打造自己的数据访问层(续)-ORM实施方案

在前几篇打造自己的数据访问层中,已经实现了最基本的数据访问层,基于程序开发中ORM的火热程度,笔者一直在思考,我们的数据访问层是否也能引入ORM的概念,哪怕是最基础的实现。
既然有想法,就该动手实施。
ORM,说到底就是将对象实体与数据表之间建立映射关系。
实施的话,首先得先提一提反射及自定义属性,试想一下,有如下模型,如何将其与数据表建立关联? 
public class TestModel
{
public string ID
{
get;
set;
}

public string NAME
{
get;
set;
}

public string VAL
{
get;
set;
}
}

自定义属性在此时就派上用场了,定义表名、主键,应用于模型之上,通过反射获取对应信息。
看看如何编写自定义属性,实质上只需继承Attribute即可,我们为属性标明表名、判断是否为主键,再判断是否为扩展(不需进行数据映射),就目前而言,有这些信息已足够了:
public class ORMAttribute : Attribute
{
private string tableName = "";

/// <summary>
/// 是否为主键
/// </summary>
public bool IsKey = false;

/// <summary>
/// 是否为扩展信息
/// </summary>
public bool IsExtend = false;

public ORMAttribute()
{

}

public ORMAttribute(string tableName)
{
this.tableName = tableName;
}

public string GetTableName()
{
return tableName;
}
}

应用于对象模型之上:
[ORMAttribute("TEST")]
public class TestModel
{
[ORMAttribute(IsKey
= true)]
public string ID
{
get;
set;
}

public string NAME
{
get;
set;
}

public string VAL
{
get;
set;
}
}

定义了属性,就得获取相应信息,这时反射来了了,通过Type来获取属性实例,并进一步获取对象信息,这是的关键方法是GetCustomAttributes,用于获取自定属性集:
/// <summary>
/// 从模型中获取数据表名
/// </summary>
public static string GetTableName(Type type)
{
ORMAttribute attr
= null;
object[] attributes = type.GetCustomAttributes(false);
foreach (object o in attributes)
{
if (o.GetType() == typeof(ORMAttribute))
{
attr
= (ORMAttribute)o;
break;
}
}

return attr.GetTableName();
}

/// <summary>
/// 根据属性获取所有字段
/// 返回字典值表示是否为主键
/// </summary>
public static Dictionary<string, bool> GetColumns(PropertyInfo[] pis)
{
Dictionary
<string, bool> dictCols = new Dictionary<string, bool>();
bool isKey = false;
object[] attributes;
ORMAttribute attribute
= null;
foreach (PropertyInfo pi in pis)
{
isKey
= false;
attribute
= null;
attributes
= pi.GetCustomAttributes(false);
foreach (object o in attributes)
{
if (o.GetType() == typeof(ORMAttribute))
{
attribute
= (ORMAttribute)o;
isKey
= attribute.IsKey;
break;
}
}

if (attribute != null && attribute.IsExtend)
{
//丢弃扩展属性
continue;
}

dictCols.Add(pi.Name, isKey);
}

return dictCols;
}

表名、字段、主键都已获取,映射的主体内容已完全获取,接下来思考的是如何与现有数据访问层进行关联。
回过头来看看数据访问都做了些什么:
1、获取实体访问数据库。
2、建立内存表与物理表的之间映射关系。
3、以DataSet为基础进行查询与更新操作。
该做的都已经做了,如果能将对对像模型进行的更改操作与DataSet建立同步关联的话,那么也就能实现对数据库的操作了。
接下来就该借助于自定集合了,具体方式请参考前篇:创建自定义集合,我们将实体模型保存于集合中,当集合进行增、删、改操作时,同步对DataSet进行修改。
实现同步,得利用事件原理了,关于事件,本篇不详述。
我们为集合定义三个事件:
新增、修改、删除,当集合进行此三种操作时事件将被自动激活:
public delegate void ORMEventHandler(object sender, ORMListEventArgs<T> e);
public event ORMEventHandler AddEvent;
public event ORMEventHandler RemoveEvent;
public event ORMEventHandler UpdateEvent;
激活事件,以更新方法为例:
/// <summary>
/// 更新
/// </summary>
public void Update(T model)
{
if (UpdateEvent != null)
{
ORMListEventArgs
<T> e = new ORMListEventArgs<T>(model);
UpdateEvent(
this, e);
}
}

