|
|
Veröffentlicht am 10.04.2015 17:22:50
|
|
|
IDictionary ist die Basisschnittstelle für eine generische Sammlung von Schlüssel-/Wertpaaren, von denen jedes ein Schlüssel-Wert-Paar im keyValuePair-Objekt ist.
Jedes Paar muss einen einzigartigen Schlüssel besitzen. Die Implementierung unterscheidet sich darin, ob der Schlüssel als leere Referenz zugelassen wird oder nicht (Nichts in Visual Basic). Dieser Wert kann eine leere Referenz sein (nichts in Visual Basic) und muss nicht eindeutig sein. Die IDictionary-Schnittstelle erlaubt eine Aufzählung der Schlüssel und Werte, die sie enthält, aber dies impliziert keine spezifische Sortierreihenfolge.
Die foreach-Anweisung in der C#-Sprache (For Each in Visual Basic und for each in C++) benötigt den Typ jedes Elements in der Sammlung. Da jedes Element des IDictionary ein Schlüssel/Wert-Paar ist, ist der Elementtyp weder ein Schlüsseltyp noch ein Werttyp. Stattdessen handelt es sich um einen KeyValuePair-Typ.
Hier ist ein einfaches Beispielprogramm
Entitätsklasse:
Namensraum Domain
{
//订单
Ordnung der öffentlichen Klasse
{
public int OrderID { get; Set; }
/// <summary>
Bestelldatum
/// </summary>
public DateTime OrderDate { get; Set; }
/// <summary>
Bestelladresse
/// </summary>
public string OrderAdress { get; Set; }
/// <summary>
Bestellen Sie Telefon
/// </summary>
public string OrderTel { get; Set; }
}
}
//订单明细
Namensraum Domain
{
öffentliche Klasse OrderDetail
{
public int DetailID { get; Set; }
public int ProductID { get; Set; }
/// <summary>
Menge
/// </summary>
öffentliche Dezimalmenge { get; Set; }
/// <summary>
Einheitspreis
/// </summary>
öffentliche Dezimalzahl Price { get; Set; }
}
}
//存放数据
mit System;
mit System.Collections.Generic;
mit System.Linq;
mit System.Text;
unter Verwendung von Domain;
Namensraumdienst
{
öffentliche statische Baureihe OrderStock
{
private statische IList<Order> m_orderList = neue Liste<Order>(); Definiere ein generisches Feld für eine Liste
öffentliche statische<Order> IList OrderList// definiert eine generische Eigenschaft einer Liste
{
Erhalten
{
m_orderList zurückkehren;
}
Set
{
m_orderList = Wert;
}
}
private statische IDictionary<Order, IList<OrderDetail>> m_orders = neues Wörterbuch<Order, IList<OrderDetail>>();
//定义了一个Dictionary的泛型字段，
öffentliche statische IDictionary<Order, IList<OrderDetail>> Orders/ definiert eine generische Eigenschaft eines Wörterbuchs
{
Erhalten
{
m_orders zurückkehren;
}
Set
{
m_orders = Wert;
}
}
}
}
Service-Schnittstellen
mit System;
unter Verwendung von Domain;
Namensraumdienst
{
öffentliche Schnittstelle IOrderService
{
//删除
void Delete (Domain.Order-Entität);
Abfrage alle
System.Collections.Generic.IList<Domain.Order> LoadAll();
//保存
Objekt Save(Domain.Order-Entität);
//更新
void Update (Domain.Order-Entität);
Abfrage nach ID
Order Get (Objekt-ID);
//获取下一个ID
Objekt GetNextID();
}
Namensraumdienst
{
öffentliche Schnittstelle IOrderDetailService
{
void Delete(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> Entität);
System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> Get(object id);
Objekt GetNextDetailID (Objekt mainID);
Objekt GetNextID();
System.Collections.Generic.IDictionary<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> LoadAll();
object Save(Domain.Order-Entität, System.Collections.Generic.IList<Domain.OrderDetail> detail);
void Update(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> Entität);
}
}
Servicerealisierung
mit System;
mit System.Collections.Generic;
mit System.Linq;
mit System.Text;
unter Verwendung von Domain;
Namensraumdienst
{
öffentliche Klasse OrderService : IOrderService
{
öffentliche<Order> IList LoadAll()
{
var list = OrderStock.OrderList;
Rückkehrliste;
}
öffentliches Objekt GetNextID()
{
int id = 1;
if (OrderStock.OrderList.Count > 0)
{
id = OrderStock.OrderList.Max(m => m.OrderID) + 1;
}
Rücksendungs-ID;
}
öffentliches Objekt Save(Order-Entität)
{
OrderStock.OrderList.Add(Entität);
Kehrende Entität zurück. OrderID;
}
Public Void Update (Order-Einheit)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == Entität. OrderID);
wenn (Liste. Count<Order>() > 0)
{
Bestellreihenfolge = Liste. Erstens();
OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)] = Entität;
}
}
öffentliche Ordnung Get(Objekt-ID)
{
Ordnungsentität = null;
var list = OrderStock.OrderList.Where(w => w.OrderID == (int)id);
wenn (Liste. Count<Order>() > 0)
{
Bestellreihenfolge = Liste. Erstens();
Entität = OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)];
}
Rücksendungsentität;
}
public void Löschen (Order-Entity)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == Entität. OrderID);
wenn (Liste. Count<Order>() > 0)
{
Bestellreihenfolge = Liste. Erstens();
OrderStock.OrderList.Remove(bestellen);
}
}
}
}
mit System;
mit System.Collections.Generic;
mit System.Linq;
mit System.Text;
unter Verwendung von Domain;
Namensraumdienst
{
öffentliche Klasse OrderDetailService : IOrderDetailService
{
öffentliche IDictionary<Order, IList<OrderDetail>> LoadAll()
{
var dic = OrderStock.Orders;
Geben Sie DIC zurück;
}
öffentliches Objekt GetNextID()
{
int id = 1;
if (OrderStock.Orders.Count > 0)
{
id = OrderStock.Orders.Max(m => m.Key.OrderID) + 1;
}
Rücksendungs-ID;
}
öffentliches Objekt GetNextDetailID (Objekt mainID)
{
int id = 1;
var dic = OrderStock.Orders.Where(w => w.Key.OrderID == (int)mainID);
wenn (dic.Count<KeyValuePair<Order, IList<OrderDetail>>>() > 0)
{
var Item = dic.First();
VAR List = Element. Value.Where(w => w.DetailID == (int)mainID);
wenn (Liste. Count<OrderDetail>() > 0)
{
id = Liste. Erst(). DetailID + 1;
}
}
Rücksendungs-ID;
}
öffentliches Objekt Speichern(Order-Entität, IList-Detail<OrderDetail>)
{
Objektergebnis = null;
wenn (! OrderStock.Orders.EnthältKey(entity))
{
OrderStock.Orders.Add(Entität, Detail);
Ergebnis = Entität. OrderID;
}
Rückgabeergebnis;
}
public void Update(KeyValuePair<Order, IList<OrderDetail>> Entität)
{
wenn (OrderStock.Orders.ContainsKey(entity. Schlüssel))
{
OrderStock.Orders[entity. Schlüssel] = Entität. Wert;
}
}
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);
wenn (dic.Count<KeyValuePair<Order, IList<OrderDetail>>>() > 0)
{
Entität = dic.First();
}
Rücksendungsentität;
}
public void Delete(KeyValuePair<Order, IList<OrderDetail>> Entität)
{
wenn (OrderStock.Orders.ContainsKey(entity. Schlüssel))
{
OrderStock.Orders.Remove(Entität. Schlüssel);
}
}
}
}
Test
mit System;
mit System.Collections.Generic;
mit System.Linq;
mit System.Text;
mit NUnit.Framework;
Nutzung von Service;
unter Verwendung von Domain;
Namensraum ServiceTest
{
[TestFixture]
öffentliche Klasse OrderServiceTest
{
private IOrderService m_service;
[Aufbau]
öffentlicher Void Init()
{
m_service = neuer OrderService();
}
[Test]
öffentliche Void LoadAllTest()
{
var list= m_service. LoadAll();
foreach (VAR-Element in der Liste)
{
Console.WriteLine(item. OrderID);
Console.WriteLine(item. OrderAdresse);
Console.WriteLine(item. OrderDate);
Console.WriteLine(item. OrderTel);
}
Assert.IsNotNull(list);
}
[Test]
öffentliche Leere Speichern()
{
Order-Entität = neue Order()
{
OrderID = (int)m_service. GetNextID(),
OrderDate = DateTime.Now.AddDays(-1),
OrderAdress = "Urumqi",
OrderTel = "123123"
};
Objekt obj = m_service. Speicherstand (Entität);
Assert.IsNotNull(obj);
}
[Test]
Public Void Update()
{
Ordnungsentität = m_service. Get(1);
Entität. OrderAdress = "Korla";
m_service. Update(Entität);
}
[Test]
public void Löschen()
{
Ordnungsentität = m_service. Get(1);
Entität. OrderAdress = "Korla";
m_service. Delete(Entität);
}
}
}
mit System;
mit System.Collections.Generic;
mit System.Linq;
mit System.Text;
mit NUnit.Framework;
Nutzung von Service;
unter Verwendung von Domain;
Namensraum ServiceTest
{
[TestFixture]
öffentliche Klasse OrderServiceDetailTest
{
private IOrderDetailService m_service;
[Aufbau]
öffentlicher Void Init()
{
m_service = neuer OrderDetailService();
}
[Test]
öffentliche Void LoadAllTest()
{
var list= m_service. LoadAll();
foreach (VAR-Element in der Liste)
{
Console.WriteLine("-------------- Order ----------");
Console.WriteLine(item. Key.OrderID);
Console.WriteLine(item. Key.OrderAdresse);
Console.WriteLine(item. Key.OrderDate);
Console.WriteLine(item. Key.OrderTel);
Console.WriteLine("-------------- Order Detail ----------");
foreach (var li in item. Wert)
{
Console.WriteLine(li.DetailID);
Console.WriteLine (li.Price);
Console.WriteLine(li.Quantity);
Console.WriteLine(li.ProductID);
}
}
Assert.IsNotNull(list);
}
[Test]
öffentliche Leere Speichern()
{
int id = (int)m_service. GetNextID();
Order-Entität = neue Order()
{
OrderID = id,
OrderDate = DateTime.Now.AddDays(-1),
OrderAdress = "Urumqi",
OrderTel = "123123"
};
IList<OrderDetail> list = neue Liste<OrderDetail>();
für (int i = 0; Ich < 3; i++)
{
Liste. Add(new OrderDetail() {
DetailID = i + 1,
Price=10+i,
Quantität=i+100,
ProductID = 1000 + i
});
}
Objekt obj = m_service. Speicherstand (Entität, Liste);
Assert.IsNotNull(obj);
}
[Test]
Public Void Update()
{
var entity = m_service. Get(1);
Entität. Value[0] = neuer OrderDetail()
{
ProductID = 1000,
DetailID = 1,
Preis = 13,34 M,
Menge = 200,1 Mio.
};
m_service. Update(Entität);
}
[Test]
public void Löschen()
{
var entity = m_service. Get(1);
m_service. Delete(Entität);
}
}
}
Hinweis: Du musst beim Testen auf das nunit.framework-Tool zurückgreifen |
Vorhergehend:Teilen Sie sich zwei CC-Angriffstools, gut zum StresstestenNächster:Bi Fujian hat einen Entschuldigungsbrief auf Weibo veröffentlicht: Ich fühle mich sehr schuldig und traurig
|
