IDictionary는 keyValuePair 객체 내의 키-값 쌍으로 구성된 일반적인 키/값 쌍 집합의 기본 인터페이스입니다.
각 쌍은 고유 키를 가져야 합니다. 구현은 키가 빈 참조(Visual Basic에서는 아무것도 없음)로 허용할지 여부에 차이가 있습니다. 이 값은 비어 있는 참조(Visual Basic에서는 아무것도 없음)일 수 있으며 반드시 고유할 필요는 없습니다. IDictionary 인터페이스는 포함된 키와 값을 열거할 수 있지만, 이는 특정 정렬 순서를 의미하지는 않습니다.
C# 언어의 foreach 문(Visual Basic에서는 For Each 및 C++에서는 for each)은 컬렉션 내 각 요소의 타입을 요구합니다. IDictionary의 각 요소는 키/값 쌍이므로, 요소 유형은 키의 타입도 값의 타입도 아닙니다. 대신 KeyValuePair 타입입니다.
간단한 예제 프로그램이 있습니다
엔터티 클래스:
네임스페이스 도메인
{
//订单
공공 등급 기사
{
public int OrderID { get; 세트; }
/// <summary>
주문일
/// </summary>
공공 DateTime OrderDate { get; 세트; }
/// <summary>
주문 주소
/// </summary>
public string OrderAdress { get; 세트; }
/// <summary>
주문 전화
/// </summary>
public string OrderTel { get; 세트; }
}
}
//订单明细
네임스페이스 도메인
{
공공 클래스 OrderDetail
{
public int DetailID { get; 세트; }
public int ProductID { get; 세트; }
/// <summary>
양
/// </summary>
공개 십진법 Quantity { get; 세트; }
/// <summary>
단가
/// </summary>
공개 십진법 가격 { get; 세트; }
}
}
//存放数据
System을 사용;
System.Collections.Generic을 사용;
System.Linq를 사용;
System.Text 사용;
도메인을 사용;
네임스페이스 서비스
{
공용 정적 클래스 OrderStock
{
private static IList<Order> m_orderList = 새 List<Order>(); 리스트에 대한 일반 필드를 정의합니다
공개 정적 IList<Order> OrderList//는 리스트의 일반적인 속성을 정의합니다
{
가져오기
{
m_orderList 반환;
}
세트
{
m_orderList = 가치;
}
}
private static IDictionary<Order, IList<OrderDetail>> m_orders = new Dictionary<Order, IList<OrderDetail>>();
//定义了一个Dictionary的泛型字段，
공개 정적 IDictionary<Order, IList<OrderDetail>> 명령은 사전의 일반적인 속성을 정의합니다
{
가져오기
{
m_orders 반환;
}
세트
{
m_orders = 가치;
}
}
}
}
서비스 인터페이스
System을 사용;
도메인을 사용;
네임스페이스 서비스
{
공개 인터페이스 IOrderService
{
//删除
무효 삭제(도메인.오더) entity;
모두 조회
System.Collections.Generic.IList<Domain.Order> LoadAll();
//保存
object Save(Domain.Order entity);
//更新
void Update(Domain.Order entity);
ID에 의한 쿼리
명령 Get(object id);
//获取下一个ID
object GetNextID();
}
네임스페이스 서비스
{
공개 인터페이스 IOrderDetailService
{
void Delete(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entity);
System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> Get(object id);
object GetNextDetailID(object mainID);
object GetNextID();
System.Collections.Generic.IDictionary<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> LoadAll();
object Save(Domain.Order entity, System.Collections.Generic.IList<Domain.OrderDetail> detail);
void Update(System.Collections.Generic.KeyValuePair<Domain.Order, System.Collections.Generic.IList<Domain.OrderDetail>> entity);
}
}
서비스 실현
System을 사용;
System.Collections.Generic을 사용;
System.Linq를 사용;
System.Text 사용;
도메인을 사용;
네임스페이스 서비스
{
공공 등급 명령 서비스 : IOrderService
{
공개 IList<Order> LoadAll()
{
var list = OrderStock.OrderList;
리턴 리스트;
}
공개 객체 GetNextID()
{
정정 ID = 1;
만약 (OrderStock.OrderList.Count > 0)
{
id = OrderStock.OrderList.Max(m => m.OrderID) + 1;
}
신분증 반환;
}
공개 객체 Save(Order entity)
{
OrderStock.OrderList.Add(법인);
반환 엔티티. OrderID;
}
공공 공허 업데이트(명령 실체)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID);
만약 (목록). 카운<Order>트() > 0)
{
주문 순서 = 목록. 퍼스트();
OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)] = 엔터티;
}
}
공공 명령 Get(object id)
{
순서 엔터티 = null;
var list = OrderStock.OrderList.Where(w => w.OrderID == (int)id);
만약 (목록). 카운<Order>트() > 0)
{
주문 순서 = 목록. 퍼스트();
entity = OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)];
}
반환 엔터티;
}
공공 공백 삭제(명령 실체)
{
var list = OrderStock.OrderList.Where(w => w.OrderID == entity. OrderID);
만약 (목록). 카운<Order>트() > 0)
{
주문 순서 = 목록. 퍼스트();
주문, 재고, 주문목록, 제거(주문);
}
}
}
}
System을 사용;
System.Collections.Generic을 사용;
System.Linq를 사용;
System.Text 사용;
도메인을 사용;
네임스페이스 서비스
{
공공 클래스 OrderDetailService : IOrderDetailService
{
public IDictionary<Order, IList<OrderDetail>> LoadAll()
{
var dic = OrderStock.Orders;
리턴 DIC;
}
공개 객체 GetNextID()
{
정정 ID = 1;
만약 (OrderStock.Orders.Count > 0)
{
id = OrderStock.Orders.Max(m => m.Key.OrderID) + 1;
}
신분증 반환;
}
public object GetNextDetailID(object mainID)
{
정정 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();
var list = 항목. Value.Where(w => w.DetailID == (int)mainID);
만약 (목록). 카운<OrderDetail>트() > 0)
{
id = 목록. First(). DetailID + 1;
}
}
신분증 반환;
}
공개 객체 저장(Order entity, IList<OrderDetail> 상세)
{
객체 결과 = null;
만약 (! OrderStock.Orders.ContainsKey(엔티티))
{
OrderStock.Orders.Add(법인, 상세);
결과 = 엔터티. OrderID;
}
반환 결과;
}
public void Update(KeyValuePair<Order, IList<OrderDetail>> entity)
{
if (OrderStock.Orders.ContainsKey(entity. 키))
{
주문주식.주문[법인. 키] = 실체. 가치;
}
}
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)
{
entity = dic. First();
}
반환 엔터티;
}
public void Delete(KeyValuePair<Order, IList<OrderDetail>> entity)
{
if (OrderStock.Orders.ContainsKey(entity. 키))
{
OrderStock.Orders.Remove(entity. 키);
}
}
}
}
테스트
System을 사용;
System.Collections.Generic을 사용;
System.Linq를 사용;
System.Text 사용;
NUnit.Framework를 사용;
서비스;
도메인을 사용;
이름공간 ServiceTest
{
[테스트픽스처]
공공 클래스 OrderServiceTest
{
민간 IOrderService m_service;
[설정]
공공 공허 Init()
{
m_service = 새로운 OrderService();
}
[테스트]
public void LoadAllTest()
{
var list= m_service. 로드올();
foreach (리스트 내 var 항목)
{
Console.WriteLine(항목. OrderID);
Console.WriteLine(항목. OrderAaddress);
Console.WriteLine(항목. 주문일);
Console.WriteLine(항목. OrderTel);
}
Assert.IsNotNull(list);
}
[테스트]
공공 공허 세이브()
{
주문 엔터티 = 새로운 주문()
{
OrderID = (int)m_service. GetNextID(),
OrderDate = DateTime.Now.AddDays(-1),
OrderAaddress = "우루무치",
OrderTel = "123123"
};
객체 obj = m_service. Save(entity);
Assert.IsNotNull(obj);
}
[테스트]
공공 공허 업데이트 ()
{
주문 실체 = m_service. Get(1);
존재. OrderAaddress = "코를라";
m_service. Update(entity);
}
[테스트]
공공 공백 삭제()
{
주문 실체 = m_service. Get(1);
존재. OrderAaddress = "코를라";
m_service. Delete(entity);
}
}
}
System을 사용;
System.Collections.Generic을 사용;
System.Linq를 사용;
System.Text 사용;
NUnit.Framework를 사용;
서비스;
도메인을 사용;
이름공간 ServiceTest
{
[테스트픽스처]
public class OrderServiceDetailTest
{
사설 IOrderDetailService m_service;
[설정]
공공 공허 Init()
{
m_service = 새로운 OrderDetailService();
}
[테스트]
public void LoadAllTest()
{
var list= m_service. 로드올();
foreach (리스트 내 var 항목)
{
Console.WriteLine("-------------- 명령 ----------");
Console.WriteLine(항목. Key.OrderID);
Console.WriteLine(항목. 키.순서 주소);
Console.WriteLine(항목. 키.주문일);
Console.WriteLine(항목. Key.OrderTel);
Console.WriteLine("-------------- 주문 세부 사항 ----------");
foreach (var li in item. 가치)
{
콘솔.WriteLine(li.DetailID);
콘솔.WriteLine(li.Price);
Console.WriteLine(li.Quantity);
Console.WriteLine(li.ProductID);
}
}
Assert.IsNotNull(list);
}
[테스트]
공공 공허 세이브()
{
정정 ID = (정수)m_service. GetNextID();
주문 엔터티 = 새로운 주문()
{
OrderID = id,
OrderDate = DateTime.Now.AddDays(-1),
OrderAaddress = "우루무치",
OrderTel = "123123"
};
IList<OrderDetail> list = 새로운 목록<OrderDetail>();
(정수: i = 0; 저는 3< 있습니다; i++)
{
목록. Add(new OrderDetail() {
DetailID = i + 1,
가격=10+i,
수량=i+100,
ProductID = 1000 + i
});
}
객체 obj = m_service. Save(entity, list);
Assert.IsNotNull(obj);
}
[테스트]
공공 공허 업데이트 ()
{
var entity = m_service. Get(1);
존재. Value[0] = 새로운 OrderDetail()
{
ProductID = 1000,
DetailID = 1,
가격 = 13.34만 달러,
수량 = 2억 100만
};
m_service. Update(entity);
}
[테스트]
공공 공백 삭제()
{
var entity = m_service. Get(1);
m_service. Delete(entity);
}
}
}
참고: 테스트 시 nunit.framework 도구를 참조해야 합니다 |
게시됨 2015. 4. 10. 오후 5:22:50
|
|
|