集合准备好了,再来就是要建立映射关系了,如数同据访问层的映射对象一样,这里同样需要一个映射对象,只是这里是的映射并不是与数据库实体间时行关联,而仅仅是对原数据访问层映射的一种重复利用而已,看看它应该具备的功能:
1、获取模型信息:表名、字段、主键。
2、将模型填充于集合当中。
3、对集合进行监听,当列表数据改变时,同步对DataSet进行修改。

第1点已经实现了,利用自定义属性。
看看第2点,填充对象集合,利用已有映射对象获取数据集,通过反射获取对象信息并进行赋值操作:
/// <summary>
/// 填充对象模型
/// </summary>
public void Fill(string sqlText)
{
//填充DataSet
map.Fill(sqlText, tableName);
dt
= executeObj.GetDataSet().Tables[tableName];

//填充对象模型
string typeName = ORMHelper.GetTypeName(type) ;
PropertyInfo pi
= null;
T model;
foreach (DataRow dr in dt.Rows)
{
model
= type.Assembly.CreateInstance(typeName) as T;
foreach (DataColumn dc in dt.Columns)
{
if (!dictCols.ContainsKey(dc.ColumnName))
{
continue;
}

pi
= type.GetProperty(dc.ColumnName);
pi.SetValue(model, dr[dc.ColumnName]
!= DBNull.Value ? dr[dc.ColumnName] : null, null);
}

lisORM.Add(model);
}
}

数据已填充完毕,最后剩下的就对集合进行监听,并触发监听事件。
至于监听时机,由于每对集合进行的修改操作都将被监听对象侦听到,因此,在第一次填充数据的时候,监听理应尚未开始,所以最好的监听时机应该在数据填充完毕后进行最好,在Fill方法中加入监听事件://侦听ORM列表改变事件
lisORM.AddEvent += new ORMList<T>.ORMEventHandler(OnModelAdded);
lisORM.RemoveEvent += new ORMList<T>.ORMEventHandler(OnModelRemove);
lisORM.UpdateEvent += new ORMList<T>.ORMEventHandler(OnModelUpdate);

监听到事件后,再来看看如何同步更新DataSet,以新增操作为例,同样通过反射获取对象信息,并将信息填充于DataSet中去:
/// <summary>
/// 自定义ORM列表,添加事件
/// </summary>
private void OnModelAdded(object sender, ORMListEventArgs<T> e)
{
DataRow dr
= dt.NewRow();
dr.BeginEdit();
PropertyInfo pi
= null;
foreach (string keyCol in dictCols.Keys)
{
pi
= type.GetProperty(keyCol);
try
{
dr[keyCol]
= Convert.ChangeType(pi.GetValue(e.Model, null), dt.Columns[keyCol].DataType);
}
catch (Exception)
{
dr[keyCol]
= DBNull.Value;
}
}

dr.EndEdit();
dt.Rows.Add(dr);
}

至此,ORM已实施完毕,只是一至到现在,我们还没有看到集合最终是如何更新到数据库中去的。实际上很简单,既然是在原有数据访问基础之上做的扩展,那么最终也应该由数据执行者来提交数据。

