C# .NET更智能的数据库操作的封装

前述：

　　对数据库操作的封装，相信网络上已经有一大堆，ORM框架，或者是.NET本身的EF，都很好的支持数据库操作。这篇文章是分享自己所思考的，对数据库操作的简单封装。我对于这篇文章，认为被浏览者所关注重点的是怎么分析设计数据库操作封装，代码是其次。而且，这是我第一篇文章，为了想好怎么实现花了些天，代码是博客发表时现写的。所以我想，使用可能还有bug，而且没有try catch异常的设计。

　　这个框架我理应做到对数据库无关，无论是哪个数据库都能够使用。不过，重点在于分析，而不是代码。所以，为了更好的阐述，我只做了对sql Server的封装，对其他的话，浏览者可以自己设计；框架可支持链式写法，我想，在许多编程语言，大家对链式写法大不会陌生，所以我想，数据库访问也可以做成链式的模式。这个框架不需要写sql语句，对任何的操作，都只需要简单的传所需的参数，封装好对应的操作。

　　在阅读文章之前最好有些泛型、反射、Link的基础，不然阅读可能会有些费劲。

进入重点：

　　框架的结构比较简单，使用简单工厂模式，因此笔者就不画一张UML图来解释，而用文字对里面方法进行描述。

　　在设计工厂接口时候，应该考虑接口中应该含有链式写法必须的三个阶段（也称部分）：数据库基本操作（打开，关闭，创建等）、数据库的增删改查、数据库返回的数据（这里我做为执行阶段，估计大家会好奇为什么不是上一阶段，大家往下阅读就知道）和不是必须的事务操作。

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

 namespace Dal
 {
     public interface DbHelper
     {
         /// <summary>
         /// 创建数据库连接
         /// </summary>
         /// <param name="connectionString">连接字符串</param>
         /// <returns></returns>
         DbHelper createConnection(string connectionString);

         /// <summary>
         /// 打开数据库
         /// </summary>
         /// <returns></returns>
         DbHelper openConnection();

         /// <summary>
         /// 关闭数据库
         /// </summary>
         /// <returns></returns>
         DbHelper closeConnection();

         /// <summary>
         /// 释放sqlConnection对象
         /// </summary>
         void DisposedConnection();

         /// <summary>
         /// 释放sqlCommand对象
         /// </summary>
         void DisposedCommand();

         /// <summary>
         /// 创建sqlCommand对象
         /// </summary>
         /// <returns></returns>
         DbHelper createCommand();

         /// <summary>
         /// 设置sqlCommand的类型
         /// </summary>
         /// <param name="type">CommandType枚举类型</param>
         /// <returns></returns>
         DbHelper setCommandType(CommandType type);

         /// <summary>
         /// 要查询的表（多表以逗号隔开）、存储过程、视图名
         /// </summary>
         /// <param name="Name"></param>
         /// <returns></returns>
         DbHelper FromName(string Name);

         /// <summary>
         /// 创建事务
         /// </summary>
         /// <returns></returns>
         DbHelper beginTransaction();

         /// <summary>
         /// 事务回滚
         /// </summary>
         /// <returns></returns>
         DbHelper TransactionRowBack();

         /// <summary>
         /// 事务提交
         /// </summary>
         /// <returns></returns>
         DbHelper TransactionCommit();

         /// <summary>
         /// 对多张表间的列进行联系
         /// </summary>
         /// <param name="Fields">表间联系的字段</param>
         /// <returns></returns>
         DbHelper ForMulTable(string Fields);

         /// <summary>
         /// 查询
         /// </summary>
         /// <param name="Fields">查询字段</param>
         /// <param name="Where">查询条件字典</param>
         /// <param name="otherWhere">其他条件</param>
         /// <returns></returns>
         DbHelper Select(string Fields = "*", Dictionary<string, object> Where = null, string otherWhere = "");

         /// <summary>
         /// 更新
         /// </summary>
         /// <param name="model">需要更新的对象</param>
         /// <param name="Where">更新条件</param>
         /// <param name="Fields">更新字段</param>
         /// <param name="otherWhere">其他条件</param>
         /// <returns></returns>
         DbHelper Update(object model, Dictionary<string, object> Where, string Fields = "", string otherWhere = "");

         /// <summary>
         /// 插入
         /// </summary>
         /// <param name="model">需要插入的对象</param>
         /// <param name="Fields">需要插入的字段</param>
         /// <returns></returns>
         DbHelper Insert(object model, string Fields = "");

         /// <summary>
         /// 删除
         /// </summary>
         /// <param name="Where">删除条件</param>
         /// <param name="otherWhere">其他条件</param>
         /// <returns></returns>
         DbHelper Delete(Dictionary<string, object> Where, string otherWhere = "");

         /// <summary>
         /// 查询返回List
         /// </summary>
         /// <typeparam name="T">模型</typeparam>
         /// <returns></returns>
         List<T> ToList<T>()
             where T : class ,new();

         /// <summary>
         /// 查询返回DataSet
         /// </summary>
         /// <param name="DatasetName"></param>
         /// <returns></returns>
         DataSet ToDataSet(string DatasetName);

         /// <summary>
         /// 查询返回DataTable
         /// </summary>
         /// <returns></returns>
         DataTable ToDataTable();

         /// <summary>
         /// 执行存储过程
         /// </summary>
         /// <param name="Parameter">存储过程参数</param>
         /// <returns></returns>
         DbHelper ExcuteProc(Dictionary<string, object> Parameter);

         /// <summary>
         /// 执行返回查询第一行第一列值
         /// </summary>
         /// <returns></returns>
         object Result();

         /// <summary>
         /// 返回执行的影响行数
         /// </summary>
         /// <returns></returns>
         int ExcuteResult();

         /// <summary>
         /// 用户自定义sqlCommand
         /// </summary>
         /// <param name="fun">委托</param>
         void UserDefineOperation(Action<dynamic> fun);
     }
 }

