通过反射进行数据访问层的抽象

     新项目中与Team的成员讨论了一下关于数据访问层的整理和重构，基于对原有的访问层的一些不满意：主要是每个方法都要自己手写SQL语句这一状况，我提出建议是使用O/R Mapping工具，现在这类工具有如过江之鲫，但比较好用也就是那几个：nHibernate，iBatis.Net，nObject。但这一提议并没有收到效果，Team里的成员有些没有接触过这些框架，且害怕学习曲线过长，无法在项目的预期时间内完成任务，只得作罢。

    后来与他们聊了聊，大家的想法是：如果能一个操作器，只要简单地将我们定义的实体类塞进去，而访问层就能完成，那就是最理想的情况——即，DAL层都不愿一个个写方法了。是人就想要偷偷懒，这也是人类进步的动力嘛：）况且程序员本来就是最懒的一群人，宁愿多用些脑细胞，也不愿多写一行代码，对此深表理解~ 说白了，要做到DAL简单的几行代码搞定，那也就是自己开发O/R Mapping工具，不是多牛，至少是初级的，能更高抽象一些重复代码工作的框架。

    自然，这个光荣而艰巨的任务落在了本人的头上。怎么下手呢？首先跳入脑海的就是“反射”，无非就是，将数据库中的表一字不差的按列生成各个实体，列和实体中的字段名称相同，用反射来生成一些SQL句子，通过反射获取的字段属性PropertyInfo.GetValue()方法来做参数的绑定（SqlParameter，防注入）.，最后将这些方法提取出来，结合Ado.Net方法，给DAL层提供调用。

   有了思路，就可以动手了。

   假设有一张这样的表：TB_NEWS，其中id列既为主键又是自增列（自增列在生成通用代码，需要注意，必须进行处理）

    那么，定义一个实体类dtoNews与其对应：

 

using System;

namespace IndieFacade
{
    public class dtoNews
    {
        public dtoNews() { }

        private int m_id;
        private string m_author;
        private DateTime m_pubtime;
        private string m_contents;
        private int m_reads;
        private string m_tags;
        private string m_title;
        private string m_summary;

        /// <summary>
        /// ID 
        /// </summary>
        public int id
        {
            get { return m_id; }
            set { m_id = value; }
        }
        /// <summary>
        /// 标题 
        /// </summary>
        public string Title
        {
            get { return m_title; }
            set { m_title = value; }
        }
        /// <summary>
        /// Summary 
        /// </summary>
        public string Summary
        {
            get { return m_summary; }
            set { m_summary = value; }
        }
        /// <summary>
        /// Author 
        /// </summary>
        public string Author
        {
            get { return m_author; }
            set { m_author = value; }
        }
        /// <summary>
        /// Tags 
        /// </summary>
        public string Tags
        {
            get { return m_tags; }
            set { m_tags = value; }
        }
        /// <summary>
        /// Reads 
        /// </summary>
        public int Reads
        {
            get { return m_reads; }
            set { m_reads = value; }
        }
        /// <summary>
        /// Contents 
        /// </summary>
        public string Contents
        {
            get { return m_contents; }
            set { m_contents = value; }
        }
        /// <summary>
        /// 发布时间
        /// </summary>
        public DateTime PubTime
        {
            get { return m_pubtime; }
            set { m_pubtime = value; }
        }
    }
}

 

    然后，我写了这样一个DbCommon类，用于处理一些通用的方法，当然，只是试验了一个最简单的插入方法：

 

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;

namespace IndieFacade
{
    /// <summary>
    /// DB访问代理
    /// </summary>
    public class DbCommon
    {
        // ----------------------------------- 生成SQL串方法 --------------------------------- //
        /// <summary>
        /// 根据反射，将一个对象做为一条记录插入到表中
        /// </summary>
        /// <param name="_connString">数据库连接串</param>
        /// <param name="tableName">表名</param>
        /// <param name="dtoObject">实体类，与表中列名一致的实体</param>
        /// <param name="isIdentity">是否有自增长列</param>
        /// <param name="identityColNum">自增长列号</param>        
        /// <param name="errMsg">出错信息，参数传递</param>
        /// <returns>是否成功</returns>
        #region static bool InsertDtoToDb(string _connString,string tableName, object dtoObject, bool isIdentity, int identityColNum,ref string errMsg)
        public static bool InsertDtoToDb(string _connString,string tableName, object dtoObject, bool isIdentity, int identityColNum,ref string errMsg)
        {
            // 通过反射，生成INSERT操作所需要的串
            string _sqlcmd = DbCommon.GenerateInsertSQLText(tableName, dtoObject,isIdentity,identityColNum);
            // 通过反射，生成一个SqlParameter数组
            SqlParameter[] pars = DbCommon.GetParameters(dtoObject, isIdentity, identityColNum);
            // 数据连接
            SqlConnection _conn = new SqlConnection(_connString);

            try
            {                
                // 传入SQL语句，及绑定参数列表
                int res = DbCommon.ExcuteNoQuery(_conn, _sqlcmd, pars);
                if (res > 0)
                    return true;
                else
                    return false;
            }
            catch (Exception err)
            {
                errMsg = err.Message;
                return false;
            }
            finally
            {
                _conn.Close();
            }
        }
        #endregion