放出ORMapping的具体实现及帮助类:
View Code
public class ORMapping<T> where T : class
{
#region 变量区
private DataTable dt = null;
private IMappingExecute executeObj;
private ORMList<T> lisORM = null; //ORM列表
private DataMapping map = null; //数据映射
private Type type = null; //对象模型类型
Dictionary<string, bool> dictCols = null; //列字段名
private string tableName = ""; //物理表名
private string columns = ""; //列字段名
private string keyColumns = ""; //主键字段名
#endregion

#region 构造函数
private ORMapping()
{
//不允许无数据执行者的构造函数
}

public ORMapping(IMappingExecute executeObj)
{
lisORM
= new ORMList<T>();
type
= typeof(T);
GetModelInformation();

//获取数据执行者
this.executeObj = executeObj;
map
= new DataMapping(this.executeObj, tableName, keyColumns, columns);
}
#endregion

#region 公有方法

/// <summary>
/// 填充对象模型
/// </summary>
public void Fill(string sqlText)
{
//填充DataSet
map.Fill(sqlText, tableName);
dt
= executeObj.GetDataSet().Tables[tableName];

//填充对象模型
string typeName = ORMHelper.GetTypeName(type) ;
PropertyInfo pi
= null;
T model;
foreach (DataRow dr in dt.Rows)
{
model
= type.Assembly.CreateInstance(typeName) as T;
foreach (DataColumn dc in dt.Columns)
{
if (!dictCols.ContainsKey(dc.ColumnName))
{
continue;
}

pi
= type.GetProperty(dc.ColumnName);
pi.SetValue(model, dr[dc.ColumnName]
!= DBNull.Value ? dr[dc.ColumnName] : null, null);
}

lisORM.Add(model);
}

//侦听ORM列表改变事件
lisORM.AddEvent += new ORMList<T>.ORMEventHandler(OnModelAdded);
lisORM.RemoveEvent
+= new ORMList<T>.ORMEventHandler(OnModelRemove);
lisORM.UpdateEvent
+= new ORMList<T>.ORMEventHandler(OnModelUpdate);
}
#endregion

#region 支撑方法
/// <summary>
/// 获取对象模型信息
/// </summary>
private void GetModelInformation()
{
//获取所有字段、主键
dictCols = ORMHelper.GetColumns(type.GetProperties());
foreach (string key in dictCols.Keys)
{
if (dictCols[key])
{
keyColumns
+= string.Format(", {0}", key);
}

columns
+= string.Format(", {0}", key);
}

if (keyColumns.Length == 0)
{
throw new Exception("请使用[ORMAttribute(IsKey = true)]设置主键");
}

keyColumns
= keyColumns.Remove(0, 2);
columns
= columns.Remove(0, 2);

//获取表名
tableName = ORMHelper.GetTableName(type);
}
#endregion

#region 事件方法
/// <summary>
/// 自定义ORM列表,添加事件
/// </summary>
private void OnModelAdded(object sender, ORMListEventArgs<T> e)
{
DataRow dr
= dt.NewRow();
dr.BeginEdit();
PropertyInfo pi
= null;
foreach (string keyCol in dictCols.Keys)
{
pi
= type.GetProperty(keyCol);
try
{
dr[keyCol]
= Convert.ChangeType(pi.GetValue(e.Model, null), dt.Columns[keyCol].DataType);
}
catch (Exception)
{
dr[keyCol]
= DBNull.Value;
}
}

dr.EndEdit();
dt.Rows.Add(dr);
}

/// <summary>
/// 自定义ORM列表,移除事件
/// </summary>
private void OnModelRemove(object sender, ORMListEventArgs<T> e)
{
//根据主键获取移除行
string where = "";
PropertyInfo pi
= null;
foreach (string keyCol in dictCols.Keys)
{
if (!dictCols[keyCol])
{
continue;
}

pi
= type.GetProperty(keyCol);
where = string.Format(" AND {0} = '{1}'", keyCol, pi.GetValue(e.Model, null));
}

where = where.Remove(0, 5);
DataRow dr
= dt.Select(where)[0];
dr.Delete();
}

/// <summary>
/// 自定义ORM列表,更新事件
/// </summary>
private void OnModelUpdate(object sender, ORMListEventArgs<T> e)
{
//根据主键获取移除行
string where = "";
PropertyInfo pi
= null;
foreach (string keyCol in dictCols.Keys)
{
if (!dictCols[keyCol])
{
continue;
}

pi
= type.GetProperty(keyCol);
where = string.Format(" AND {0} = '{1}'", keyCol, pi.GetValue(e.Model, null));
}

where = where.Remove(0, 5);
DataRow dr
= dt.Select(where)[0];
dr.BeginEdit();
pi
= null;
foreach (string keyCol in dictCols.Keys)
{
if (dictCols[keyCol])
{
continue;
}

pi
= type.GetProperty(keyCol);
try
{
dr[keyCol]
= Convert.ChangeType(pi.GetValue(e.Model, null), dt.Columns[keyCol].DataType);
}
catch (Exception)
{
dr[keyCol]
= DBNull.Value;
}
}

dr.EndEdit();
}
#endregion

#region 获取ORM列表
/// <summary>
/// 获取自定义ORM列表
/// </summary>
public ORMList<T> GetORMList
{
get
{
return lisORM;
}
}
#endregion
}