　　好了，看完代码，大家对具体实现应该还是一头雾水，那，接下来一步步分析具体实现，是以sql Server来分析。

　　在具体实现的类中SQLHelper，设计中所必须的字段。在一开始设计时候，我在想怎么给各个数据库兼容，因为它们使用的执行对象Command是不同的，所以为了能够更好封装的库，将其设计sqlCommand不暴露给外部使用，而是在内部使用。暴露方法能够设置com的属性，以及ExcuteName就存放着执行数据的对象。

//连接字符串
        string ConnectionString;

        //数据库连接对象
        private SqlConnection conn;

        //执行对象
        SqlCommand com;

        //表、存储过程、视图名称
        string ExcuteName;

        //事务
        SqlTransaction tran;

        //sql语句
        StringBuilder sqlBuilderString;

        //参数
        SqlParameter[] paras;

　第一部分：数据库基本操作

　　createConnection方法：这个方法其实就是new sqlConnection，对其赋值connectionString，也采用了大家一般使用的单例模式，这样也会在执行的时候比较安全。不过这个单例是指一个Helper对应一个sqlConnection，而不是设计为static，因为我觉得有些项目在访问的数据库有可能有多个。而且在创建时候，对其进行打开和关闭一次，为了检查能否真的能使用。

public DbHelper createConnection(string connectionString)
        {
            if (!ConnectionCanUse())
            {
                this.ConnectionString = connectionString;
                conn = new SqlConnection(this.ConnectionString);
            }

            return this;
        }

        /// <summary>
        /// 检查conn是否能用
        /// </summary>
        /// <returns></returns>
        public bool ConnectionCanUse()
        {
            if (conn == null)
                return false;
            try
            {
                conn.Open();
                conn.Close();
            }catch(Exception e)
            {
                return false;
            }

            return true;
        }

　　打开、关闭、释放connection和创建command就不作解释了，因为里面就一句话。

