三、定义主从实体基类

定义主从实体基类的原因是我希望在类的定义时，可以很明确的了解类之间的主从关系。

3.1定义主表基类

定义PrimaryDataEntityBase

1. /// <summary>  
2. /// 描述主从表的主表的数据实体  
3. /// </summary>  
4. /// <typeparam name="ID">主表实体的主键ID</typeparam>  
5. /// <typeparam name="P">主表</typeparam>  
6. /// <typeparam name="F">从表</typeparam>  
7. public abstract class PrimaryDataEntityBase<ID, P, F> : EntityBase<P, ID>  
8.     where P : PrimaryDataEntityBase<ID, P, F>  
9.     where F : ForeignDataEntityBase<ID, P, F>  
10. {  
11.     /// <summary>  
12.     /// PrimaryDataEntityBase的默认构造函数  
13.     /// </summary>  
14.     public PrimaryDataEntityBase()  
15.     {  
16.     }  
17.     /// <summary>  
18.     /// 按table的第一行数据进行属性的初始化  
19.     /// </summary>  
20.     /// <param name="table"></param>  
21.     public PrimaryDataEntityBase(System.Data.DataTable table)  
22.         : this(table, 0)  
23.     {  
24.     }  
25.     /// <summary>  
26.     /// 按table的指定行数据进行属性的初始化  
27.     /// </summary>  
28.     /// <param name="table"></param>  
29.     /// <param name="indexRow"></param>  
30.     public PrimaryDataEntityBase(System.Data.DataTable table, int indexRow)  
31.         : base(table, indexRow)  
32.     {  
33.     }  
34.     /// <summary>  
35.     /// 装载当前从表的详细项  
36.     /// </summary>  
37.     protected abstract List<F> LoadDetailedItems();  
38.     /// <summary>  
39.     /// 存放外键表的数据项目的集合  
40.     /// </summary>  
41.     protected List<F> items = new List<F>();  
42.     /// <summary>  
43.     /// 获取外键表数据的集合  
44.     /// </summary>  
45.     public List<F> DetailedItems  
46.     {  
47.         get  
48.         {  
49.             return LoadDetailedItems();  
50.         }  
51.     }  
52.     /// <summary>  
53.     /// 返回外键表的数据项目数量  
54.     /// </summary>  
55.     public int DetailedItemCount  
56.     {  
57.         get  
58.         {  
59.             return items.Count;  
60.         }  
61.     }  
62.     /// <summary>  
63.     /// 将一个外键实体加入集合  
64.     /// </summary>  
65.     /// <param name="item"></param>  
66.     /// <returns></returns>  
67.     public abstract void Add(F item);  
68.     /// <summary>  
69.     /// 从集合中移除一个外键实体  
70.     /// </summary>  
71.     /// <param name="item"></param>  
72.     public abstract void Remove(F item);  
73.     /// <summary>  
74.     /// 从集合中移除一个外键实体  
75.     /// </summary>  
76.     /// <param name="index"></param>  
77.     public abstract void RemoveAt(int index);  
78.     /// <summary>  
79.     /// 返回或设置匹配索引的订单详细项  
80.     /// </summary>  
81.     /// <param name="index"></param>  
82.     /// <returns></returns>  
83.     public abstract F this[int index]  
84.     {  
85.         set;  
86.         get;  
87.     }  
88. } 

3.2定义从表基类

定义ForeignDataEntityBase

1. /// <summary>  
2. /// 描述主从表的从表的数据实体  
3. /// </summary>  
4. /// <typeparam name="ID">从表实体的主键ID</typeparam>  
5. /// <typeparam name="P">主表</typeparam>  
6. /// <typeparam name="F">从表</typeparam>  
7. public abstract class ForeignDataEntityBase<ID, P, F> : EntityBase<F, ID>  
8.     where P : PrimaryDataEntityBase<ID, P, F>  
9.     where F : ForeignDataEntityBase<ID, P, F>  
10. {  
11.     /// <summary>  
12.     /// ForeignDataEntityBase的默认构造函数  
13.     /// </summary>  
14.     public ForeignDataEntityBase()  
15.     {  
16.     }  
17.     /// <summary>  
18.     /// 按table的第一行数据进行属性的初始化  
19.     /// </summary>  
20.     /// <param name="table"></param>  
21.     public ForeignDataEntityBase(System.Data.DataTable table)  
22.         : this(table, 0)  
23.     {  
24.     }  
25.     /// <summary>  
26.     /// 按table的指定行数据进行属性的初始化  
27.     /// </summary>  
28.     /// <param name="table"></param>  
29.     /// <param name="indexRow"></param>  
30.     public ForeignDataEntityBase(System.Data.DataTable table, int indexRow)  
31.         : base(table, indexRow)  
32.     {  
33.     }  
34.     /// <summary>  
35.     /// 对应主键实体  
36.     /// </summary>  
37.     [System.ComponentModel.DataObjectField(false, false, false)]  
38.     public P RelationOrder  
39.     {  
40.         set;  
41.         get;  
42.     }  
43. } 

3.3使用主从表基类

1. /// <summary>  
2. /// 客户委托单  
3. /// </summary>  
4. [System.ComponentModel.DataObject(true)]  
5. public class BusinessOrder : LogisticsOrderBase<BusinessOrder, BusinessOrderItem>  
6. {  
7. }  
8. /// <summary>  
9. /// 委托单详细  
10. /// </summary>  
11. [System.ComponentModel.DataObject(true)]  
12. public class BusinessOrderItem : DetailedItemBase<BusinessOrder, BusinessOrderItem>  
13. {  
14. } 

现在我们的类在定义的时候，就可以非常明确的描述了主从实体的关系，并拥有了数据自动属性装载的能力。

本文转自shyleoking 51CTO博客，原文链接:http://blog.51cto.com/shyleoking/805772