|
|
Pubblicato su 10/04/2015 17:22:50
|
|
|
IDictionary è l'interfaccia base per una collezione generica di coppie chiave/valore, ciascuna delle quali è una coppia chiave-valore nell'oggetto keyValuePair.
Ogni coppia deve avere una chiave unica. L'implementazione differisce nel permettere o meno che la chiave sia un riferimento vuoto (Nothing in Visual Basic). Questo valore può essere un riferimento vuoto (Niente in Visual Basic) e non deve essere per forza unico. L'interfaccia IDictionary consente di enumerare le chiavi e i valori che contiene, ma ciò non implica un ordine di ordinamento specifico.
L'istruzione foreach nel linguaggio C# (For Each in Visual Basic e per each in C++) richiede il tipo di ciascun elemento nella collezione. Poiché ogni elemento di IDictionary è una coppia chiave/valore, il tipo di elemento non è né un tipo di chiave né un tipo di valore. Invece, è un tipo KeyValuePair.
Ecco un semplice esempio di programma
Classe di entità:
Spazio dei nomi Dominio
{
//订单
Ordine di classe pubblica
{
public int OrderID { get; set; }
/// <summary>
Data dell'ordine
/// </summary>
Public DateTime OrderDate { get; set; }
/// <summary>
Indirizzo dell'ordine
/// </summary>
stringa pubblica OrderAdress { get; set; }
/// <summary>
Ordina telefono
/// </summary>
stringa pubblica OrderTel { get; set; }
}
}
//订单明细
Spazio dei nomi Dominio
{
classe pubblica OrdineDettaglio
{
public int DetailID { get; set; }
public int ProductID { get; set; }
/// <summary>
Quantità
/// </summary>
decimale pubblico Quantità { get; set; }
/// <summary>
Prezzo unitario
/// </summary>
decimale pubblico Price { get; set; }
}
}
//存放数据
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domain;
Servizio namespace
{
classe statica pubblica OrderStock
{
IList statico<Order> privato m_orderList = nuova Lista<Order>(); Definisci un campo generico per una Lista
IList statico<Order> pubblico OrderList// definisce una proprietà generica di una Lista
{
Ottieni
{
ritorno m_orderList;
}
Set
{
m_orderList = valore;
}
}
privato statico IDictionary<Order, IList<OrderDetail>> m_orders = nuovo Dizionario<Ordine, IList<OrderDetail>>();
//定义了一个Dictionary的泛型字段，
Identificazione statica pubblica<Order, IList<OrderDetail>> Orders/ definisce una proprietà generica di un dizionario
{
Ottieni
{
ritorno m_orders;
}
Set
{
m_orders = valore;
}
}
}
}
Interfacce di servizio
usando Sistema;
usando Domain;
Servizio namespace
{
interfaccia pubblica IOrderService
{
//删除
void Delete (entità Domain.Order);
Interroga tutti
System.Collections.Generic.IList<Domain.Order> LoadAll();
//保存
oggetto Save(entità Domain.Order);
//更新
void Update (entità Domain.Order);
Query per ID
Order Get(id oggetto);
//获取下一个ID
oggetto GetNextID();
}
Servizio namespace
{
interfaccia pubblica 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(object id);
oggetto GetNextDetailID(oggetto mainID);
oggetto GetNextID();
System.Collections.Generic.IDictionary<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> LoadAll();
object Save (entità Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail> dettaglio);
null Update(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entità);
}
}
Realizzazione del servizio
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domain;
Servizio namespace
{
Servizio di Ordine di classe pubblica: Servizio di Ordine
{
pubblico<Order> IList LoadAll()
{
var list = OrderStock.OrderList;
elenco dei ritorni;
}
oggetto pubblico GetNextID()
{
int id = 1;
if (OrderStock.OrderList.Count > 0)
{
id = OrderStock.OrderList.Max(m => m.OrderID) + 1;
}
restituisci ID;
}
oggetto pubblico Salvezza (entità dell'Ordine)
{
OrderStock.OrderList.Add(entità);
Restituisci l'entità. OrderID;
}
Aggiornamento di vuoto pubblico (entità dell'Ordine)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entità. OrderID);
se (lista. Count<Order>() > 0)
{
Ordine ordine = lista. Prima();
OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)] = entità;
}
}
Ordine pubblico Get(oggetto id)
{
entità d'ordine = nulla;
var list = OrderStock.OrderList.Where(w => w.OrderID == (int)id);
se (lista. Count<Order>() > 0)
{
Ordine ordine = lista. Prima();
entità = OrdineStock.ListaOrdine[OrdineStock.ListaOrdine.IndiceIndiceDie(ordine)];
}
restituire entità;
}
Vuoto pubblico Elimina (entità di ordine)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entità. OrderID);
se (lista. Count<Order>() > 0)
{
Ordine ordine = lista. Prima();
OrdineStock.ListaOrdine.Rimuove(ordine);
}
}
}
}
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domain;
Servizio namespace
{
Ordine di classe pubblica OrderDetailService : IOrderDetailService
{
Identificativo pubblico<Ordine, IList<OrderDetail>> LoadAll()
{
var dic = OrderStock.Orders;
Ritorno Dic;
}
oggetto pubblico GetNextID()
{
int id = 1;
if (OrderStock.Orders.Count > 0)
{
id = OrderStock.Orders.Max(m => m.Key.OrderID) + 1;
}
restituisci ID;
}
oggetto pubblico GetNextDetailID(oggetto mainID)
{
int id = 1;
var dic = OrderStock.Orders.Where(w => w.Key.OrderID == (int)mainID);
if (dic.Count<KeyValuePair<Order, IList<OrderDetail>>>() > 0)
{
var item = dic.First();
Lista VAR = Elemento. Value.Where(w => w.DetailID == (int)mainID);
se (lista. Count<OrderDetail>() > 0)
{
id = lista. First(). DetailID + 1;
}
}
restituisci ID;
}
Salvezza di oggetto pubblico (Entità dell'ordine,<OrderDetail> dettaglio IList)
{
risultato oggetto = nullo;
se (! OrderStock.Orders.ContainsKey(entity))
{
OrderStock.Orders.Add(entità, dettaglio);
risultato = entità. OrderID;
}
risultato di ritorno;
}
Public void Update(KeyValuePair<Order, <OrderDetail>IList> entità)
{
if if (OrderStock.Orders.ContainsKey(entity. Tonalità))
{
OrderStock.Orders[entity. Tonalità] = entità. Valore;
}
}
public KeyValuePair<Order, IList<OrderDetail>> Get(object id)
{
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, IList<OrderDetail>>>() > 0)
{
entità = dic.First();
}
restituire entità;
}
public void Delete(KeyValuePair<Order, <OrderDetail>IList> entità)
{
if if (OrderStock.Orders.ContainsKey(entity. Tonalità))
{
OrderStock.Orders.Remove(entità. Tonalità);
}
}
}
}
Test
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
utilizzando NUnit.Framework;
uso del Servizio;
usando Domain;
Namespace ServiceTest
{
[TestFitture]
Classe pubblica OrderServiceTest
{
m_service privato IOrderService;
[SetUp]
public void Init()
{
m_service = nuovo OrderService();
}
[Test]
vuoto pubblico LoadAllTest()
{
var list= m_service. LoadAll();
foreach (elemento var nella lista)
{
Console.WriteLine(elemento. OrderID);
Console.WriteLine(elemento. OrderAdress);
Console.WriteLine(elemento. OrderDate);
Console.WriteLine(elemento. OrderTel);
}
Assert.IsNotNull(lista);
}
[Test]
vuoto pubblico Salva()
{
Entità Ordine = nuovo Ordine()
{
OrderID = (int)m_service. GetNextID(),
OrderDate = DateTime.Now.AddDays(-1),
OrderAdress = "Urumqi",
OrderTel = "123123"
};
oggetto obj = m_service. Salvezza (entità);
Assert.IsNotNull(obj);
}
[Test]
Aggiornamento sull'ambiente pubblico ()
{
Entità d'ordine = m_service. Get(1);
entità. OrderAdress = "Korla";
m_service. Aggiornamento(entità);
}
[Test]
public void Delete()
{
Entità d'ordine = m_service. Get(1);
entità. OrderAdress = "Korla";
m_service. Elimina(entità);
}
}
}
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
utilizzando NUnit.Framework;
uso del Servizio;
usando Domain;
Namespace ServiceTest
{
[TestFitture]
classe pubblica OrderServiceDetailTest
{
m_service privata IOrderDetailService;
[SetUp]
public void Init()
{
m_service = nuovo OrderDetailService();
}
[Test]
vuoto pubblico LoadAllTest()
{
var list= m_service. LoadAll();
foreach (elemento var nella lista)
{
Console.WriteLine("-------------- Order ----------");
Console.WriteLine(elemento. Key.OrderID);
Console.WriteLine(elemento. Key.OrderAdress);
Console.WriteLine(elemento. Key.OrderDate);
Console.WriteLine(elemento. Key.OrderTel);
Console.WriteLine("-------------- Dettaglio Ordine ----------");
Foreach (var li in item. Valore)
{
Console.WriteLine(li.DetailID);
Console.WriteLine(li.Price);
Console.WriteLine(li.Quantity);
Console.WriteLine(li.ProductID);
}
}
Assert.IsNotNull(lista);
}
[Test]
vuoto pubblico Salva()
{
int id = (int)m_service. GetNextID();
Entità Ordine = nuovo Ordine()
{
OrderID = id,
OrderDate = DateTime.Now.AddDays(-1),
OrderAdress = "Urumqi",
OrderTel = "123123"
};
<OrderDetail> IList list = nuova lista<OrderDetail>();
per (int i = 0; Ho < 3; i++)
{
lista. Add(new OrderDetail() {
DetailID = i + 1,
Prezzo=10+i,
Quantità=i+100,
ProductID = 1000 + i
});
}
oggetto obj = m_service. Salvezza (entità, lista);
Assert.IsNotNull(obj);
}
[Test]
Aggiornamento sull'ambiente pubblico ()
{
entità var = m_service. Get(1);
entità. Value[0] = nuovo OrderDetail()
{
ProductID = 1000,
DetailID = 1,
Prezzo = 13,34M,
Quantità = 200,1M
};
m_service. Aggiornamento(entità);
}
[Test]
public void Delete()
{
entità var = m_service. Get(1);
m_service. Elimina(entità);
}
}
}
Nota: Devi fare riferimento allo strumento nunit.framework durante i test |
Precedente:Condividi due strumenti di attacco CC, buoni per i test di stressProssimo:Bi Fujian ha pubblicato una lettera di scuse su Weibo: Mi sento molto in colpa e triste
|