　　关于基本操作，还有就是关于sqlCommandType的设置，因为存储过程和普通的语句等操作字符串明显是不同，因此要写个方法来设置它。

　　第二部分：增删改查的操作 这里就解释为什么sql语句不是在这个阶段执行。我觉得，如果将具体的执行放在这个阶段，那么就会导致方法重载过多，为什么？因为并不是所有人都能考虑到使用者要返回的类型，比如我想要List，或者DataSet等等，而且还会将这个方法的作用过重：在我设计的这些方法中，实操作的是对sql语句的生成，所以说为什么不能在这边执行，那么就不能重用。是吧，这样设计很灵活，将数据库真正执行放在下个阶段。而且这些方法都是链式的写法，所以会对执行能够很灵活的控制，最重要能够重用，不需要写别的重载方法，只需要一个方法。

　　生成sql语句在这也是简单的封装，如果要做起真的框架，我觉得sql字符串的组合还应该创建一个类，来更智能的组合用户的需求。

　　自然，里面使用到反射、Linq。不过笔者也一步步解释，将怎么设计分享给大家。

　　大家看到Select、Insert、Update、Delete的接口都有Where的条件字典。没错，反射就在这里使用。为了考虑到数据库的安全，所以sql自然只是简单的拼接，还应该使用参数。所以，反射就用在Where生成参数上。大家也许还看到别的otherWhere，这个怎么不设计成参数，因为Where能够实现的，其实就是赋值语句，也就是表内某字段 = 值，所以需要。在otherWhere中，存放的是其他特殊的条件。前面说这里设计的不完美，就因为如此，其实有些条件 like 或者 使用or ，虽然能够写在otherWhere中，但是没办法使用参数来控制。

　　那么接下来就是Fiels参数了，这个在各个方法充当不同的作用。Select是查询的字段，Update中是更新的字段，在Insert中是插入的字段，这样就灵活的控制了。在这些字段为空的时候，默认为全部，反射在这里就使用了，遍历模型对象中的属性，然后将它们一个个填进sql语句中。在这里比较注意的应该是插入，因为大家在写sql语句时候是这样的 insert tableName values(value,value....)这样的格式，这样是因为sql会自己对应值插入，而在程序中的模型类中，我想大家写属性可不是按顺序的吧，所以在反射遍历时候，就有可能将几个本来待在某个列位置的值去换了位置的情况。所以，这里在遍历的时候，应该按插入的完全格式来设计，也就是 insert tableName(Field,Field...) values(value,value...)。

　　在这几个方法中，Delete最简单。

public DbHelper Select(string Fields = "*",Dictionary<string,object> Where = null,string otherWhere = "")
        {
            sqlBuilderString = new StringBuilder();

            sqlBuilderString.AppendLine("select " + Fields + " from " + this.ExcuteName);
            List<SqlParameter> paras = new List<SqlParameter>();
            sqlBuilderString.AppendLine(" where 1 = 1 ");

            if (Where != null && Where.Count > )
            {
                paras = new List<SqlParameter>();
                //遍历Where，将里面的条件添加到sqlParamter和sql语句中
                Where.Keys.ToList().ForEach(o => {
                    sqlBuilderString.AppendLine(" and "+ o + " = @" + o);
                    paras.Add(new SqlParameter(o, Where[o]));
                });
            }

            if(!string.IsNullOrEmpty(otherWhere))
            {
                sqlBuilderString.AppendLine(otherWhere);
            }

            this.paras = paras.ToArray();
            return this;
        }