        /// <summary>
        /// 生成INSERT操作所需要的串
        /// </summary>
        /// <param name="tableName">要插入的表名</param>
        /// <param name="dtoObject">dto对象</param>
        /// <param name="isIdentity">是否有自增长列</param>
        /// <param name="identityColNum">自增长列号</param>
        /// <returns>串</returns>
        #region static string GenerateInsertSQLText(string tableName,object dtoObject,, bool isIdentity, int identityColNum)
        private static string GenerateInsertSQLText(string tableName, object dtoObject, bool isIdentity, int identityColNum)
        {
            string fieldstr = string.Empty;                // 字段的串
            string bindstr = string.Empty;                // 绑定变量的串
            string sqlstr = string.Empty;                // 最终SQL串

            // 反射DTO对象的各字段,必须把字段和DB中字段同名
            System.Reflection.PropertyInfo[] pps = dtoObject.GetType().GetProperties();
            // 列号
            int i = 0;

            foreach (System.Reflection.PropertyInfo pi in pps)
            {
                if (!isIdentity || identityColNum != i)
                {
                    fieldstr += pi.Name + ",";
                    bindstr += "@" + pi.Name + ",";
                }
                i++;
            }
            fieldstr = fieldstr.TrimEnd(new char[] { ',' });
            bindstr = bindstr.TrimEnd(new char[] { ',' });

            sqlstr = string.Format("INSERT INTO {0} ({1}) VALUES({2})", tableName, fieldstr, bindstr);

            return sqlstr;
        }
        #endregion

        /// <summary>
        /// 获取dto对象各字段对应到表中的绑定参数数组
        /// </summary>
        /// <param name="dtoObject">dto对象</param>
        /// <param name="isIdentity">是否有自增长列</param>
        /// <param name="identityColNum">自增长列号</param>
        /// <returns>绑定参数数组</returns>
        #region static SqlParameter[] GetParameters(object dtoObject, bool isIdentity, int identityColNum)
        private static SqlParameter[] GetParameters(object dtoObject, bool isIdentity, int identityColNum)
        {
            // 反射DTO对象的各字段,必须把字段和DB中字段同名
            System.Reflection.PropertyInfo[] pps = dtoObject.GetType().GetProperties();            
            // 确定成员数量，生成动态数组
            SqlParameter[] pars = (SqlParameter[])
                Array.CreateInstance(typeof(SqlParameter), isIdentity ? pps.Length - 1 : pps.Length);
            int i = 0;           

            foreach (System.Reflection.PropertyInfo pi in pps)
            {
                if (!isIdentity || identityColNum != i)
                {
                    pars[i] = new SqlParameter();
                    pars[i].ParameterName = string.Format("@{0}", pi.Name);
                    pars[i].Value = pi.GetValue(dtoObject, null);
                }

                i++;
            }

            return pars;
        }
        #endregion

        // ----------------------------------- 工具方法 --------------------------------------- //
        /// <summary>
        /// SQLDATAREADER
        /// </summary>
        #region static SqlDataReader ExcuteReader(SqlConnection conn, string cmdtext)
        public static SqlDataReader ExcuteReader(SqlConnection conn, string cmdtext)
        {            
            SqlCommand cmd = new SqlCommand(cmdtext, conn);            
            try
            {
                conn.Open();
                return cmd.ExecuteReader();
            }
            catch(Exception err)
            {
                conn.Close();
                throw err;
            }            
        }
        #endregion

        /// <summary>
        /// SQLDATAREADER参数版本
        /// </summary>
        #region static SqlDataReader ExcuteReader(SqlConnection conn, string cmdtext,params SqlParameter[] sqlparams)
        public static SqlDataReader ExcuteReader(SqlConnection conn, string cmdtext, params SqlParameter[] sqlparams)
        {           
            SqlCommand cmd = new SqlCommand(cmdtext, conn);
            if (sqlparams.Length > 0)
            {
                for (int i = 0; i < sqlparams.Length; i++)
                    cmd.Parameters.Add(sqlparams[i]);
            }

            try
            {
                conn.Open();
                return cmd.ExecuteReader();
            }
            catch (Exception err)
            {
                conn.Close();
                throw err;
            }           
        }
        #endregion