public class ORMHelper
{
#region 从模型中获取数据表名
/// <summary>
/// 从模型中获取数据表名
/// </summary>
public static string GetTableName(Type type)
{
ORMAttribute attr
= null;
object[] attributes = type.GetCustomAttributes(false);
foreach (object o in attributes)
{
if (o.GetType() == typeof(ORMAttribute))
{
attr
= (ORMAttribute)o;
break;
}
}

return attr.GetTableName();
}
#endregion

#region 获取类型名称
/// <summary>
/// 获取类型名称
/// </summary>
public static string GetTypeName(Type type)
{
return string.Format("{0}.{1}", type.Namespace, type.Name);
}
#endregion

#region 对对象模型进行赋值操作
/// <summary>
/// 对对象模型进行赋值操作
/// </summary>
public static void SetValue<T>(T model, Type type, DataRow dr, DataColumnCollection dcs) where T : class
{
PropertyInfo pi
= null;
foreach (DataColumn dc in dcs)
{
pi
= type.GetProperty(dc.ColumnName);
if (pi == null)
{
continue;
}

pi.SetValue(model, dr[dc.ColumnName],
null);
}
}
#endregion

#region 获取主键集
/// <summary>
/// 获取主键集
/// </summary>
public static IList<string> GetKeyColumns(PropertyInfo[] pis)
{
IList
<string> lisKeys = new List<string>();
object[] attributes;
ORMAttribute attribute
= null;
foreach (PropertyInfo pi in pis)
{
attribute
= null;
attributes
= pi.GetCustomAttributes(false);
foreach (object o in attributes)
{
if (o.GetType() != typeof(ORMAttribute))
{
continue;
}

attribute
= (ORMAttribute)o;
if (attribute.IsKey)
{
lisKeys.Add(pi.Name);
}
}
}

return lisKeys;
}
#endregion

#region 根据属性获取所有字段
/// <summary>
/// 根据属性获取所有字段
/// 返回字典值表示是否为主键
/// </summary>
public static Dictionary<string, bool> GetColumns(PropertyInfo[] pis)
{
Dictionary
<string, bool> dictCols = new Dictionary<string, bool>();
bool isKey = false;
object[] attributes;
ORMAttribute attribute
= null;
foreach (PropertyInfo pi in pis)
{
isKey
= false;
attribute
= null;
attributes
= pi.GetCustomAttributes(false);
foreach (object o in attributes)
{
if (o.GetType() == typeof(ORMAttribute))
{
attribute
= (ORMAttribute)o;
isKey
= attribute.IsKey;
break;
}
}

if (attribute != null && attribute.IsExtend)
{
//丢弃扩展属性
continue;
}

dictCols.Add(pi.Name, isKey);
}

return dictCols;
}
#endregion
}

最后看看如何使用:
string sqlText = "SELECT * FROM TEST";
DataExecutor exec
= ExecutorFactory.Create();
ORMapping
<TestModel> map = new ORMapping<TestModel>(exec.GetInstant());
map.Fill(sqlText);
ORMList
<TestModel> lisOrm = map.GetORMList;
TestModel model
= lisOrm.Find(item => item.ID == "09b221a8-2389-4d81-b3fe-68bc8419d27f");
if(model != null)
{
model.NAME
= "模型修改";
lisOrm.Update(model);
}

exec.Update();

关于ORM的实施,实际是在数据访问层之上再加了一层映射,因而在进行实际数据操作的时候是多做了一次处理,对于性能上是有一定损耗的,其好处也是显而易见的,更接近于OO思想,可读性提高。至于到底要不要使用ORM,得由具体使用场景及开发习惯来决定了。
 
posted @ 2011-05-28 22:00  flysoul  阅读(2029)  评论(5编辑  收藏