public DbHelper Update(object model,Dictionary<string, object> Where,string Fields = "", string otherWhere = "")
        {
            Type t = model.GetType();
            List<string> keys = Where.Keys.ToList();
            sqlBuilderString = new StringBuilder();
            bool firstnode = true;
            sqlBuilderString.AppendLine("update "+ExcuteName + " set ");
            List<SqlParameter> paras = new List<SqlParameter>();
            if(string.IsNullOrEmpty(Fields))
            {
                t.GetProperties().ToList().ForEach(o =>
                {
                    if (!firstnode)
                        sqlBuilderString.Append(",");
                    else
                        firstnode = false;
                    if(!keys.Contains(o.Name))
                    {
                        sqlBuilderString.AppendLine(o.Name + " = @"+o.Name);
                        paras.Add(new SqlParameter(o.Name,o.GetValue(model,null)));
                    }
                });
            }else
            {
                Fields.Split(',').ToList().ForEach(o =>
                {
                    sqlBuilderString.AppendLine(o + " = @" + o);
                    paras.Add(new SqlParameter(o, t.GetProperty(o).GetValue(model, null)));
                });
            }

            this.paras = paras.ToArray();
            return this;
        }

public DbHelper Insert(object model,string Fields = "")
        {
            List<SqlParameter> paras = new List<SqlParameter>();
            Type t = model.GetType();
            sqlBuilderString = new StringBuilder();
            sqlBuilderString.AppendLine("insert " + ExcuteName);
            if(string.IsNullOrEmpty(Fields))
            {
                string s = "";
                string s1="";
                t.GetProperties().ToList().ForEach(o =>
                {
                    s += o.Name + ",";
                    s1 += " @" + o.Name + ",";
                    paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
                });
                s.Remove(s.LastIndexOf(','),);
                s1.Remove(s.LastIndexOf(','), );
                sqlBuilderString.AppendLine("(" + s + ")");
                sqlBuilderString.AppendLine(" values(" + s1 + ")");
            }else
            {
                sqlBuilderString.AppendLine("(" + Fields + ")");
                string s = "";
                Fields.Split(',').ToList().ForEach(o =>
                {
                    s += " @" + o + ",";
                    paras.Add(new SqlParameter(o, t.GetProperty(o).GetValue(model, null)));
                });
                sqlBuilderString.AppendLine(" values(" + s + ")");
            }

            this.paras = paras.ToArray();
            return this;
        }

public DbHelper Delete(Dictionary<string,object> Where,string otherWhere = "")
        {
            sqlBuilderString = new StringBuilder();
            List<SqlParameter> paras = new List<SqlParameter>();
            sqlBuilderString.AppendLine("delete " + ExcuteName);
            sqlBuilderString.AppendLine(" where 1 = 1 ");

            Where.Keys.ToList().ForEach(o =>
            {
                sqlBuilderString.AppendLine(" and " + o + " = @" + o);
                paras.Add(new SqlParameter(o, Where[o]));
            });
            this.paras = paras.ToArray();
            return this;
        }

最后一个阶段，那就是执行阶段，这里封装了些执行的方法。

这个也是简单，最重要的方法应该是setCommand，这个方法是对sqlCommand进行设置，执行的语句，以及添加参数。

private void setCommand()
        {
            if(com.CommandType== CommandType.StoredProcedure)
            {
                this.com.CommandText = ExcuteName;
            }else
            {
                this.com.CommandText = sqlBuilderString.ToString();
            }

            this.paras.ToList().ForEach(o =>
            {
                this.com.Parameters.Add(o);
            });
        }

其他就是执行的语句。

public List<T> ToList<T>()
            where T:class ,new()
        {
            List<T> list = new List<T>();
            setCommand();
            SqlDataReader reader = com.ExecuteReader();
            Type t = typeof(T);
            List<PropertyInfo> pros = t.GetProperties().ToList();

            while(reader.Read())
            {
                T model = new T();
                pros.ForEach(o =>
                {
                    o.SetValue(model, reader[o.Name], null);
                });
                list.Add(model);
            }
            reader.Dispose();
            return list;
        }

        public DataSet ToDataSet(string DatasetName = "")
        {
            DataSet ds = new DataSet();
            setCommand();
            SqlDataAdapter adapter = new SqlDataAdapter(com);

            adapter.Fill(ds, string.IsNullOrEmpty(DatasetName) ? this.ExcuteName.Replace(",", "_") : DatasetName);
            adapter.Dispose();
            return ds;
        }

        public DataTable ToDataTable()
        {
            DataTable dt = new DataTable();
            setCommand();
            SqlDataAdapter adapter = new SqlDataAdapter(com);
            adapter.Fill(dt);
            adapter.Dispose();
            return dt;
        }

        public object Result()
        {
            setCommand();
            return com.ExecuteScalar();
        }

        public int ExcuteResult()
        {
            setCommand();
            return com.ExecuteNonQuery();
        }

        public DbHelper ExcuteProc(Dictionary<string,object> Parameter)
        {
            List<SqlParameter> paras = new List<SqlParameter>();

            Parameter.Keys.ToList().ForEach(o =>
            {
                paras.Add(new SqlParameter(o, Parameter[o]));
            });
            return this;
        }