        /// <summary>
        /// SQLSCALAR
        /// </summary>
        #region static object ExcuteScalar(SqlConnection conn, string cmdtext)
        public static object ExcuteScalar(SqlConnection conn, string cmdtext)
        {            
            SqlCommand cmd = new SqlCommand(cmdtext, conn);
            try
            {
                conn.Open();
                return cmd.ExecuteScalar();
            }
            catch (Exception err)
            {
                conn.Close();
                throw err;
            }            
        }
        #endregion

        /// <summary>
        /// SQLSCALAR参数版本
        /// </summary>
        #region static object ExcuteScalar(SqlConnection conn, string cmdtext,params SqlParameter[] sqlparams)
        public static object ExcuteScalar(SqlConnection conn, string cmdtext, params SqlParameter[] sqlparams)
        {           
            SqlCommand cmd = new SqlCommand(cmdtext, conn);
            if (sqlparams.Length > 0)
            {
                for (int i = 0; i < sqlparams.Length; i++)
                    cmd.Parameters.Add(sqlparams[i]);
            }
            try
            {
                conn.Open();
                return cmd.ExecuteScalar();
            }
            catch (Exception err)
            {
                conn.Close();
                throw err;
            }           
        }
        #endregion

        /// <summary>
        /// ExcuteNoQuery
        /// </summary>
        /// <returns>影响行数</returns>
        #region static int ExcuteNoQuery(SqlConnection conn, string cmdtext)
        public static int ExcuteNoQuery(SqlConnection conn, string cmdtext)
        {
            SqlCommand cmd = new SqlCommand(cmdtext, conn);
            try
            {
                conn.Open();
                return cmd.ExecuteNonQuery();
            }
            catch (Exception err)
            {
                conn.Close();
                throw err;
            }           
        }
        #endregion

        /// <summary>
        /// ExcuteNoQuery参数版本
        /// </summary>
        /// <returns>影响行数</returns>
        #region static int ExcuteNoQuery(SqlConnection conn, string cmdtext, params SqlParameter[] sqlparams)
        public static int ExcuteNoQuery(SqlConnection conn, string cmdtext, params SqlParameter[] sqlparams)
        {
            SqlCommand cmd = new SqlCommand(cmdtext, conn);
            if (sqlparams.Length > 0)
            {
                for (int i = 0; i < sqlparams.Length; i++)
                    cmd.Parameters.Add(sqlparams[i]);
            }
            try
            {
                conn.Open();
                return cmd.ExecuteNonQuery();
            }
            catch (Exception err)
            {
                conn.Close();
                throw err;
            }
        }
        #endregion

        /// <summary>
        /// 获取指定表的总记录数
        /// </summary>
        /// <param name="connstr"></param>
        /// <param name="TableName"></param>
        #region static int GetRecordCount(string connstr, string TableName)
        public static int GetRecordCount(string connstr, string TableName)
        {
            // 取表的记录数
            string SQLTEXT = @"SELECT COUNT(*) FROM "+TableName;

            SqlConnection conn = new SqlConnection(connstr);
            try
            {                
                int count = (int)DbCommon.ExcuteScalar(conn, SQLTEXT);
                return count;
            }
            catch
            {
                return 0;
            }
            finally
            {
                if (conn.State != ConnectionState.Closed)
                    conn.Close();
            }

        }
        #endregion

        /// <summary>
        /// 获取指定表的总记录数（带条件）
        /// </summary>
        /// <param name="connstr"></param>
        /// <param name="TableName"></param>
        #region static int GetRecordCount(string connstr, string TableName,string Where)
        public static int GetRecordCount(string connstr, string TableName,string Where)
        {
            // 取表的记录数
            string SQLTEXT = @"SELECT COUNT(*) FROM " + TableName + " WHERE "+Where;

            SqlConnection conn = new SqlConnection(connstr);
            try
            {
                int count = (int)DbCommon.ExcuteScalar(conn, SQLTEXT);
                return count;
            }
            catch
            {
                return 0;
            }
            finally
            {
                if (conn.State != ConnectionState.Closed)
                    conn.Close();
            }

        }
        #endregion

