|
|
Publicado em 10/04/2015 17:22:50
|
|
|
IDictionary é a interface base para uma coleção genérica de pares chave/valor, cada um dos quais é um par-chave-valor no objeto keyValuePair.
Cada par deve ter uma chave única. A implementação difere quanto a permitir ou não que a chave seja uma referência vazia (Nothing in Visual Basic). Esse valor pode ser uma referência vazia (Nada no Visual Basic) e não precisa ser único. A interface IDictionary permite uma enumeração das chaves e valores que contém, mas isso não implica nenhuma ordem de ordenação específica.
A instrução foreach na linguagem C# (For Each em Visual Basic e para each em C++) requer o tipo de cada elemento na coleção. Como cada elemento do IDictionary é um par chave/valor, o tipo de elemento não é nem um tipo de chave nem um tipo de valor. Em vez disso, é um tipo KeyValuePair.
Aqui está um exemplo simples de programa
Classe de entidade:
Domínio do namespace
{
//订单
Ordem de classe pública
{
public int OrderID { get; set; }
/// <summary>
Data do pedido
/// </summary>
Public DateTime OrderDate { get; set; }
/// <summary>
Endereço da ordem
/// </summary>
string pública OrderAdress { get; set; }
/// <summary>
Telefone para encomendar
/// </summary>
string pública OrderTel { get; set; }
}
}
//订单明细
Domínio do namespace
{
Classe pública OrderDetail
{
public int DetailID { get; set; }
public int ProductID { get; set; }
/// <summary>
Quantidade
/// </summary>
decimal público Quantidade { get; set; }
/// <summary>
Preço unitário
/// </summary>
decimal público Price { get; set; }
}
}
//存放数据
usando o Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domínio;
Serviço de espaço nominal
{
classe pública estática OrderStock
{
private static<Order> IList m_orderList = nova List<Order>(); Defina um campo genérico para uma Lista
IList público<Order> estático OrderList// define uma propriedade genérica de uma Lista
{
Obter
{
retorno m_orderList;
}
Conjunto
{
m_orderList = valor;
}
}
IDictionary<Order, IList<OrderDetail>> m_orders = novo Dicionário<Ordem, IList<OrderDetail>>();
//定义了一个Dictionary的泛型字段，
IDictionary<Order, IList<OrderDetail>> Orders/ estático público define uma propriedade genérica de um dicionário
{
Obter
{
retorno m_orders;
}
Conjunto
{
m_orders = valor;
}
}
}
}
Interfaces de serviço
usando o Sistema;
usando Domínio;
Serviço de espaço nominal
{
interface pública IOrderService
{
//删除
void Delete (entidade Domain.Order);
Consultar todos
System.Collections.Generic.IList<Domain.Order> LoadAll();
//保存
objeto Save(entidade Domain.Ordem);
//更新
void Update (entidade Domain.Order);
Consulta por ID
Order Get(id de objeto);
//获取下一个ID
objeto GetNextID();
}
Serviço de espaço nominal
{
interface pública IOrderDetailService
{
void Delete(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entidade);
System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> Get(id de objeto);
objeto GetNextDetailID(objeto mainID);
objeto GetNextID();
System.Collections.Generic.IDictionary<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> LoadAll();
objeto Save(entidade Domain.Ordem, System.Collections.Generic.IList<Domínio.DetalheDeorde> detalhe);
atualização void (System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entidade);
}
}
Realização do serviço
usando o Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domínio;
Serviço de espaço nominal
{
Serviço de Ordem de Classe Pública: Serviço Superior
{
IList público<Order> LoadAll()
{
var list = OrderStock.OrderList;
lista de retorno;
}
objeto público GetNextID()
{
int id = 1;
if (OrderStock.OrderList.Count > 0)
{
id = OrderStock.OrderList.Max(m => m.OrderID) + 1;
}
devolver ID;
}
objeto público Salvar (entidade de ordem)
{
OrderStock.OrderList.Add(entidade);
Devolver a entidade. OrderID;
}
Atualização de vazio público (entidade de ordem)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID);
se (lista. <Order>Contagem() > 0)
{
Ordem de ordem = lista. Primeiro();
OrdemEstoque.ListaDeOrdem[OrdemEstoque.ListaDePedidoÍndiceOf(ordem)] = entidade;
}
}
ordem pública Get (objeto id)
{
Entidade de ordem = nula;
var list = OrderStock.OrderList.Where(w => w.OrderID == (int)id);
se (lista. <Order>Contagem() > 0)
{
Ordem de ordem = lista. Primeiro();
entidade = OrdemEstoque.ListaDeOrdem[OrdemEstoque.ListaDeOrdemÍndiceOf(ordem)];
}
retornar a entidade;
}
Exclusão pública (entidade de ordem)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID);
se (lista. <Order>Contagem() > 0)
{
Ordem de ordem = lista. Primeiro();
OrderStock.OrderList.Remove(order);
}
}
}
}
usando o Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domínio;
Serviço de espaço nominal
{
classe pública OrderDetailService: IOrderDetailService
{
Identificação pública<Ordem, IList<OrderDetail>> LoadAll()
{
var dic = OrderStock.Orders;
devolver a dic;
}
objeto público GetNextID()
{
int id = 1;
se (OrderStock.Orders.Count > 0)
{
id = OrderStock.Orders.Max(m => m.Key.OrderID) + 1;
}
devolver ID;
}
objeto público GetNextDetailID(objeto mainID)
{
int id = 1;
var dic = OrderStock.Orders.Where(w => w.Key.OrderID == (int)mainID);
if (dic.Count<KeyValuePair<Order, IList<OrderDetail>>>() > 0)
{
item var = dic.First();
Lista VAR = item. Value.Where(w => w.DetailID == (int)mainID);
se (lista. <OrderDetail>Contagem() > 0)
{
id = lista. First(). DetailID + 1;
}
}
devolver ID;
}
objeto público Salvar (entidade de ordem, detalhe IList<OrderDetail>)
{
resultado do objeto = nulo;
se (! OrdemStock.Ordens.Contém-Chave(entidade))
{
OrderStock.Orders.Add(entidade, detalhe);
resultado = entidade. OrderID;
}
resultado do retorno;
}
public void Update(KeyValuePair<Order, <OrderDetail>IList> entidade)
{
se (OrderStock.Orders.ContainsKey(entity. Chave))
{
OrderStock.Orders[entity. Chave] = entidade. Valor;
}
}
public KeyValuePair<Order, IList<OrderDetail>> Get(id de objeto)
{
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)
{
entidade = dic.First();
}
retornar a entidade;
}
empty público Delete(KeyValuePair<Order, <OrderDetail>IList> entidade)
{
se (OrderStock.Orders.ContainsKey(entity. Chave))
{
OrderStock.Orders.Remove(entity. Chave);
}
}
}
}
Teste
usando o Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando o NUnit.Framework;
usando o Serviço;
usando Domínio;
Espaço de nomes ServiceTest
{
[TestFixture]
classe pública OrderServiceTest
{
m_service privados de serviço internacional;
[Preparação]
Init() de vazio público
{
m_service = novo OrderService();
}
[Teste]
LoadAllTest() público vazio
{
var list= m_service. LoadAll();
Foreach (item var na lista)
{
Console.WriteLine(item. OrderID);
Console.WriteLine(item. OrderAdress);
Console.WriteLine(item. OrderDate);
Console.WriteLine(item. OrderTel);
}
Assert.IsNotNull(lista);
}
[Teste]
Void público Salvar()
{
Entidade de ordem = nova Ordem()
{
OrderID = (int)m_service. GetNextID(),
OrderDate = DateTime.Now.AddDays(-1),
EndereçoOrdem = "Urumqi",
OrderTel = "123123"
};
objeto obj = m_service. Save(entidade);
Assert.IsNotNull(obj);
}
[Teste]
Atualização de vazio-público ()
{
Entidade de ordem = m_service. Get(1);
entidade. EndereçoOrderT= "Korla";
m_service. Atualização(entidade);
}
[Teste]
Void público Delete()
{
Entidade de ordem = m_service. Get(1);
entidade. EndereçoOrderT= "Korla";
m_service. Excluir(entidade);
}
}
}
usando o Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando o NUnit.Framework;
usando o Serviço;
usando Domínio;
Espaço de nomes ServiceTest
{
[TestFixture]
classe pública OrderServiceDetailTest
{
privado IOrderDetailService m_service;
[Preparação]
Init() de vazio público
{
m_service = novo OrderDetailService();
}
[Teste]
LoadAllTest() público vazio
{
var list= m_service. LoadAll();
Foreach (item var na lista)
{
Console.WriteLine("-------------- Order ----------");
Console.WriteLine(item. Key.OrderID);
Console.WriteLine(item. Chave.OrdemEndereço);
Console.WriteLine(item. Key.OrderDate);
Console.WriteLine(item. Key.OrderTel);
Console.WriteLine("-------------- Detalhe de Ordem ----------");
Foreach (var li no item. Valor)
{
Console.WriteLine(li.DetailID);
Console.WriteLine(li.Price);
Console.WriteLine(li.Quantity);
Console.WriteLine(li.ProductID);
}
}
Assert.IsNotNull(lista);
}
[Teste]
Void público Salvar()
{
int id = (int)m_service. GetNextID();
Entidade de ordem = nova Ordem()
{
OrderID = id,
OrderDate = DateTime.Now.AddDays(-1),
EndereçoOrdem = "Urumqi",
OrderTel = "123123"
};
<OrderDetail> IList list = nova Lista<OrderDetail>();
para (int i = 0; Eu < 3; i++)
{
lista. Add(new OrderDetail() {
DetailID = i + 1,
Preço=10+i,
Quantidade=i+100,
ProductID = 1000 + i
});
}
objeto obj = m_service. Save(entidade, lista);
Assert.IsNotNull(obj);
}
[Teste]
Atualização de vazio-público ()
{
entidade var = m_service. Get(1);
entidade. Value[0] = novo OrderDetail()
{
ProductID = 1000,
DetailID = 1,
Preço = 13,34M,
Quantidade = 200,1M
};
m_service. Atualização(entidade);
}
[Teste]
Void público Delete()
{
entidade var = m_service. Get(1);
m_service. Excluir(entidade);
}
}
}
Nota: Você precisa consultar a ferramenta nunit.framework ao testar |
Anterior:Compartilhe duas ferramentas de ataque de CC, boas para testes de estressePróximo:Bi Fujian emitiu uma carta de desculpas no Weibo: Me sinto muito culpado e triste
|
