|
|
Publié sur 10/04/2015 17:22:50
|
|
|
IDictionary est l’interface de base pour une collection générique de paires clé/valeur, chacune étant une paire clé-valeur dans l’objet keyValuePair.
Chaque paire doit avoir une clé unique. L’implémentation diffère quant à la possibilité ou non de permettre à la clé d’être une référence vide (Nothing in Visual Basic). Cette valeur peut être une référence vide (rien dans Visual Basic) et n’a pas besoin d’être unique. L’interface IDictionary permet une énumération des clés et des valeurs qu’elle contient, mais cela n’implique pas d’ordre de tri spécifique.
L’instruction foreach dans le langage C# (For Each en Visual Basic et pour each en C++) nécessite le type de chaque élément de la collection. Puisque chaque élément d’IDictionnaire est une paire clé/valeur, le type d’élément n’est ni un type de clé ni un type de valeur. À la place, c’est un type KeyValuePair.
Voici un exemple simple de programme
Classe d’entité :
Domaine d’espace de noms
{
//订单
Ordre de classe publique
{
public int OrderID { get ; set ; }
/// <summary>
Date de commande
/// </summary>
public DateTime OrderDate { get ; set ; }
/// <summary>
Adresse de la commande
/// </summary>
chaîne publique OrderAdress { get ; set ; }
/// <summary>
Commande téléphone
/// </summary>
chaîne publique OrderTel { get ; set ; }
}
}
//订单明细
Domaine d’espace de noms
{
classe publique OrdreDétail
{
public int DetailID { get ; set ; }
public int ProductID { get ; set ; }
/// <summary>
Quantité
/// </summary>
Quantité décimale publique { get ; set ; }
/// <summary>
Prix unitaire
/// </summary>
décimale publique Price { get ; set ; }
}
}
//存放数据
utilisant System ;
utilisant System.Collections.Generic ;
utilisant System.Linq ;
en utilisant System.Text ;
utilisant Domaine ;
Service d’espace de noms
{
classe statique publique OrderStock
{
IList statique<Order> privé m_orderList = nouvelle <Order>Liste() ; Définissez un champ générique pour une liste
IList statique<Order> public OrderList// définit une propriété générique d’une Liste
{
Avoir
{
retour m_orderList ;
}
Ensemble
{
m_orderList = valeur ;
}
}
identifiant statique privé<Order, <OrderDetail>IList> m_orders = nouveau Dictionary<Order, IList<OrderDetail>>() ;
//定义了一个Dictionary的泛型字段，
public static IDictionary<Order, IList<OrderDetail>> Orders/ définit une propriété générique d’un dictionnaire
{
Avoir
{
retour m_orders ;
}
Ensemble
{
m_orders = valeur ;
}
}
}
}
Interfaces de service
utilisant System ;
utilisant Domaine ;
Service d’espace de noms
{
interface publique IOrderService
{
//删除
void Delete (entité Domain.Order) ;
Interroger tout
System.Collections.Generic.IList<Domain.Order> LoadAll() ;
//保存
objet Save(entité Domain.Order) ;
//更新
void Update (entité Domain.Order) ;
Requête par ID
Order Get (id d’objet) ;
//获取下一个ID
objet GetNextID() ;
}
Service d’espace de noms
{
interface publique IOrderDetailService
{
void Delete (System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entité) ;
System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> Get(id d’objet) ;
objet GetNextDetailID(objet mainID) ;
objet GetNextID() ;
System.Collections.Generic.IDictionary<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> LoadAll() ;
objet Save(entité Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail> détail) ;
void Update(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entité) ;
}
}
Réalisation du service
utilisant System ;
utilisant System.Collections.Generic ;
utilisant System.Linq ;
en utilisant System.Text ;
utilisant Domaine ;
Service d’espace de noms
{
Service d’ordre de classe publique : Ordre de classe publique : Service d’Ordre
{
IList public<Order> LoadAll()
{
var list = OrderStock.OrderList ;
liste de retour ;
}
objet public GetNextID()
{
int id = 1 ;
if (OrderStock.OrderList.Count > 0)
{
id = OrderStock.OrderList.Max(m => m.OrderID) + 1 ;
}
Retour d’ID ;
}
Objet public Sauvegarder (Entité d’ordre)
{
OrderStock.OrderList.Add(entité) ;
Retourner l’entité. OrderID ;
}
Mise à jour de l’annulation publique (entité de l’Ordre)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID) ;
si (liste. Compte<Order>() > 0)
{
Ordre d’ordre = liste. Premièrement() ;
OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)] = entité ;
}
}
Ordre public Get(objet id)
{
Entité d’ordre = nulle ;
var list = OrderStock.OrderList.Where(w => w.OrderID == (int)id) ;
si (liste. Compte<Order>() > 0)
{
Ordre d’ordre = liste. Premièrement() ;
entité = OrdreStock.ListeCommande[OrdreStock.ListeOrdreIndexD(ordre)] ;
}
retourner l’entité ;
}
Invalidité publique Supprimer (entité de commande)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID) ;
si (liste. Compte<Order>() > 0)
{
Ordre d’ordre = liste. Premièrement() ;
CommanderStock.ListeCommande.Retire(ordre) ;
}
}
}
}
utilisant System ;
utilisant System.Collections.Generic ;
utilisant System.Linq ;
en utilisant System.Text ;
utilisant Domaine ;
Service d’espace de noms
{
Public Class OrderDetailService : IOrderDetailService
{
Identification publique<Ordre, <OrderDetail>IList> LoadAll()
{
var dic = OrderStock.Orders ;
Retour à Dic ;
}
objet public GetNextID()
{
int id = 1 ;
if (OrderStock.Orders.Count > 0)
{
id = OrderStock.Orders.Max(m = > m.Key.OrderID) + 1 ;
}
Retour d’ID ;
}
objet public GetNextDetailID(objet mainID)
{
int id = 1 ;
var dic = OrderStock.Orders.Where(w => w.Key.OrderID == (int)mainID) ;
if (dic.Count<KeyValuePair<Order, <OrderDetail>IList>>() > 0)
{
item var = dic.First() ;
Liste VAR = Item. Value.Where(w => w.DetailID == (int)mainID) ;
si (liste. Compte<OrderDetail>() > 0)
{
id = liste. First(). DetailID + 1 ;
}
}
Retour d’ID ;
}
Sauvegarde d’objet public (Entité d’ordre,<OrderDetail> détail IList)
{
résultat objet = nul ;
si ( ! OrderStock.Orders.ContainsKey(entity))
{
OrderStock.Orders.Add(entité, détail) ;
résultat = entité. OrderID ;
}
résultat de retour ;
}
public void Update(KeyValuePair<Order, <OrderDetail>IList> entity)
{
si (OrderStock.Orders.ContainsKey(entity. Clémen)
{
OrderStock.Orders[entity. Clé] = entité. Valeur ;
}
}
public KeyValuePair<Order, <OrderDetail>IList> Get(id d’objet)
{
KeyValuePair<Order, IList<OrderDetail>> entity = new KeyValuePair<Order, IList<OrderDetail>>() ;
var dic = OrderStock.Orders.Where(w => w.Key.OrderID == (int)id) ;
if (dic.Count<KeyValuePair<Order, <OrderDetail>IList>>() > 0)
{
entité = dic.First() ;
}
retourner l’entité ;
}
public void Supprimer(KeyValuePair<Order, <OrderDetail>IList> entité)
{
si (OrderStock.Orders.ContainsKey(entity. Clémen)
{
OrderStock.Orders.Remove(entity. Clémence ;
}
}
}
}
Test
utilisant System ;
utilisant System.Collections.Generic ;
utilisant System.Linq ;
en utilisant System.Text ;
en utilisant NUnit.Framework ;
utilisant le Service ;
utilisant Domaine ;
Espace de noms ServiceTest
{
[TestFixture]
classe publique OrderServiceTest
{
m_service privé de l’I’RderService ;
[Mise en place]
public void Init()
{
m_service = nouveau OrderService() ;
}
[Test]
public void LoadAllTest()
{
Liste var= m_service. LoadAll() ;
Foreach (élément VAR dans la liste)
{
Console.WriteLine(item. OrderID) ;
Console.WriteLine(item. OrderAdress) ;
Console.WriteLine(item. DateCommande) ;
Console.WriteLine(item. OrderTel) ;
}
Assert.IsNotNull(liste) ;
}
[Test]
Vie publique Sauvegarde()
{
Entité d’Ordre = nouvelle Ordre()
{
OrderID = (int)m_service. GetNextID(),
OrderDate = DateTime.Now.AddDays(-1),
AdresseOrdreAdresse = « Urumqi »,
OrderTel = « 123123 »
};
objet obj = m_service. Sauvegarde ;
Assert.IsNotNull(obj) ;
}
[Test]
Mise à jour sur l’annulation publique ()
{
Entité d’ordre = m_service. Get(1) ;
entité. OrderAdress = « Korla » ;
m_service. Mise à jour (entité) ;
}
[Test]
public void Supprimer()
{
Entité d’ordre = m_service. Get(1) ;
entité. OrderAdress = « Korla » ;
m_service. Supprimer (entité) ;
}
}
}
utilisant System ;
utilisant System.Collections.Generic ;
utilisant System.Linq ;
en utilisant System.Text ;
en utilisant NUnit.Framework ;
utilisant le Service ;
utilisant Domaine ;
Espace de noms ServiceTest
{
[TestFixture]
classe publique OrderServiceDetailTest
{
privé IOrderDetailService m_service ;
[Mise en place]
public void Init()
{
m_service = nouveau OrderDetailService() ;
}
[Test]
public void LoadAllTest()
{
Liste var= m_service. LoadAll() ;
Foreach (élément VAR dans la liste)
{
Console.WriteLine(« -------------- Order ----------« ) ;
Console.WriteLine(item. Key.OrderID) ;
Console.WriteLine(item. Key.OrderAdress) ;
Console.WriteLine(item. Key.OrderDate) ;
Console.WriteLine(item. Key.OrderTel) ;
Console.WriteLine(« -------------- Ordre détail ----------« ) ;
Foreach (var li dans l’item. Value)
{
Console.WriteLine(li.DetailID) ;
Console.WriteLine(li.Price) ;
Console.WriteLine(li.Quantity) ;
Console.WriteLine(li.ProductID) ;
}
}
Assert.IsNotNull(liste) ;
}
[Test]
Vie publique Sauvegarde()
{
int id = (int)m_service. GetNextID() ;
Entité d’Ordre = nouvelle Ordre()
{
OrderID = id,
OrderDate = DateTime.Now.AddDays(-1),
AdresseOrdreAdresse = « Urumqi »,
OrderTel = « 123123 »
};
<OrderDetail> IList list = nouvelle <OrderDetail>liste() ;
pour (int i = 0 ; J’ai < 3 ; i++)
{
liste. Add(new OrderDetail() {
DetailID = i + 1,
Prix=10+i,
Quantité=i+100,
ProductID = 1000 + i
});
}
objet obj = m_service. Sauvegarde (entité, liste) ;
Assert.IsNotNull(obj) ;
}
[Test]
Mise à jour sur l’annulation publique ()
{
Entité VAR = m_service. Get(1) ;
entité. Value[0] = new OrderDetail()
{
ProductID = 1000,
DetailID = 1,
Prix = 13,34M,
Quantité = 200,1 M
};
m_service. Mise à jour (entité) ;
}
[Test]
public void Supprimer()
{
Entité VAR = m_service. Get(1) ;
m_service. Supprimer (entité) ;
}
}
}
Note : Vous devez vous référer à l’outil nunit.framework lors des tests |
Précédent:Partager deux outils d’attaque CC, efficaces pour les tests de résistanceProchain:Bi Fujian a publié une lettre d’excuses sur Weibo : Je me sens très coupable et triste
|
