|
|
Publicado en 10/4/2015 17:22:50
|
|
|
IDictionary es la interfaz base para una colección genérica de pares clave/valor, cada uno de los cuales es un par clave-valor en el objeto keyValuePair.
Cada par debe tener una clave única. La implementación difiere en si permitir o no que la clave sea una referencia vacía (Nothing in Visual Basic). Este valor puede ser una referencia vacía (Nada en Visual Basic) y no tiene por qué ser único. La interfaz IDictionary permite enumerar las claves y valores que contiene, pero esto no implica un orden de ordenación específico.
La sentencia foreach en el lenguaje C# (For Each en Visual Basic y For Each en C++) requiere el tipo de cada elemento de la colección. Dado que cada elemento de IDictionary es un par clave/valor, el tipo de elemento no es ni un tipo de clave ni un tipo de valor. En cambio, es un tipo KeyValuePair.
Aquí tienes un ejemplo sencillo de programa
Clase de entidad:
Espacio de nombres Dominio
{
//订单
Orden de clase pública
{
public int OrderID { get; set; }
/// <summary>
Fecha del pedido
/// </summary>
Public DateTime OrderDate { get; set; }
/// <summary>
Dirección de la orden
/// </summary>
cadena pública OrderAdress { get; set; }
/// <summary>
Pedido teléfono
/// </summary>
cadena pública OrderTel { get; set; }
}
}
//订单明细
Espacio de nombres Dominio
{
Clase pública OrdenDetalle
{
public int DetailID { get; set; }
public int ProductID { get; set; }
/// <summary>
Cantidad
/// </summary>
decimal público Cantidad { get; set; }
/// <summary>
Precio unitario
/// </summary>
decimal público Price { get; set; }
}
}
//存放数据
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domain;
Servicio de espacio de nombres
{
Clase pública estática OrderStock
{
IList estático<Order> privado m_orderList = nueva Lista<Order>(); Define un campo genérico para una Lista
IList estático<Order> público OrderList// define una propiedad genérica de una Lista
{
Obtener
{
regreso m_orderList;
}
Set
{
m_orderList = valor;
}
}
identificacionario estático privado<Order, IList<OrderDetail>> m_orders = nuevo Diccionario<Orden, <OrderDetail>IList>();
//定义了一个Dictionary的泛型字段，
IDictionary<Order, IList<OrderDetail>> Orders/ estático público define una propiedad genérica de un diccionario
{
Obtener
{
regreso m_orders;
}
Set
{
m_orders = valor;
}
}
}
}
Interfaces de servicio
usando Sistema;
usando Domain;
Servicio de espacio de nombres
{
interfaz pública IOrderService
{
//删除
void Delete (entidad Domain.Order);
Consulta a todos
System.Collections.Generic.IList<Domain.Order> LoadAll();
//保存
objeto Save(entidad Domain.Order);
//更新
void Update (entidad Domain.Order);
Consulta por ID
Orden Get(id de objeto);
//获取下一个ID
objeto GetNextID();
}
Servicio de espacio de nombres
{
interfaz pública IOrderDetailService
{
void Delete(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entidad);
System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> Get(id de objeto);
objeto GetNextDetailID(mainID del objeto);
objeto GetNextID();
System.Collections.Generic.IDictionary<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> LoadAll();
objeto Save(entidad Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail> detalle);
actualización void (System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entidad);
}
}
Realización del servicio
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domain;
Servicio de espacio de nombres
{
Servicio de Orden de clase pública: Servicio de Seguridad
{
IList público<Order> LoadAll()
{
var list = OrderStock.OrderList;
lista de retorno;
}
objeto público GetNextID()
{
int id = 1;
si (OrderStock.OrderList.Count > 0)
{
id = OrdenStock.ListaDeOrden.Max(m => m.IDorden) + 1;
}
devolver identidad;
}
objeto público Guardar (entidad de orden)
{
OrdenStock.ListaOrden.Añadir(entidad);
Devolver la entidad. OrderID;
}
Actualización de vacío público (entidad de orden)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID);
Si (lista. Cuenta<Order>() > 0)
{
Orden de orden = lista. Primero();
OrdenStock.ListaDeOrden[OrdenStock.ListaDeOrdenIndexOf(orden)] = entidad;
}
}
Orden público Get(id de objeto)
{
entidad de orden = nulo;
var list = OrderStock.OrderList.Where(w => w.OrderID == (int)id);
Si (lista. Cuenta<Order>() > 0)
{
Orden de orden = lista. Primero();
entidad = OrdenStock.ListaDeOrden[OrdenStock.ListaDeOrdenÍndiceOf(orden)];
}
entidad de retorno;
}
Vacío público Eliminar (entidad de orden)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID);
Si (lista. Cuenta<Order>() > 0)
{
Orden de orden = lista. Primero();
OrdenStock.OrdenLista.Eliminar(orden);
}
}
}
}
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando Domain;
Servicio de espacio de nombres
{
clase pública OrderDetailService: IOrderDetailService
{
Public IDictionary<Order, IList<OrderDetail>> LoadAll()
{
var dic = OrderStock.Orders;
Devolver a Dic;
}
objeto público GetNextID()
{
int id = 1;
si (OrderStock.Orders.Count > 0)
{
id = OrdenStock.Órdenes.Max(m => m.Key.OrderID) + 1;
}
devolver identidad;
}
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)
{
ítem var = dic.First();
Lista de var = ítem. Value.Where(w => w.DetailID == (int)mainID);
Si (lista. Count<OrderDetail>() > 0)
{
id = lista. First(). DetailID + 1;
}
}
devolver identidad;
}
Objeto público Guardar (entidad de orden,<OrderDetail> detalle IList)
{
object result = null;
si (! OrdenStock.Órdenes.ContieneClave(entidad))
{
OrderStock.Orders.Add(entidad, detalle);
resultado = entidad. OrderID;
}
resultado de retorno;
}
Public void Update(KeyValuePair<<OrderDetail>Order, IList> entidad)
{
si (OrderStock.Orders.ContainsKey(entity. Clave))
{
OrderStock.Orders[entity. Clave] = entidad. Valor;
}
}
Public KeyValuePair<Order, IList<OrderDetail>> Get(id de objeto)
{
KeyValuePair<Order, IList<OrderDetail>> entity = new KeyValuePair<Order, <OrderDetail>IList>();
var dic = OrderStock.Orders.Where(w => w.Key.OrderID == (int)id);
if (dic.Count<KeyValuePair<Order, IList<OrderDetail>>>() > 0)
{
entidad = dic.First();
}
entidad de retorno;
}
empty public void Suprimir (KeyValuePair<Order, <OrderDetail>IList> entidad)
{
si (OrderStock.Orders.ContainsKey(entity. Clave))
{
OrderStock.Orders.Remove(entity. Clave);
}
}
}
}
Prueba
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando NUnit.Framework;
usando Service;
usando Domain;
ServiceTest en espacio de nombres
{
[TestFixture]
Clase pública OrderServiceTest
{
m_service privados de Servicio Internacional;
[Preparación]
vacío público Init()
{
m_service = nuevo OrderService();
}
[Prueba]
vacío público LoadAllTest()
{
var list= m_service. LoadAll();
Foreach (elemento var en la lista)
{
Consola.WriteLine(ítem. OrderID);
Consola.WriteLine(ítem. DirecciónOrden);
Consola.WriteLine(ítem. OrderDate);
Consola.WriteLine(ítem. OrderTel);
}
Assert.IsNotNull(lista);
}
[Prueba]
vacío público Guardar()
{
Entidad de orden = nuevo Orden()
{
OrderID = (int)m_service. GetNextID(),
OrdenFecha = FechaTiempo.Ahora.AgregarDías(-1),
DirecciónDeOrden = "Urumqi",
OrderTel = "123123"
};
objeto obj = m_service. Save(entidad);
Assert.IsNotNull(obj);
}
[Prueba]
Vacío público Actualización()
{
entidad de orden = m_service. Get(1);
entidad. DirecciónOrdenT= "Korla";
m_service. Actualización(entidad);
}
[Prueba]
Vacío público Eliminar()
{
entidad de orden = m_service. Get(1);
entidad. DirecciónOrdenT= "Korla";
m_service. Eliminar(entidad);
}
}
}
usando Sistema;
usando System.Collections.Generic;
usando System.Linq;
usando System.Text;
usando NUnit.Framework;
usando Service;
usando Domain;
ServiceTest en espacio de nombres
{
[TestFixture]
Clase pública OrderServiceDetailTest
{
privado IOrderDetailService m_service;
[Preparación]
vacío público Init()
{
m_service = nuevo OrderDetailService();
}
[Prueba]
vacío público LoadAllTest()
{
var list= m_service. LoadAll();
Foreach (elemento var en la lista)
{
Console.WriteLine("-------------- Order ----------");
Consola.WriteLine(ítem. Key.OrderID);
Consola.WriteLine(ítem. Key.OrderAdress);
Consola.WriteLine(ítem. Key.OrderDate);
Consola.WriteLine(ítem. Key.OrderTel);
Console.WriteLine("-------------- Detalle de Orden ----------");
Foreach (var li en ítem. Valor)
{
Consola.WriteLine(li.DetailID);
Console.WriteLine(li.Price);
Consola.WriteLine(li.Quantity);
Consola.WriteLine(li.ProductID);
}
}
Assert.IsNotNull(lista);
}
[Prueba]
vacío público Guardar()
{
int id = (int)m_service. GetNextID();
Entidad de orden = nuevo Orden()
{
OrderID = id,
OrdenFecha = FechaTiempo.Ahora.AgregarDías(-1),
DirecciónDeOrden = "Urumqi",
OrderTel = "123123"
};
<OrderDetail> IList list = nueva lista<OrderDetail>();
para (int i = 0; Yo < 3; i++)
{
lista. Add(new OrderDetail() {
DetailID = i + 1,
Precio=10+i,
Cantidad=i+100,
ProductID = 1000 + i
});
}
objeto obj = m_service. Guardar (entidad, lista);
Assert.IsNotNull(obj);
}
[Prueba]
Vacío público Actualización()
{
Entidad var = m_service. Get(1);
entidad. Value[0] = nuevo OrderDetail()
{
ProductID = 1000,
DetailID = 1,
Precio = 13,34M,
Cantidad = 200,1M
};
m_service. Actualización(entidad);
}
[Prueba]
Vacío público Eliminar()
{
Entidad var = m_service. Get(1);
m_service. Eliminar(entidad);
}
}
}
Nota: Necesitas consultar la herramienta nunit.framework al hacer pruebas |
Anterior:Comparte dos herramientas de ataque CC, buenas para pruebas de estrésPróximo:Bi Fujian emitió una carta de disculpa en Weibo: Me siento muy culpable y triste
|
