C#之泛型集合类(Ilist,IDictionary)的使用

IDictionary是键/值对的泛型集合的基接口，每个元素都是存在keyValuepair对象中的键值对。

每一对都必须有唯一的键。实现在是否允许 key 为 空引用（在 Visual Basic 中为 Nothing） 方面有所不同。此值可以为 空引用（在 Visual Basic 中为 Nothing），并且不必是唯一的。IDictionary 接口允许对所包含的键和值进行枚举，但这并不意味着任何特定的排序顺序。

C# 语言中的 foreach 语句（在 Visual Basic 中为 For Each，在 C++ 中为 for each）需要集合中每个元素的类型。由于 IDictionary 的每个元素都是一个键/值对，因此元素类型既不是键的类型，也不是值的类型。而是 KeyValuePair 类型。

 

以下是一个简单的示例程序

实体类：

namespace Domain
{

//订单
    public class Order
    {
        public int OrderID { get; set; }

        /// <summary>
        /// 订单日期
        /// </summary>
        public DateTime OrderDate { get; set; }

        /// <summary>
        /// 订单地址
        /// </summary>
        public string OrderAdress { get; set; }

        /// <summary>
        /// 订单电话
        /// </summary>
        public string OrderTel { get; set; }
    }
}

//订单明细

namespace Domain
{
    public class OrderDetail
    {
        public int DetailID { get; set; }

        public int ProductID { get; set; }

        /// <summary>
        /// 数量
        /// </summary>
        public decimal Quantity { get; set; }

        /// <summary>
        /// 单价
        /// </summary>
        public decimal Price { get; set; }
    }
}

//存放数据

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Domain;

namespace Service
{
    public static class OrderStock
    {
        private static IList<Order> m_orderList = new List<Order>(); //定义了一个List的泛型字段

        public static IList<Order> OrderList//定义了一个List的泛型属性
        {
            get
            {
                return m_orderList;
            }
            set
            {
                m_orderList = value;
            }
        }

        private static IDictionary<Order, IList<OrderDetail>> m_orders = new Dictionary<Order, IList<OrderDetail>>();

//定义了一个Dictionary的泛型字段，

        public static IDictionary<Order, IList<OrderDetail>> Orders/定义了一个Dictionary的泛型属性
        {
            get
            {
                return m_orders;
            }
            set
            {
                m_orders = value;
            }
        }
    }
}

服务接口

using System;
using Domain;
namespace Service
{
    public interface IOrderService
    {

　　　//删除
        void Delete(Domain.Order entity);

       //查询所有
        System.Collections.Generic.IList<Domain.Order> LoadAll();

　　　//保存
        object Save(Domain.Order entity);

　　　//更新
        void Update(Domain.Order entity);

　　  //根据ID查询
        Order Get(object id);

　　　//获取下一个ID
        object GetNextID();
    }

namespace Service
{
    public interface 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);
    }
}

服务实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Domain;

namespace Service
{
    public class OrderService : IOrderService
    {
        public IList<Order> LoadAll()
        {
            var list = OrderStock.OrderList;

            return list;
        }

        public object GetNextID()
        {
            int id = 1;
            if (OrderStock.OrderList.Count > 0)
            {
                id = OrderStock.OrderList.Max(m => m.OrderID) + 1;
            }
            return id;
        }

        public object Save(Order entity)
        {
            OrderStock.OrderList.Add(entity);

            return entity.OrderID;
        }

