使用泛型和反射，打造我们的完美实体基类
背景
我在开发的过程中，实体和数据库的访问是一直要接触和编写的代码，考虑到团队中初学者比较多，我一直希望有一种方式可以改善目前编码的困境：
ADO.Net的代码对于初学者来讲比较麻烦，需要他们更多的对ADO.Net有所了解。
将数据库的值为实体属性赋值是一个比较繁琐的过程，程序员容易厌倦这个重复工作，或数据类型，或属性名称的赋值错误。
对于一对多的实体模型开发中，程序员很容易的将一对多的实体对象相互的关联错误。
我们当然可以使用一些自动化的工具来辅助，或者采用类似Hibernate的框架或VS2008SP1的一些新功能来实现，但我们又需要在我们的实体中有些更灵活的控制。
因此作为开发团队的技术管理人员，我必须要设计一种更好的模式来解决以上的事项。
正文中，我们将逐步的阐述我的设计思路。
一、打造DataProvider
ADO.Net的封装已经有很多的实现了，但我总感觉那些实现还是没有透明化使用者对ADO.Net的了解。比如说很多人推崇的Enterprise Library的DataAccess，我认为就是封装不够彻底。我理想中封装彻底的ADO.Net对象是，使用者不需要（或尽可能的少）了解任何，而DataAccess还是需要使用者直接的处理很多ADO.Net的对象。而我需要的ADO.Net的封装希望使用者，仅给予SQL命令，赋值参数，并获取结果即可。
1.1定义DataProvide
|
定义SqlDataProvider类 |
|
/// <summary> /// SQL数据提供者的实现 /// </summary> public class SqlDataProvider : DataProviders.IDataProvider {
} |
1.2定义DataProviders.IDataProvider
DataProviders.IDataProvider是我定义的一个接口，我希望将来所有的数据提供者都能实现该接口，以便利用依赖倒置实现抽象工厂。
|
定义DataProviders.IDataProvider接口 |
|
public interface IDataProvider { void AddParameters(string parname, Guid value); void AddParameters(string parname, long value); void AddParameters(string parname, string value); void AddParameters(string parname, string value, DataProviders.StringFamily dataType); void AddParameters(string parname, string value, DataProviders.StringFamily dataType, int size); void AddParameters(string parname, float value); void AddParameters(string parname, decimal value); void AddParameters(string parname, DateTime value); void AddParameters(string parname, DateTime value, DataProviders.DateFamily dataType); void AddParameters(string parname, int value); void AddParameters(string parname, object value); void AddParameters(string parname, System.Drawing.Bitmap value); void AddParameters(string parname, byte[] value); void AddParameters(string parname, byte[] value, DataProviders.ByteArrayFamily dataType); void AddParameters(string parname, bool value); void AddParameters(string parname, short value); void AddParameters(string parname, byte value); System.Data.CommandType CommandType { get; set; } string ConnectionString { get; } System.Data.DataSet ExecuteDataSet(); System.Data.DataTable ExecuteDataTable(); void ExecuteReader(ReadData readData); int ExecuteNonQuery(); object ExecuteScalar(); string SQL { get; set; } }
public delegate void ReadData(System.Data.IDataReader dataReadre); |
从该接口可以看到，实现的DataProvider封装了关于具体的连接对象，命令对象和参数类型的信息。
1.3实现DataProvider基础部分
|
SqlDataProvider类实现（基础部分） |
|
private static System.Data.SqlClient.SqlConnection conn; private System.Data.SqlClient.SqlCommand cmd;
/// <summary> /// 默认构造函数 /// </summary> public SqlDataProvider() {
}
/// <summary> /// 接受连接字符串 /// </summary> /// <param name="connstr"></param> public SqlDataProvider(string connstr) : this(connstr, "") {
}
/// <summary> /// 接受连接字符串和sql字符串 /// </summary> /// <param name="connstr"></param> /// <param name="sql"></param> public SqlDataProvider(string connstr, string sql) { conn = new System.Data.SqlClient.SqlConnection(connstr); cmd = new System.Data.SqlClient.SqlCommand(); cmd.Connection = conn; cmd.CommandText = sql; }
/// <summary> /// 需要执行的SQL命令 /// </summary> public string SQL { set { cmd.CommandText = value; } get { return cmd.CommandText; } }
/// <summary> /// 当前的连接字符串 /// </summary> public string ConnectionString { get { return conn.ConnectionString; } }
/// <summary> /// 设置命令的类型 /// </summary> public System.Data.CommandType CommandType { set { cmd.CommandType = value; } get { return cmd.CommandType; } } |
从上述代码可以观察到，我们的DataProvider只向用户暴露了两个字符串数据：连接字符串和SQL指令字符串。而将ADO.Net特有的Connection和Command封装起来了。由于用户不需要了解到具体实例化的Connection和Command，则为以后对其他数据源提供者的扩展带来了机会。
1.4实现DataProvider数据执行部分
|
SqlDataProvider类实现（数据执行部分） |
|
/// <summary> /// 将SqlDataReader提交给具体的委托器处理 /// </summary> /// <param name="readData"></param> public void ExecuteReader(ReadData readData) { using (conn) { conn.Open(); System.Data.SqlClient.SqlDataReader dr = cmd.ExecuteReader(); readData(dr); conn.Close(); } }
/// <summary> /// 对连接执行 Transact-SQL 语句并返回受影响的行数 /// </summary> /// <returns></returns> public int ExecuteNonQuery() { int result = -1; using (conn) { conn.Open(); result = cmd.ExecuteNonQuery(); conn.Close(); } return result; }
/// <summary> /// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略其他列或行 /// </summary> /// <returns></returns> public object ExecuteScalar() { object result = null; using (conn) { conn.Open(); result = cmd.ExecuteScalar(); conn.Close(); } return result; }
/// <summary> /// 执行查询，并返回查询的DataSet /// </summary> /// <returns></returns> public System.Data.DataSet ExecuteDataSet() { System.Data.DataSet datadet = new System.Data.DataSet(); using (conn) { System.Data.SqlClient.SqlDataAdapter adapter = new System.Data.SqlClient.SqlDataAdapter(); adapter.SelectCommand = cmd; conn.Open(); adapter.Fill(datadet); conn.Close(); } return datadet; }
/// <summary> /// 执行查询，并返回查询的Table /// </summary> /// <param name="tableIndex"></param> /// <returns></returns> public System.Data.DataTable ExecuteDataSet(int tableIndex) { System.Data.DataSet datadet = ExecuteDataSet(); if (datadet.Tables.Count > 0 && tableIndex < datadet.Tables.Count) { return datadet.Tables[tableIndex]; } else { return null; } }
/// <summary> /// 执行查询，并返回查询的Table /// </summary> /// <returns></returns> public System.Data.DataTable ExecuteDataTable() { System.Data.DataTable table = new System.Data.DataTable(); using (conn) { System.Data.SqlClient.SqlDataAdapter adapter = new System.Data.SqlClient.SqlDataAdapter(); adapter.SelectCommand = cmd; conn.Open(); adapter.Fill(table); conn.Close(); } return table; } |
DataProvider提供ExecuteReader、ExecuteNonQuery、ExecuteScalar、ExecuteDataSet和ExecuteDataTable方法，向使用者封装了两种不同的信息：
对执行数据访问的过程（Open后要Close等）已经在执行过程中的辅助对象（DataAdapter）信息。使用者仅需要简单的调用上述的方法，既可以得到他所关注的数据。
1.5实现DataProvider参数部分
|
SqlDataProvider类实现（参数部分） |
|
/// <summary> /// 添加一个Variant类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, object value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.Variant).Value = value; }
/// <summary> /// 添加一个Bit类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, bool value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.Bit).Value = value; }
/// <summary> /// 添加一个TinyInt类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, byte value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.TinyInt).Value = value; }
/// <summary> /// 添加一个SmallInt类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, short value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.SmallInt).Value = value; }
/// <summary> /// 添加一个Int类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, int value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.Int).Value = value; }
/// <summary> /// 添加一个BigInt类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, long value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.BigInt).Value = value; }
/// <summary> /// 添加一张图片 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, System.Drawing.Bitmap value) { System.IO.MemoryStream ms = new System.IO.MemoryStream(); value.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg); AddParameters(parname, ms.ToArray(), ByteArrayFamily.Image); }
/// <summary> /// 添加一个Timestamp类型 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, byte[] value) { AddParameters(parname, value, ByteArrayFamily.Timestamp); }
/// <summary> /// 添加一个字节数组族类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> /// <param name="dateType"></param> public void AddParameters(string parname, byte[] value, ByteArrayFamily dataType) { cmd.Parameters.Add(parname, DataTypeAdapter.ConvertSqlDbType(dataType)).Value = value; }
/// <summary> /// 添加一个字符类型数据，默认是NVarChar，长度是value.Length /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, string value) { AddParameters(parname, value, StringFamily.NVarChar, value.Length); }
/// <summary> /// 添加一个字符族类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> /// <param name="length"></param> public void AddParameters(string parname, string value, int size) { AddParameters(parname, value, StringFamily.NVarChar, size); }
/// <summary> /// 添加一个字符族类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> /// <param name="dateType"></param> /// <param name="length"></param> public void AddParameters(string parname, string value, StringFamily dataType) { AddParameters(parname, value,dataType, value.Length); }
/// <summary> /// 添加一个字符族类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> /// <param name="dateType"></param> /// <param name="size"></param> public void AddParameters(string parname, string value, StringFamily dataType, int size) { cmd.Parameters.Add(parname, DataTypeAdapter.ConvertSqlDbType(dataType), size).Value = value; }
/// <summary> /// 添加一个SmallDateTime类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, DateTime value) { AddParameters(parname, value, DateFamily.SmallDateTime); }
/// <summary> /// 添加一个日期族类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> /// <param name="dateType"></param> public void AddParameters(string parname, DateTime value, DateFamily dataType) { cmd.Parameters.Add(parname, DataTypeAdapter.ConvertSqlDbType(dataType)).Value = value; }
/// <summary> /// 添加一个Decimal类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, decimal value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.Decimal).Value = value; }
/// <summary> /// 添加Float类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, float value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.Float).Value = value; }
/// <summary> /// 添加一个UniqueIdentifier类型数据 /// </summary> /// <param name="parname"></param> /// <param name="value"></param> public void AddParameters(string parname, System.Guid value) { cmd.Parameters.Add(parname, System.Data.SqlDbType.UniqueIdentifier).Value = value; } |
ADO.Net对参数的处理冗长的很，需要很多代码，我们的DataProvider通过重载简单的实现了对参数的处理，使用者在大多数情况下只需要提供两个参数：参数的名称和值。DataProvider和根据值的类型推算应该使用具体的哪个System.Data.SqlDbType。
1.6定义C#和SQL数据类型的关系
不过，另人烦恼的是C#的数据类型和SQL的数据类型不是简单的一对一的关系，而是一对多的复杂关系，我们需要有一个方法来适配数据类型的不同。
|
数据类型的关系定义 |
|
/// <summary> /// C#对于的SQL类型 /// </summary> public enum StringFamily { Char, NChar, NText, NVarChar, Text, VarChar }
/// <summary> /// C#对于的SQL类型 /// </summary> public enum DateFamily { DateTime, SmallDateTime, Date, Time, DateTime2, DateTimeOffset }
/// <summary> /// C#对于的SQL类型 /// </summary> public enum ByteArrayFamily { Binary, Image, Timestamp, VarBinary } |
1.7定义数据类型的适配器
|
DataTypeAdapter的定义 |
|
/// <summary> /// SqlDbType数据类型和.NET Framework数据类型的适配器 /// </summary> public static class DataTypeAdapter { /// <summary> /// 将.NET Framework数据类型适配为SqlDbType数据类型 /// </summary> /// <param name="data"></param> /// <returns></returns> public static System.Data.SqlDbType ConvertSqlDbType(StringFamily data) { switch (data) { case StringFamily.Char: return System.Data.SqlDbType.Char; case StringFamily.NChar: return System.Data.SqlDbType.NChar; case StringFamily.NText: return System.Data.SqlDbType.NText; case StringFamily.NVarChar: return System.Data.SqlDbType.NVarChar; case StringFamily.Text: return System.Data.SqlDbType.Text; default: return System.Data.SqlDbType.VarChar; } }
/// <summary> /// 将.NET Framework数据类型适配为SqlDbType数据类型 /// </summary> /// <param name="data"></param> /// <returns></returns> public static System.Data.SqlDbType ConvertSqlDbType(DateFamily data) { switch (data) { case DateFamily.Date: return System.Data.SqlDbType.Date; case DateFamily.DateTime: return System.Data.SqlDbType.DateTime; case DateFamily.DateTime2: return System.Data.SqlDbType.DateTime2; case DateFamily.DateTimeOffset: return System.Data.SqlDbType.DateTimeOffset; case DateFamily.SmallDateTime: return System.Data.SqlDbType.SmallDateTime; default: return System.Data.SqlDbType.Time; } }
/// <summary> /// 将.NET Framework数据类型适配为SqlDbType数据类型 /// </summary> /// <param name="data"></param> /// <returns></returns> public static System.Data.SqlDbType ConvertSqlDbType(ByteArrayFamily data) { switch (data) { case ByteArrayFamily.Binary: return System.Data.SqlDbType.Binary; case ByteArrayFamily.Image: return System.Data.SqlDbType.Image; case ByteArrayFamily.Timestamp: return System.Data.SqlDbType.Timestamp; default: return System.Data.SqlDbType.VarBinary; } }
} |
通过上述的数据类型适配，我们将使用者和ADO.Net直接的具体关系弱耦合了。
1.8使用DataProvider
|
使用DataProvider（Select） |
|
DataProviders.IDataProvider provider = CreateDataProvider(); provider.SQL = "SELECT CompanyID as [Identity],Name,ShortName,Code,LegalEntity,Address,PostalCode,Type as CompanyType,CityID,Version " + "FROM lt_dictionary.Company WHERE CityID=@cityid"; provider.AddParameters("@cityid", cityID);
return provider.ExecuteDataTable();
|
|
使用DataProvider（Update） |
|
DataProviders.IDataProvider provider = CreateDataProvider(); provider.SQL = "UPDATE lt_dictionary.Company " + "SET " + "Name=@name, " + "ShortName=@shortName," + "Code=@code," + "LegalEntity=@legalEntity," + "Address=@address," + "PostalCode=@postalCode, " + "Type=@type," + "CityID=@cityID " + "WHERE CompanyID=@id AND Version=@ver";
provider.AddParameters("@name", company.Name); provider.AddParameters("@shortName", company.ShortName); provider.AddParameters("@Code", company.Code); provider.AddParameters("@LegalEntity", company.LegalEntity); provider.AddParameters("@address", company.Address); provider.AddParameters("@postalCode", company.PostalCode); provider.AddParameters("@type", company.CompanyType.ToString()); provider.AddParameters("@cityID", company.City.Identity); provider.AddParameters("@id", original_company.Identity); provider.AddParameters("@ver", original_company.Version, DataProviders.ByteArrayFamily.Timestamp);
return provider.ExecuteNonQuery() > 0;
|
|
使用DataProvider（Insert） |
|
DataProviders.IDataProvider provider = CreateDataProvider(); provider.SQL = "INSERT INTO lt_dictionary.City " + "([Name],PostalCode,DistanceCode,Province,Longitude,Latitude)" + "VALUES " + "(@Name,@PostalCode,@DistanceCode,@Province,@Longitude,@Latitude)"; provider.AddParameters("@name", city.Name); provider.AddParameters("@postalCode", city.PostalCode); provider.AddParameters("@distanceCode", city.DistanceCode); provider.AddParameters("@province", city.Province); provider.AddParameters("@longitude", city.Longitude); provider.AddParameters("@latitude", city.Latitude);
return provider.ExecuteNonQuery() > 0; |
通过上述的代码，可以发现，使用了我们的DataProvider后，程序员对ADO.Net的了解被降到最低程度，其只要关心具体的SQL指令和参数的赋值，其他内容不再需要其关注。很高程度的提高了程序员的开发效率。
二、打造实体基类
关系型数据表中一般有共性的部分是所有的实体都有ID（但ID的类型不一样），很多业务表都有主从的关系。
2.1表定义
比如下面的表
|
City定义 |
|
CREATE TABLE [lt_dictionary].[City]( [CityID] [int] IDENTITY(1,1) NOT NULL, [Name] [nvarchar](50) NOT NULL, [PostalCode] [dbo].[PostalCodeType] NOT NULL, [DistanceCode] [nvarchar](5) NOT NULL, [Province] [nvarchar](3) NOT NULL, [Longitude] [decimal](5, 2) NOT NULL, [Latitude] [decimal](5, 2) NOT NULL, [Enable] [dbo].[EnableType] NOT NULL CONSTRAINT [DF_City_Enable] DEFAULT ((1)), [LastEditDate] [dbo].[BusinessDateType] NOT NULL CONSTRAINT [DF_City_LastEditDate] DEFAULT (getdate()), [UpdateDay] AS (datediff(day,[LastEditDate],getdate())), [Version] [timestamp] NOT NULL, CONSTRAINT [PK_City] PRIMARY KEY CLUSTERED ( [CityID] ASC ) |
这个城市表的ID是int的。
|
BusinessOrders定义 |
|
CREATE TABLE [lt_business].[BusinessOrders]( [BusinessOrderID] [uniqueidentifier] NOT NULL CONSTRAINT [DF_BusinessOrders_BusinessOrderID] DEFAULT (newid()), [Number] [dbo].[BusinessOrderType] NOT NULL CONSTRAINT [DF_BusinessOrders_Number] DEFAULT ([dbo].[CreateBusinessOrderNumber]('Bz')), [Deadline] [dbo].[BusinessDateType] NOT NULL, [PaymentMethod] [nchar](2) NOT NULL, [PaymentEnterprise] [dbo].[DescriptionType] NOT NULL, [Origin] [dbo].[DescriptionType] NOT NULL, [Destination] [dbo].[DescriptionType] NOT NULL, [DeliveryType] [nchar](2) NOT NULL, [Level] [dbo].[LevelType] NOT NULL, [Remark] [dbo].[DescriptionType] NOT NULL, [Indicator] [nvarchar](3) NOT NULL, [FreightPayable] [dbo].[DescriptionType] NOT NULL, [WarehouseID] [int] NOT NULL, [OrderID] [uniqueidentifier] NOT NULL, [BusinessDate] [dbo].[BusinessDateType] NOT NULL CONSTRAINT [DF_BusinessOrders_BusinessDate] DEFAULT (getdate()), [StaffID] [int] NOT NULL, [Version] [timestamp] NOT NULL, [State] AS ([dbo].[GetBusinessOrderState]([BusinessOrderID])), CONSTRAINT [PK_BusinessOrders] PRIMARY KEY CLUSTERED |
BusinessOrders的ID是uniqueidentifier类型。
|
BusinessOrderDetaileds定义 |
|
CREATE TABLE [lt_business].[BusinessOrderDetaileds]( [BusinessOrderDetailedID] [uniqueidentifier] NOT NULL CONSTRAINT [DF_BusinessOrderDetaileds_BusinessOrderDetailedID] DEFAULT (newid()), [BusinessOrderID] [uniqueidentifier] NOT NULL, [Serial] [int] NOT NULL, [GoodsDescription] [dbo].[DescriptionType] NOT NULL, [Packing] [nvarchar](2) NOT NULL, [Quantity] [decimal](18, 2) NOT NULL, [TotalPackages] [decimal](18, 2) NOT NULL, [Weight] [decimal](18, 2) NOT NULL, [Measurement] [decimal](18, 2) NOT NULL, [Version] [timestamp] NOT NULL, [State] AS ([dbo].[GetBusinessOrderItmeState]([BusinessOrderDetailedID])), [CompleteQuantity] AS ([dbo].[GetBusinessOrderItmeCompleteQuantity]([BusinessOrderDetailedID])), CONSTRAINT [PK_BusinessOrderDetaileds] PRIMARY KEY CLUSTERED |
BusinessOrderDetaileds的ID是uniqueidentifier类型，其外键对应的是BusinessOrders实体的ID。
2.2关于实体基类定义的要求
我希望有这个的实体基类，该实体定义了所有的继承者（实体的具体实现类）都必须有ID属性，但ID属性的数据类型由各实体自己定义。我还希望，能在类的定义上看出有主从表的关系，并且能约束主从表的一些行为。而且我还希望基类能自动的实现对属性的赋值。
2.3定义EntityBase
|
EntityBase定义（继承部分） |
|
[Serializable] public abstract class EntityBase<T,ID> where T : EntityBase<T,ID> {
/// <summary> /// 所有的实体都必须有一个唯一标识，具体类型有实体各自实现 /// </summary> [System.ComponentModel.DataObjectField(true, true, false)] public virtual ID Identity { set; get; } } |
EntityBase定义了一个ID的泛型，该泛型描述了继承者必须实现具体的ID类型。
2.4定义EntityBase的Undo功能
在没有泛型的年代时，基类无了解子类的类型，因此基类只能实现一些返回或参数是基本数据类型的方法，如果要为子类提供个性化的方法，基类只能以object对象返回，且要求子类实现数据类型的强制转换。但现在，EntityBase还提供了一个T类型，因此我们可以实现Undo的功能。
|
EntityBase（Undo部分） |
|
/// <summary> /// 实体是否支持撤销 /// </summary> public abstract bool HasUndo { get; }
/// <summary> /// 还可以撤销的次数 /// </summary> public int UndoCount { get { return undoStack.Count; } }
/// <summary> /// 得到实体的副本 /// </summary> /// <returns></returns> protected virtual T Clone() { return (T)this.MemberwiseClone(); }
/// <summary> /// 将复本入栈 /// </summary> protected void Push() { if (this.HasUndo) { this.Push((T)this.Clone()); } }
/// <summary> /// 将复本入栈 /// </summary> /// <param name="obj"></param> private void Push(T obj) { if (this.HasUndo) { undoStack.Push(obj.Clone()); } }
private System.Collections.Generic.Stack<T> undoStack = new Stack<T>();
/// <summary> /// 将复本出栈 /// </summary> /// <returns></returns> private T Pop() { if (undoStack.Count > 0) { return undoStack.Pop(); } else { return null; } } /// <summary> /// 撤销 /// </summary> /// <returns></returns> public T Undo() { return Pop(); } |
使用了泛型，我们在类的内部提供了泛型队列，然后返回值和参数值都是泛型T，该T将由各个子类来具体实现。
2.5定义EntityBase的数据访问能力
|
|
|
/// <summary> /// 根据给定的连接字符串构造数据提供者 /// </summary> /// <param name="connStr"></param> /// <returns></returns> protected static DataProviders.IDataProvider CreateDataProvider(string connStr) { return new DataProviders.SqlDataProvider.SqlDataProvider(connStr); } |
2.6定义EntityBase的构造函数
EntityBase有一个接受System.Data.DataTable的构造函数，该构造函数将table中指定行的数据和本类的属性作对比，如果名称和数据类型匹配，则自动赋值。
|
EntityBase构造函数 |
|
/// <summary> /// 按table的指定行数据进行属性的初始化 /// </summary> /// <param name="table"></param> /// <param name="indexRow"></param> public EntityBase(System.Data.DataTable table, int indexRow) { //遍历table中的每一列 for (int i = 0; i <= table.Columns.Count - 1; i++) { //按列的名称，试图从当前对象中获取同名属性
System.Reflection.PropertyInfo pinfo = this.GetType().GetProperty(table.Columns[i].ColumnName); if (pinfo != null) {//如果存在该属性
object value = table.Rows[indexRow][table.Columns[i].ColumnName];//提取列的当前行值
if (pinfo.PropertyType == table.Columns[i].DataType)//如果对象属性定义的类型和table的列的类型一致 {
pinfo.SetValue(this, value, null);//赋值 } else { if (pinfo.PropertyType.IsEnum)//如果对象属性的值是枚举类型 {
if (value.GetType() == typeof(int))//数据库中保存的是int类型，则直接为枚举赋值 { pinfo.SetValue(this, value, null);//赋值 } if (value.GetType() == typeof(string))//如果数据库中保存的是string类型 { pinfo.SetValue(this, Enum.Parse(pinfo.PropertyType, value.ToString(), false), null);//赋值 } }
//如果对象的属性是Bitmap类型，对应的数据值是byte[] if (pinfo.PropertyType==typeof(System.Drawing.Bitmap) && value.GetType()==typeof(byte[])) { pinfo.SetValue(this, new System.Drawing.Bitmap(new System.IO.MemoryStream((byte[])value)), null);//赋值 } } } } } |
2.7定义EntityBase的CreateInstance
虽然EntityBase的构造函数有能力实现对属性的自动赋值，但我们可能要实例对象的集合或决定table中是否有值，应此我们需要实现CreateInstance方法。
|
定义EntityBase的CreateInstances方法 |
|
/// <summary> /// 通过table实例化一组对象 /// </summary> /// <param name="table"></param> /// <returns></returns> public static List<T> CreateInstances(System.Data.DataTable table, int startRecord, int maxRecords) { List<T> instances = new List<T>();
for (int i = startRecord; i <= maxRecords; i++) { instances.Add(CreateInstance(table, i)); } return instances; }
/// <summary> /// 通过table实例化一个对象 /// </summary> /// <param name="table"></param> /// <param name="startRecord"></param> /// <param name="maxRecords"></param> /// <returns></returns> public static T CreateInstance(System.Data.DataTable table, int rowIndex) { if (table.Rows.Count > rowIndex) { return (T)System.Activator.CreateInstance(typeof(T), table, rowIndex); } else { return null; } }
/// <summary> /// 默认按table的第一行实例化一个对象 /// </summary> /// <param name="table"></param> /// <returns></returns> public static T CreateInstance(System.Data.DataTable table) { return CreateInstance(table, 0); }
/// <summary> /// 通过table实例化一组对象 /// </summary> /// <param name="table"></param> /// <param name="startRecord"></param> /// <returns></returns> public static List<T> CreateInstances(System.Data.DataTable table, int startRecord) { return CreateInstances(table, startRecord, table.Rows.Count - 1); }
/// <summary> /// 通过table实例化一组对象 /// </summary> /// <param name="table"></param> /// <returns></returns> public static List<T> CreateInstances(System.Data.DataTable table) { return CreateInstances(table, 0, table.Rows.Count - 1); } |
2.8使用EntityBase
|
返回单个实例对象 |
|
/// <summary> /// 按指定的名字返回城市对象 /// </summary> /// <param name="cityName"></param> /// <returns></returns> [System.ComponentModel.DataObjectMethod(System.ComponentModel.DataObjectMethodType.Select, false)] public static City SelectByName(string cityName) { DataProviders.IDataProvider provider = CreateDataProvider(); provider.SQL = "SELECT CityID as [Identity],Name,PostalCode,DistanceCode,Province,Longitude,Latitude,Version " + "FROM lt_dictionary.City WHERE Name=@name"; provider.AddParameters("@name", cityName); return CreateInstance(provider.ExecuteDataTable()); } |
|
返回集合对象 |
|
/// <summary> /// 返回所有禁用状态的城市信息 /// </summary> /// <returns></returns> [System.ComponentModel.DataObjectMethod(System.ComponentModel.DataObjectMethodType.Select, false)] public static List<City> SelectIsDisabled() { DataProviders.IDataProvider provider = CreateDataProvider(); provider.SQL = "SELECT CityID as [Identity],Name,PostalCode,DistanceCode,Province,Longitude,Latitude,Version " + "FROM lt_dictionary.City WHERE Enable=0"; //返回List<City> return CreateInstances(provider.ExecuteDataTable()); } |
三、定义主从实体基类
定义主从实体基类的原因是我希望在类的定义时，可以很明确的了解类之间的主从关系。
3.1定义主表基类
|
定义PrimaryDataEntityBase |
|
/// <summary> /// 描述主从表的主表的数据实体 /// </summary> /// <typeparam name="ID">主表实体的主键ID</typeparam> /// <typeparam name="P">主表</typeparam> /// <typeparam name="F">从表</typeparam> public abstract class PrimaryDataEntityBase<ID, P, F> : EntityBase<P, ID> where P : PrimaryDataEntityBase<ID, P, F> where F : ForeignDataEntityBase<ID, P, F> { /// <summary> /// PrimaryDataEntityBase的默认构造函数 /// </summary> public PrimaryDataEntityBase() {
}
/// <summary> /// 按table的第一行数据进行属性的初始化 /// </summary> /// <param name="table"></param> public PrimaryDataEntityBase(System.Data.DataTable table) : this(table, 0) {
}
/// <summary> /// 按table的指定行数据进行属性的初始化 /// </summary> /// <param name="table"></param> /// <param name="indexRow"></param> public PrimaryDataEntityBase(System.Data.DataTable table, int indexRow) : base(table, indexRow) {
}
/// <summary> /// 装载当前从表的详细项 /// </summary> protected abstract List<F> LoadDetailedItems();
/// <summary> /// 存放外键表的数据项目的集合 /// </summary> protected List<F> items = new List<F>();
/// <summary> /// 获取外键表数据的集合 /// </summary> public List<F> DetailedItems { get { return LoadDetailedItems(); } }
/// <summary> /// 返回外键表的数据项目数量 /// </summary> public int DetailedItemCount { get { return items.Count; } }
/// <summary> /// 将一个外键实体加入集合 /// </summary> /// <param name="item"></param> /// <returns></returns> public abstract void Add(F item);
/// <summary> /// 从集合中移除一个外键实体 /// </summary> /// <param name="item"></param> public abstract void Remove(F item);
/// <summary> /// 从集合中移除一个外键实体 /// </summary> /// <param name="index"></param> public abstract void RemoveAt(int index);
/// <summary> /// 返回或设置匹配索引的订单详细项 /// </summary> /// <param name="index"></param> /// <returns></returns> public abstract F this[int index] { set; get; } } |
3.2定义从表基类
|
定义ForeignDataEntityBase |
|
/// <summary> /// 描述主从表的从表的数据实体 /// </summary> /// <typeparam name="ID">从表实体的主键ID</typeparam> /// <typeparam name="P">主表</typeparam> /// <typeparam name="F">从表</typeparam> public abstract class ForeignDataEntityBase<ID, P, F> : EntityBase<F, ID> where P : PrimaryDataEntityBase<ID, P, F> where F : ForeignDataEntityBase<ID, P, F> { /// <summary> /// ForeignDataEntityBase的默认构造函数 /// </summary> public ForeignDataEntityBase() {
}
/// <summary> /// 按table的第一行数据进行属性的初始化 /// </summary> /// <param name="table"></param> public ForeignDataEntityBase(System.Data.DataTable table) : this(table, 0) {
}
/// <summary> /// 按table的指定行数据进行属性的初始化 /// </summary> /// <param name="table"></param> /// <param name="indexRow"></param> public ForeignDataEntityBase(System.Data.DataTable table, int indexRow) : base(table, indexRow) {
}
/// <summary> /// 对应主键实体 /// </summary> [System.ComponentModel.DataObjectField(false, false, false)] public P RelationOrder { set; get; } } |
3.3使用主从表基类
|
|
|
/// <summary> /// 客户委托单 /// </summary> [System.ComponentModel.DataObject(true)] public class BusinessOrder : LogisticsOrderBase<BusinessOrder, BusinessOrderItem> { }
/// <summary> /// 委托单详细 /// </summary> [System.ComponentModel.DataObject(true)] public class BusinessOrderItem : DetailedItemBase<BusinessOrder, BusinessOrderItem> { }
|
现在我们的类在定义的时候，就可以非常明确的描述了主从实体的关系，并拥有了数据自动属性装载的能力。
四、结论
反射可以让我们动态的了解对象的所有成员，通过对tabel的遍历和对本对象的遍历，我们可以很方便的实现对属性的赋值，减少了程序员的重复性工作。而减少代码并不是可以偷懒，而是可以降低错误的产生机会。
而泛型可以在具体的实现之前，定义将来的类型，并且能对类型做出很多约束。使用了泛型以后，我们可以在基类为子类的多态做出更多的多态实现，现在我们的类对于静态方法也可以产生多态了，不是吗？
