我的ORM框架

任何系统的基础，都可以算是各种数据的增删改查（CRUD）。最早操作数据是直接在代码里写SQL语句，后来出现了各种ORM框架。C#下的ORM框架有很多，如微软自己的Entity Framework、第三方的NHibernate。这些ORM框架甚至可以直接隐去具体SQL语句，让开发人员直接面向持久化后的对象。

虽然这种ORM框架大大简化了开发流程，但也带来了一个很大的问题。开发人员不了解SQL，而有时候这些ORM框架自己生成的SQL语句效率极低。

想象一个场景：

某天DBA说：”那谁谁谁，这个数据操作性能太低，得优化一下。”

开发人员：“这是NHibernate自动生成的，关我屁事”

DBA：“这个查询跨表太多，容易造成死锁，需要修改一下”

开发人员：“这是NHibernate自动生成的SQL，我不会修改啊”

DBA：“%￥…*&（*“

所以在大型项目里，ORM封装的太好，反而有时候会带来问题。说句题外话，微软太照顾开发人员了，各种封装，虽然用起来舒服，开发效率快，但是对于一些特殊场景性能就跟不上。有一次一个团队成员用ASP.net的Treeview控件做树形菜单，生成的Html源代码足足有20M。

我自己用的ORM框架是多层+代码生成器。多层提供数据持久化，代码生成器生成基本的CRUD操作，如果有更复杂的业务，可以扩充。这样既可以封装重复的底层操作，让开发人员集中精力到业务上，也可以提供足够的灵活性。

代码生成器是基于动软代码生成器（http://www.maticsoft.com/codematic.aspx）2.41版本的源码做的二次开发：

在开发过程中，数据表发生变化，很常见。这样每次都要重新生成三层代码。为了防止新生成的代码覆盖我扩充的方法，可以将使用分部类将扩充方法放到单独一个文件中。举例来说：这有个用户类Users.cs，里面放了有关用户的CRUD：

我有个扩充方法Login，就可以新建一个Users的分部类，名字命名为Users.designer.cs 。VS会自动将这个文件折叠到User.cs的里面：

这样我以后即使重新生成代码，也不会覆盖掉扩充方法。

不过我觉得仍然过于繁琐。开发阶段表字段变来变去，每次都要重新覆盖3个文件，老陷入这种重复性的工作，真是有损程序员的清名。仔细考虑下，数据表字段和Model属性是一致的，而CRUD基本上都是对Model的操作。这样依靠反射和泛型两尊大神，可以将SQLHelper做进一步的简化：

• 新增和修改

Dataset构造一个DataRow，把Model中和表字段对应属性的值复制过来，然后提交到数据库。代码如下(同时支持新增和修改。如果数据库存在该记录，为修改，不存在为新增)：

public static bool ModelToDatabase(object model, string tabname)
{
    Type ObjType = model.GetType();
    PropertyInfo[] ObjProInfos = ObjType.GetProperties();
    string sql = "";
    DataSet ds = null;
    DataTable dt = null;
    DataRow dr = null;
    //检测是新增记录还是修改记录
    SqlConnection conn = Conn();
    try
    {
        SqlDataAdapter oda = null;
        bool IsEditFlag = false;
        //--------------------------
        foreach (PropertyInfo ObjProInfo in ObjProInfos)
        {
            if (ObjProInfo.Name.ToLower() == "id")
            {
                object IdObject = ObjProInfo.GetValue(model, null);
                if (IdObject != null)
                {
                    sql = "select top 1 * from " + tabname + " where id=" + StringPlus.SafeStrN(IdObject.ToString());
                    oda = new SqlDataAdapter(sql, conn);
                    ds = new DataSet();
                    oda.Fill(ds, tabname);
                    conn.Close();
                    dt = ds.Tables[0];
                    if (dt.Rows.Count == 0)
                    {
                        dr = dt.NewRow();
                        IsEditFlag = false;
                    }
                    else
                    {
                        dr = dt.Rows[0];
                        IsEditFlag = true;
                    }
                    break;
                }
                else
                {
                    sql = "select top 1 * from " + tabname;
                    oda = new SqlDataAdapter(sql, conn);
                    ds = new DataSet();
                    oda.Fill(ds, tabname);
                    conn.Close();
                    dt = ds.Tables[0];
                    dr = dt.NewRow();
                    IsEditFlag = false;
                    break;
                }
            }
        }
        //如果不存在ID这一个项，视为新建
        if (!IsEditFlag)
        {
            sql = "select top 1 * from " + tabname;
            oda = new SqlDataAdapter(sql, conn);
            ds = new DataSet();
            oda.Fill(ds, tabname);
            conn.Close();
            dt = ds.Tables[0];
            dr = dt.NewRow();
        }
        if (conn.State != ConnectionState.Closed)
            conn.Close();
        //开始构筑一条datarow
        ArrayList col = new ArrayList(dt.Columns.Count);
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            col.Add(dt.Columns[j].ColumnName.ToLower());
        }
        foreach (PropertyInfo ObjProInfo in ObjProInfos)
        {
            foreach (string DataColumn in col)
            {
                object objValue = ObjProInfo.GetValue(model, null);
                if (DataColumn.ToLower() == ObjProInfo.Name.ToLower())
                {
                    if (objValue != null)
                    {
                        dr[ObjProInfo.Name] = objValue;
                    }
                    else
                    {
                        dr[ObjProInfo.Name] = DBNull.Value;
                    }
                    break;
                }
            }
        }
        //将更改或新增的记录更新到数据库
        if (!IsEditFlag)
        {
            dt.Rows.Add(dr);
            SqlCommandBuilder ocb = new SqlCommandBuilder(oda);
            ocb.ConflictOption = ConflictOption.OverwriteChanges;
            ocb.QuotePrefix = "[";
            ocb.QuoteSuffix = "]";
            SqlCommand odc = ocb.GetInsertCommand();
            oda.Update(dt);
        }
        else
        {
            SqlCommandBuilder ocb = new SqlCommandBuilder(oda);
            ocb.ConflictOption = ConflictOption.OverwriteChanges;
            ocb.QuotePrefix = "[";
            ocb.QuoteSuffix = "]";
            SqlCommand odc = ocb.GetInsertCommand();
            oda.Update(dt);
        }
}
</span><span style="color: #0000ff">catch</span><span style="color: #000000"> (Exception)
{

}
</span><span style="color: #0000ff">finally</span><span style="color: #000000">
{
    </span><span style="color: #0000ff">if</span> (conn.State !=<span style="color: #000000"> ConnectionState.Closed)
    {
        conn.Close();
    }
}
</span><span style="color: #0000ff">return</span> <span style="color: #0000ff">true</span><span style="color: #000000">;

}