当然，还不能少了让用户自定义的方法，所以最后还留了个方法，参数是委托。委托里面的参数还是动态类型，这就懂了吧，想用户怎么用，你就怎么定义。

public void UserDefineOperation(Action<dynamic> fun)
        {
            fun(this.com);
        }

好了，设计也就到这里，下面就贴上SQLHelper完整的代码。

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

namespace Dal
{
    public class SQLHelper:DbHelper
    {
        //连接字符串
        string ConnectionString;

        //数据库连接对象
        private SqlConnection conn;

        //执行对象
        SqlCommand com;

        //表、存储过程、视图名称
        string ExcuteName;

        //事务
        SqlTransaction tran;

        //sql语句
        StringBuilder sqlBuilderString;

        //参数
        SqlParameter[] paras;

        private SQLHelper()
        {

        }

        /// <summary>
        /// 创建sqlHelper静态方法
        /// </summary>
        /// <returns></returns>
        public static DbHelper getInstance()
        {
            return new SQLHelper();
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="connectionString"></param>
        /// <returns></returns>
        public DbHelper createConnection(string connectionString)
        {
            if (!ConnectionCanUse())
            {
                this.ConnectionString = connectionString;
                conn = new SqlConnection(this.ConnectionString);
            }

            return this;
        }

        /// <summary>
        /// 检查conn是否能用
        /// </summary>
        /// <returns></returns>
        public bool ConnectionCanUse()
        {
            if (conn == null)
                return false;
            try
            {
                conn.Open();
                conn.Close();
            }catch(Exception e)
            {
                return false;
            }

            return true;
        }

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public DbHelper openConnection()
        {
            if(conn.State != ConnectionState.Open)
            this.conn.Open();
            return this;
        }

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public DbHelper closeConnection()
        {
            if(conn.State != ConnectionState.Closed)
            this.conn.Close();
            return this;
        }

        /// <summary>
        ///
        /// </summary>
        public void DisposedConnection()
        {
            if (!ConnectionBeUsed())
                this.conn.Dispose();
        }

        /// <summary>
        /// 检查数据库是否在被打开使用
        /// </summary>
        /// <returns></returns>
        public bool ConnectionBeUsed()
        {
            if(conn.State == ConnectionState.Open)
                return true;
            return false;
        }

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public DbHelper createCommand()
        {
            if (this.com == null)
            {
                this.com = new SqlCommand();
                com.Connection = this.conn;
            }

            return this;
        }

        /// <summary>
        ///
        /// </summary>
        public void DisposedCommand()
        {
            this.com.Dispose();
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public DbHelper setCommandType(CommandType type)
        {
            this.com.CommandType = type;
            return this;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="Name"></param>
        /// <returns></returns>
        public DbHelper FromName(string Name)
        {
            this.ExcuteName = Name;
            return this;
        }

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public DbHelper beginTransaction()
        {
            this.tran = conn.BeginTransaction();
            com.Transaction = this.tran;
            return this;
        }

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public DbHelper TransactionRowBack()
        {
            if(tran!=null)
            {
                tran.Rollback();
            }
            return this;
        }

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public DbHelper TransactionCommit()
        {
            if(tran!=null)
            {
                tran.Commit();
                tran = null;
            }
            return this;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="Fields"></param>
        /// <param name="Where"></param>
        /// <param name="otherWhere"></param>
        /// <returns></returns>
        public DbHelper Select(string Fields = "*",Dictionary<string,object> Where = null,string otherWhere = "")
        {
            sqlBuilderString = new StringBuilder();

            sqlBuilderString.AppendLine("select " + Fields + " from " + this.ExcuteName);
            List<SqlParameter> paras = new List<SqlParameter>();
            sqlBuilderString.AppendLine(" where 1 = 1 ");

            if (Where != null && Where.Count > )
            {
                paras = new List<SqlParameter>();
                //遍历Where，将里面的条件添加到sqlParamter和sql语句中
                Where.Keys.ToList().ForEach(o => {
                    sqlBuilderString.AppendLine(" and "+ o + " = @" + o);
                    paras.Add(new SqlParameter(o, Where[o]));
                });
            }

            if(!string.IsNullOrEmpty(otherWhere))
            {
                sqlBuilderString.AppendLine(otherWhere);
            }

            this.paras = paras.ToArray();
            return this;
        }

        public DbHelper ForMulTable(string Fields)
        {
            List<string> tables = ExcuteName.Split(',').ToList();
            Fields.Split(',').ToList().ForEach(o =>
            {
                for(int i = ;i<tables.Count-;i++)
                {
                    sqlBuilderString.AppendLine(" and " + tables[i] + "." + o + " = " + tables[i + ] + "." + o);
                }
            });

            return this;
        }

        public DbHelper Update(object model,Dictionary<string, object> Where,string Fields = "", string otherWhere = "")
        {
            Type t = model.GetType();
            List<string> keys = Where.Keys.ToList();
            sqlBuilderString = new StringBuilder();
            bool firstnode = true;
            sqlBuilderString.AppendLine("update "+ExcuteName + " set ");
            List<SqlParameter> paras = new List<SqlParameter>();
            if(string.IsNullOrEmpty(Fields))
            {
                t.GetProperties().ToList().ForEach(o =>
                {
                    if (!firstnode)
                        sqlBuilderString.Append(",");
                    else
                        firstnode = false;
                    if(!keys.Contains(o.Name))
                    {
                        sqlBuilderString.AppendLine(o.Name + " = @"+o.Name);
                        paras.Add(new SqlParameter(o.Name,o.GetValue(model,null)));
                    }
                });
            }else
            {
                Fields.Split(',').ToList().ForEach(o =>
                {
                    sqlBuilderString.AppendLine(o + " = @" + o);
                    paras.Add(new SqlParameter(o, t.GetProperty(o).GetValue(model, null)));
                });
            }

            this.paras = paras.ToArray();
            return this;
        }

        public DbHelper Insert(object model,string Fields = "")
        {
            List<SqlParameter> paras = new List<SqlParameter>();
            Type t = model.GetType();
            sqlBuilderString = new StringBuilder();
            sqlBuilderString.AppendLine("insert " + ExcuteName);
            if(string.IsNullOrEmpty(Fields))
            {
                string s = "";
                string s1="";
                t.GetProperties().ToList().ForEach(o =>
                {
                    s += o.Name + ",";
                    s1 += " @" + o.Name + ",";
                    paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
                });
                s.Remove(s.LastIndexOf(','),);
                s1.Remove(s.LastIndexOf(','), );
                sqlBuilderString.AppendLine("(" + s + ")");
                sqlBuilderString.AppendLine(" values(" + s1 + ")");
            }else
            {
                sqlBuilderString.AppendLine("(" + Fields + ")");
                string s = "";
                Fields.Split(',').ToList().ForEach(o =>
                {
                    s += " @" + o + ",";
                    paras.Add(new SqlParameter(o, t.GetProperty(o).GetValue(model, null)));
                });
                sqlBuilderString.AppendLine(" values(" + s + ")");
            }

            this.paras = paras.ToArray();
            return this;
        }

        public DbHelper Delete(Dictionary<string,object> Where,string otherWhere = "")
        {
            sqlBuilderString = new StringBuilder();
            List<SqlParameter> paras = new List<SqlParameter>();
            sqlBuilderString.AppendLine("delete " + ExcuteName);
            sqlBuilderString.AppendLine(" where 1 = 1 ");

            Where.Keys.ToList().ForEach(o =>
            {
                sqlBuilderString.AppendLine(" and " + o + " = @" + o);
                paras.Add(new SqlParameter(o, Where[o]));
            });
            this.paras = paras.ToArray();
            return this;
        }

        private void setCommand()
        {
            if(com.CommandType== CommandType.StoredProcedure)
            {
                this.com.CommandText = ExcuteName;
            }else
            {
                this.com.CommandText = sqlBuilderString.ToString();
            }

            this.paras.ToList().ForEach(o =>
            {
                this.com.Parameters.Add(o);
            });
        }

        public List<T> ToList<T>()
            where T:class ,new()
        {
            List<T> list = new List<T>();
            setCommand();
            SqlDataReader reader = com.ExecuteReader();
            Type t = typeof(T);
            List<PropertyInfo> pros = t.GetProperties().ToList();

            while(reader.Read())
            {
                T model = new T();
                pros.ForEach(o =>
                {
                    o.SetValue(model, reader[o.Name], null);
                });
                list.Add(model);
            }
            reader.Dispose();
            return list;
        }

        public DataSet ToDataSet(string DatasetName = "")
        {
            DataSet ds = new DataSet();
            setCommand();
            SqlDataAdapter adapter = new SqlDataAdapter(com);

            adapter.Fill(ds, string.IsNullOrEmpty(DatasetName) ? this.ExcuteName.Replace(",", "_") : DatasetName);
            adapter.Dispose();
            return ds;
        }

        public DataTable ToDataTable()
        {
            DataTable dt = new DataTable();
            setCommand();
            SqlDataAdapter adapter = new SqlDataAdapter(com);
            adapter.Fill(dt);
            adapter.Dispose();
            return dt;
        }

        public object Result()
        {
            setCommand();
            return com.ExecuteScalar();
        }

        public int ExcuteResult()
        {
            setCommand();
            return com.ExecuteNonQuery();
        }

        public DbHelper ExcuteProc(Dictionary<string,object> Parameter)
        {
            List<SqlParameter> paras = new List<SqlParameter>();

            Parameter.Keys.ToList().ForEach(o =>
            {
                paras.Add(new SqlParameter(o, Parameter[o]));
            });
            return this;
        }

        public void UserDefineOperation(Action<dynamic> fun)
        {
            fun(this.com);
        }
    }
}

最后还有两个事务的方法，前面忘记说了，其实就是SqlTransaction，在里面的sqlCommand加上这个，就可以实现。或许有人会问，如果有同一时间段有好几个sqlCommand怎么办？不会的，sqlCommand我也设置成单例，就不会发生控制不了的事情了。

　　结束语：第一次的博客，我虽然做过不少“幼稚作品”，毕竟我是大三学生，如果随意的写文章，我担心只是会成为被嘲笑的对象，幼稚的“作品”也不好意思放在网上给大家看。所以，在想了几天，写了我觉得蛮有用的封装，虽然可能对许多项目不起作用，但是读者可以自己在更深的思考。

　　这个框架，我觉得应该还能更好的封装，比如从sql语句组合，调用的时候发生异常处理，怎么更好的实现链式组合，多数据库的处理控制，加上锁我觉得也是可以，毕竟做web的时候可不是像winform，每个端都有自己的connection。还有一个我觉得不错的，就是在模型上做处理，加上特性，让框架能够识别主键，外键，在程序中建立sql中的联系等。那么就给读者思考了。

　　现写现发表的文章应该不多，所以大家遇到什么bug可以在下面评论，欢迎大家指出不足。