        /// <summary>
        /// 返回指定SQL语句查询的记录条数
        /// </summary>
        /// <param name="pagesize"></param>
        /// <param name="bid"></param>
        /// <param name="SQLTEXT"></param>
        /// <param name="sqlparams"></param>
        #region static int GetPageCountBySQL(string connnstr,int pagesize,string SQLTEXT)
        public static int GetPageCountBySQL(string connstr, int pagesize, string SQLTEXT)
        {
            SqlConnection conn = new SqlConnection(connstr);

            try
            {
                int pagecount = 0;
                int count = (int)DbCommon.ExcuteScalar(conn, SQLTEXT);
                pagecount = count / pagesize;
                // 余数
                int yushu = count % pagesize;
                if (yushu > 0)
                    pagecount += 1;
                return pagecount;
            }
            catch (Exception err)
            {
                return 0;
            }
            finally
            {
                if (conn.State != ConnectionState.Closed)
                    conn.Close();
            }
        }
        #endregion

        /// <summary>
        /// 返回指定SQL语句查询的记录条数
        /// </summary>
        /// <param name="pagesize"></param>
        /// <param name="bid"></param>
        /// <param name="SQLTEXT"></param>
        /// <param name="sqlparams"></param>
        #region static int GetPageCountBySQL(string connnstr,int pagesize,string SQLTEXT,params SqlParameter[] sqlparams)
        public static int GetPageCountBySQL(string connstr,int pagesize,string SQLTEXT, params SqlParameter[] sqlparams)
        {
            SqlConnection conn = new SqlConnection(connstr);

            try
            {                
                int pagecount = 0;
                int count = (int)DbCommon.ExcuteScalar(conn, SQLTEXT, sqlparams);
                pagecount = count / pagesize;
                // 余数
                int yushu = count % pagesize;
                if (yushu > 0)
                    pagecount += 1;
                return pagecount;
            }
            catch (Exception err)
            {
                return 0;
            }
            finally
            {
                if (conn.State != ConnectionState.Closed)
                    conn.Close();
            }
        }
        #endregion
    }
}

 

   再写一个针对dtoNews实体与TB_NEWS表进行操作的DAL类：ManagerNews，调用DBCommon类中的方法进行这样的操作，将数据实体转换为一条数据记录：

 

using System;
using System.Collections.Generic;
using System.Text;

namespace IndieFacade
{
    public class ManagerNews :IDisposable
    {
        private string _connString;             // 连接串
        private string _message;                // 错误消息
        private string _tableName;              // 表名

        #region 对外接口:错误消息
        /// <summary>
        /// 错误消息
        /// </summary>
        public string Message
        {
            get { return this._message; }
        }
        #endregion

        #region 构造函数
        /// <summary>
        /// 使用默认配置，进行数据库连接
        /// </summary>
        public ManagerNews()
        {
            _connString = ConfigCache.ConnStr;
            _tableName = "TB_NEWS";
            _message = string.Empty;
        }

        /// <summary>
        /// 指定数据库连接串
        /// </summary>
        public ManagerNews(string connString)
        {
            _connString = connString;
            _tableName = "TB_NEWS";
            _message = string.Empty;
        }
        #endregion

        //----------------------------查询方法-----------------------------//
        /// <summary>
        /// 添加一个新闻
        /// </summary>
        /// <param name="blog">日志分类</param>
        /// <returns>成功否</returns>
        #region bool AddNews(dtoNews news)
        public bool AddNews(dtoNews news)
        {
            return DbCommon.InsertDtoToDb(this._connString,this._tableName, news,true,0,ref this._message);
        }
        #endregion

        //-----------------------实现Idisposable接口-----------------//

        // Implement IDisposable.
        // Do not make this method virtual.
        // A derived class should not be able to override this method.
        public void Dispose()
        {
            // This object will be cleaned up by the Dispose method.
            // Therefore, you should call GC.SupressFinalize to
            // take this object off the finalization queue 
            // and prevent finalization code for this object
            // from executing a second time.
            GC.SuppressFinalize(this);
        }
    }
}

 

   最后到客户端（例如WEB上的.aspx页面）就变得非常的轻松了：

private void Test()
    {
        dtoNews news = new dtoNews();
        news.id = 1;
        news.PubTime = DateTime.Now;
        news.Reads = 1;
        news.Summary = "";
        news.Tags = "";
        news.Title = "";
        news.Contents = "";
        news.Author = "";

        using (ManagerNews mn = new ManagerNews())
        {
            bool ss = mn.AddNews(news);
        }
    }

 

　　这个框架还很稚嫩，还只是解决了一两个如何偷懒的问题，至少在本人可怜的512内存机器上，性能堪忧，以后再慢慢改进吧。