• 获取一个Model

这个是上一个操作的逆操作。先获取DataRow，然后把泛型实体化，通过反射赋值后返回：

/// <summary>
/// 通过一个Sql查询语句返回一个Model
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <returns></returns>
public static T DatabaseToModel<T>(string sql) where T : new()
{
    T model = new T();
    PropertyInfo[] MyProInfo = model.GetType().GetProperties();
    DataSet MyDS = ReturnDataset(sql);
    DataTable MyDT = MyDS.Tables[0];
    if (MyDT.Rows.Count > 0)
    {
        DataRow MyDR = MyDT.Rows[0];
        foreach (PropertyInfo MyPro in MyProInfo)
        {
            foreach (DataColumn MyDC in MyDT.Columns)
            {
                if (MyDC.ColumnName.ToLower() == MyPro.Name.ToLower())
                {
                    if (MyDR[MyDC] != System.DBNull.Value)
                    {
                    MyPro.SetValue(model, TypeConvertor.ConvertType(MyDR[MyDC], MyPro.PropertyType), </span><span style="color: #0000ff">null</span><span style="color: #000000">);
                }
                </span><span style="color: #0000ff">else</span><span style="color: #000000">
                    MyPro.SetValue(model, </span><span style="color: #0000ff">null</span>, <span style="color: #0000ff">null</span><span style="color: #000000">);
            }
        }
    }
    </span><span style="color: #0000ff">return</span><span style="color: #000000"> model;
}
</span><span style="color: #0000ff">else</span>
    <span style="color: #0000ff">return</span> <span style="color: #0000ff">default</span><span style="color: #000000">(T);

}

• 获取一个List<Model>

用datareader循环读取数据库，然后把每条数据构筑一个Model放到List中返回:

/// <summary>
/// 通过一个SQL检索字符串，返回一个List
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <returns></returns>
public static List<T> DatabaseToModels<T>(string sql) where T : new()
{
    List<T> RtnIl = new List<T>();
    SqlDataReader sdr = ExecuteReader(sql);
    while (sdr.Read())
    {
        T model = new T();
        PropertyInfo[] MyProInfo = model.GetType().GetProperties();
        foreach (PropertyInfo MyPro in MyProInfo)
        {
            for (int i = 0; i < sdr.FieldCount; i++)
            {
                if (MyPro.Name.ToLower() == sdr.GetName(i).ToLower())
                {
                    if (sdr[i] != System.DBNull.Value)
                    {
                        MyPro.SetValue(model, TypeConvertor.ConvertType(sdr[i], MyPro.PropertyType), null);
                    }
                    else
                    {
                        MyPro.SetValue(model, null, null);
                    }
                    break;
                }
            }
        }
        RtnIl.Add(model);
    }
    sdr.Close();
    return RtnIl;
}

如此一来，DAL层和BLL层就不会出现和表字段相关的变量。每次修改表后，只需要手动更改Model文件就可以。

如果更进一步偷懒，可以把修改Model写成一个自动化的过程。每次修改表，代码生成器自动去修改Model项目文件下的对应类文件。

当然任何事务都是有局限性的。用反射的问题就是性能会带来一些降低。不过一般系统性能的瓶颈大多数都在数据库和恶劣的业务算法。相比能带来开发效率上的提升，我觉得是非常值得的。