        public void Update(Order entity)
        {
            var list = OrderStock.OrderList.Where(w => w.OrderID == entity.OrderID);

            if (list.Count<Order>() > 0)
            {
                Order order = list.First();
                OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)] = entity;
            }
        }

        public Order Get(object id)
        {
            Order entity = null;
            var list = OrderStock.OrderList.Where(w => w.OrderID == (int)id);
            if (list.Count<Order>() > 0)
            {
                Order order = list.First();
                entity = OrderStock.OrderList[OrderStock.OrderList.IndexOf(order)];
            }
            return entity;
        }

        public void Delete(Order entity)
        {
            var list = OrderStock.OrderList.Where(w => w.OrderID == entity.OrderID);
            if (list.Count<Order>() > 0)
            {
                Order order = list.First();
                OrderStock.OrderList.Remove(order);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Domain;

namespace Service
{
    public class OrderDetailService : IOrderDetailService
    {
        public IDictionary<Order, IList<OrderDetail>> LoadAll()
        {
            var dic = OrderStock.Orders;

            return dic;
        }

        public object GetNextID()
        {
            int id = 1;
            if (OrderStock.Orders.Count > 0)
            {
                id = OrderStock.Orders.Max(m => m.Key.OrderID) + 1;
            }
            return id;
        }

        public object GetNextDetailID(object mainID)
        {
            int 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 = item.Value.Where(w => w.DetailID == (int)mainID);
                if (list.Count<OrderDetail>() > 0)
                {
                    id = list.First().DetailID + 1;
                }
            }
            return id;
        }

        public object Save(Order entity, IList<OrderDetail> detail)
        {
            object result = null;
            if (!OrderStock.Orders.ContainsKey(entity))
            {
                OrderStock.Orders.Add(entity, detail);
                result = entity.OrderID;
            }
            return result;
        }

        public void Update(KeyValuePair<Order, IList<OrderDetail>> entity)
        {
            if (OrderStock.Orders.ContainsKey(entity.Key))
            {
                OrderStock.Orders[entity.Key] = entity.Value;
            }
        }

        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();
            }
           
            return entity;
        }

        public void Delete(KeyValuePair<Order, IList<OrderDetail>> entity)
        {
            if (OrderStock.Orders.ContainsKey(entity.Key))
            {
                OrderStock.Orders.Remove(entity.Key);
            }
        }
    }
}

测试

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Service;
using Domain;

namespace ServiceTest
{
    [TestFixture]
    public class OrderServiceTest
    {
        private IOrderService m_service;

        [SetUp]
        public void Init()
        {
            m_service = new OrderService();
        }

        [Test]
        public void LoadAllTest()
        {
           var list= m_service.LoadAll();
           foreach (var item in list)
           {
               Console.WriteLine(item.OrderID);
               Console.WriteLine(item.OrderAdress);
               Console.WriteLine(item.OrderDate);
               Console.WriteLine(item.OrderTel);
           }
           Assert.IsNotNull(list);
        }

        [Test]
        public void Save()
        {
            Order entity = new Order()
            {
                OrderID = (int)m_service.GetNextID(),
                OrderDate = DateTime.Now.AddDays(-1),
                OrderAdress = "乌鲁木齐",
                OrderTel = "123123"
            };
            object obj = m_service.Save(entity);
          
            Assert.IsNotNull(obj);
        }

        [Test]
        public void Update()
        {
            Order entity = m_service.Get(1);
            entity.OrderAdress = "库尔勒";
            m_service.Update(entity);
        }

        [Test]
        public void Delete()
        {
            Order entity = m_service.Get(1);
            entity.OrderAdress = "库尔勒";
            m_service.Delete(entity);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Service;
using Domain;

namespace ServiceTest
{
    [TestFixture]
    public class OrderServiceDetailTest
    {
        private IOrderDetailService m_service;

        [SetUp]
        public void Init()
        {
            m_service = new OrderDetailService();
        }

        [Test]
        public void LoadAllTest()
        {
           var list= m_service.LoadAll();
           foreach (var item in list)
           {
               Console.WriteLine("--------------订单----------");
               Console.WriteLine(item.Key.OrderID);
               Console.WriteLine(item.Key.OrderAdress);
               Console.WriteLine(item.Key.OrderDate);
               Console.WriteLine(item.Key.OrderTel);
               Console.WriteLine("--------------订单明细----------");
               foreach (var li in item.Value)
               {
                   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();
            Order entity = new Order()
            {
                OrderID = id,
                OrderDate = DateTime.Now.AddDays(-1),
                OrderAdress = "乌鲁木齐",
                OrderTel = "123123"
            };
            IList<OrderDetail> list = new List<OrderDetail>();
            for (int i = 0; i < 3; i++)
            {
                list.Add(new OrderDetail() {
                    DetailID = i + 1,
                    Price=10+i,
                    Quantity=i+100,
                    ProductID = 1000 + i
                });
            }
            object obj = m_service.Save(entity, list);
          
            Assert.IsNotNull(obj);
        }

        [Test]
        public void Update()
        {
            var entity = m_service.Get(1);

            entity.Value[0] = new OrderDetail()
            {
                ProductID = 1000,
                DetailID = 1,
                Price = 13.34M,
                Quantity = 200.1M
            };
            m_service.Update(entity);
        }

        [Test]
        public void Delete()
        {
            var entity = m_service.Get(1);
            m_service.Delete(entity);
        }
    }
}

注：测试时需要引用nunit.framework工具