|
|
Publicerad på 2015-04-10 17:22:50
|
|
|
IDictionary är basgränssnittet för en generisk samling av nyckel/värde-par, där varje par är ett nyckel-värde-par i keyValuePair-objektet.
Varje par måste ha en unik nyckel. Implementeringen skiljer sig åt i om man ska tillåta att nyckeln är en tom referens eller inte (Inget i Visual Basic). Detta värde kan vara en tom referens (Nothing i Visual Basic) och behöver inte vara unikt. IDictionary-gränssnittet möjliggör en uppräkning av nycklar och värden det innehåller, men detta innebär ingen specifik sorteringsordning.
Foreach-satsen i C#-språket (For Each i Visual Basic och för each i C++) kräver typen av varje element i samlingen. Eftersom varje element i IDictionary är ett nyckel/värde-par är elementtypen varken en typ av nyckel eller en typ av värde. Istället är det en KeyValuePair-typ.
Här är ett enkelt exempel på ett program
Entitetsklass:
namnrymddomän
{
//订单
offentlig klassordning
{
public int OrderID { get; set; }
/// <summary>
Beställningsdatum
/// </summary>
public DateTime OrderDate { get; set; }
/// <summary>
Beställningsadress
/// </summary>
public string OrderAdress { get; set; }
/// <summary>
Beställ telefon
/// </summary>
public string OrderTel { get; set; }
}
}
//订单明细
namnrymddomän
{
public class OrderDetail
{
public int DetailID { get; set; }
public int ProductID { get; set; }
/// <summary>
Kvantitet
/// </summary>
publik decimal Quantity { get; set; }
/// <summary>
Enhetspris
/// </summary>
publik decimal Price { get; set; }
}
}
//存放数据
med System;
med System.Collections.Generic;
med System.Linq;
med System.Text;
med hjälp av Domain;
namnrymdstjänst
{
offentlig statisk klass OrderStock
{
privat statisk IList<Order> m_orderList = ny Lista<Order>(); Definiera ett generiskt fält för en lista
publik statisk IList<Order> OrderList// definierar en generisk egenskap hos en List
{
Hämta
{
återvända m_orderList;
}
Set
{
m_orderList = värde;
}
}
privat statisk IDictionary<Order, IList<OrderDetail>> m_orders = ny Dictionary<Order, IList<OrderDetail>>();
//定义了一个Dictionary的泛型字段，
publik statisk IDictionary<Order, IList<OrderDetail>> Orders/ definierar en generisk egenskap hos en ordbok
{
Hämta
{
återvända m_orders;
}
Set
{
m_orders = värde;
}
}
}
}
Tjänstegränssnitt
med System;
med hjälp av Domain;
namnrymdstjänst
{
publikt gränssnitt IOrderService
{
//删除
void Delete(Domain.Order-entitet);
Fråga alla
System.Collections.Generic.IList<Domain.Order> LoadAll();
//保存
objekt Save(Domän.Order-entitet);
//更新
void Update(Domain.Order-entitet);
Sök efter ID
Order Get (objekt-id);
//获取下一个ID
objekt GetNextID();
}
namnrymdstjänst
{
publikt gränssnitt IOrderDetailService
{
void Delete(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entitet);
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();
objekt Save(Domain.Order-entitet, System.Collections.Generic.IList<Domain.OrderDetail> detalj);
void Update(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entitet);
}
}
Tjänsterealisering
med System;
med System.Collections.Generic;
med System.Linq;
med System.Text;
med hjälp av Domain;
namnrymdstjänst
{
offentlig klass OrderService : IOrderService
{
offentlig IList<Order> LoadAll()
{
var list = OrderStock.OrderList;
återvändolista;
}
publikt objekt GetNextID()
{
int id = 1;
om (OrderStock.OrderList.Count > 0)
{
id = OrderStock.OrderList.Max(m => m.OrderID) + 1;
}
Return ID;
}
publikt objekt Spara (Order entity)
{
OrderStock.OrderList.Add (enhet);
Returnerande entitet. OrderID;
}
public void Uppdatering (Order-enhet)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID);
om (lista. Räkning<Order>() > 0)
{
Ordning = lista. Första();
OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)] = enhet;
}
}
public order get(objekt-id)
{
Ordningsenhet = null;
var list = OrderStock.OrderList.Where(w => w.OrderID == (int)id);
om (lista. Räkning<Order>() > 0)
{
Ordning = lista. Första();
enhet = OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)];
}
returnerande enhet;
}
offentlig tomhet Radera (Order-enhet)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID);
om (lista. Räkning<Order>() > 0)
{
Ordning = lista. Första();
OrderStock.OrderList.Remove(order);
}
}
}
}
med System;
med System.Collections.Generic;
med System.Linq;
med System.Text;
med hjälp av Domain;
namnrymdstjänst
{
publik klass OrderDetailService : IOrderDetailService
{
public IDictionary<Order, IList<OrderDetail>> LoadAll()
{
var dic = OrderStock.Orders;
returnera DIC;
}
publikt objekt GetNextID()
{
int id = 1;
om (OrderStock.Orders.Count > 0)
{
id = OrderStock.Orders.Max(m => m.Key.OrderID) + 1;
}
Return ID;
}
publikt objekt GetNextDetailID (objekt mainID)
{
int id = 1;
var dic = OrderStock.Orders.Where(w => w.Key.OrderID == (int)mainID);
om (dic.Count<KeyValuePair<Order, IList<OrderDetail>>>() > 0)
{
var-objekt = dic.First();
VAR List = Föremål. Value.Where(w => w.DetailID == (int)mainID);
om (lista. Räkna<OrderDetail>() > 0)
{
id = lista. Först(). DetailID + 1;
}
}
Return ID;
}
offentligt objekt Spara (Order entity, IList<OrderDetail> detalj)
{
objektresultat = null;
om (! OrderStock.Orders.ContainsKey(entity))
{
OrderStock.Orders.Add (enhet, detalj);
resultat = entitet. OrderID;
}
återvändande resultat;
}
public void Update(KeyValuePair<Order, IList<OrderDetail>> entity)
{
om (OrderStock.Orders.ContainsKey(entity. Nyckel))
{
OrderStock.Orders[entity. nyckel] = entitet. Värde;
}
}
publik KeyValuePair<Order, IList<OrderDetail>> Get(object id)
{
KeyValuePair<Order, IList<OrderDetail>> entity = ny KeyValuePair<Order, IList<OrderDetail>>();
var dic = OrderStock.Orders.Where(w => w.Key.OrderID == (int)id);
om (dic.Count<KeyValuePair<Order, IList<OrderDetail>>>() > 0)
{
entitet = dic.First();
}
returnerande enhet;
}
public void Delete(KeyValuePair<Order, IList<OrderDetail>> entity)
{
om (OrderStock.Orders.ContainsKey(entity. Nyckel))
{
OrderStock.Orders.Remove(entity. Nyckel);
}
}
}
}
Test
med System;
med System.Collections.Generic;
med System.Linq;
med System.Text;
med hjälp av NUnit.Framework;
använda Service;
med hjälp av Domain;
namnrymden ServiceTest
{
[TestFixture]
offentlig klass OrderServiceTest
{
privat IOrderService m_service;
[Uppställning]
public void Init()
{
m_service = ny OrderService();
}
[Test]
offentlig tomrum LoadAllTest()
{
var list= m_service. LoadAll();
Foreach (VAR-punkt i listan)
{
Console.WriteLine(item. OrderID);
Console.WriteLine(item. OrderAdress);
Console.WriteLine(item. OrderDate);
Console.WriteLine(item. OrderTel);
}
Assert.IsNotNull(list);
}
[Test]
public void Save()
{
Orderentitet = ny Order()
{
OrderID = (int)m_service. GetNextID(),
OrderDate = DateTime.Now.AddDays(-1),
OrderAdress = "Urumqi",
OrderTel = "123123"
};
objekt obj = m_service. Spara(entitet);
Assert.IsNotNull(obj);
}
[Test]
public void Uppdatering()
{
Orderentitet = m_service. Get(1);
entitet. OrderAdress = "Korla";
m_service. Uppdatering(entitet);
}
[Test]
public void Delete()
{
Orderentitet = m_service. Get(1);
entitet. OrderAdress = "Korla";
m_service. Delete(entitet);
}
}
}
med System;
med System.Collections.Generic;
med System.Linq;
med System.Text;
med hjälp av NUnit.Framework;
använda Service;
med hjälp av Domain;
namnrymden ServiceTest
{
[TestFixture]
offentlig klass OrderServiceDetailTest
{
privat IOrderDetailService m_service;
[Uppställning]
public void Init()
{
m_service = ny OrderDetailService();
}
[Test]
offentlig tomrum LoadAllTest()
{
var list= m_service. LoadAll();
Foreach (VAR-punkt i listan)
{
Console.WriteLine("-------------- Order ----------");
Console.WriteLine(item. Nyckel.OrderID);
Console.WriteLine(item. Key.OrderAddress);
Console.WriteLine(item. Key.OrderDate);
Console.WriteLine(item. Key.OrderTel);
Console.WriteLine ("-------------- ordningsdetalj ----------");
foreach (var li in item. Värde)
{
Console.WriteLine(li.DetailID);
Console.WriteLine(li.Price);
Console.WriteLine(li.Quantity);
Console.WriteLine(li.ProductID);
}
}
Assert.IsNotNull(list);
}
[Test]
public void Save()
{
int id = (int)m_service. GetNextID();
Orderentitet = ny Order()
{
OrderID = id,
OrderDate = DateTime.Now.AddDays(-1),
OrderAdress = "Urumqi",
OrderTel = "123123"
};
IList<OrderDetail> list = ny List<OrderDetail>();
för (int i = 0; Jag < 3; i++)
{
lista. Add(new OrderDetail() {
DetailID = i + 1,
Price=10+i,
Kvantitet=i+100,
ProductID = 1000 + i
});
}
objekt obj = m_service. Spara (entitet, lista);
Assert.IsNotNull(obj);
}
[Test]
public void Uppdatering()
{
var entity = m_service. Get(1);
entitet. Value[0] = ny OrderDetail()
{
ProductID = 1000,
DetailID = 1,
Pris = 13,34 Mio.
Mängd = 200,1 miljoner
};
m_service. Uppdatering(entitet);
}
[Test]
public void Delete()
{
var entity = m_service. Get(1);
m_service. Delete(entitet);
}
}
}
Obs: Du behöver referera till verktyget nunit.framework när du testar |
Föregående:Dela två CC-attackverktyg, bra för stresstestningNästa:Bi Fujian skickade ut ett ursäktsbrev på Weibo: Jag känner mig väldigt skyldig och ledsen
|
