C# .NET更智能的数据库操作的封装完整版（重构）

前述：

　　第一次发表文章，不过是对数据库简单的封装，主要是阐述下思路。那么在上篇文章，在大家的指导下和提出意见，并自己对代码进行了思考。在这两天我重构了新的框架，我觉得我写的可以称得上框架，为什么？请大家往下看。不过在项目中没有很多注释。笔者除了课余学习时候，大部分时间在完成学校的功课，没有许多时间，所以也就偷下懒，请大家体谅。

　　这次框架分为几个部分：拼接数据库语句、数据库执行、数据库连接控制、异常类、用户使用的DbHelper。等下我回用文字和图还分析这个部分。经过重构后，类增多了，而且能够极大的支持开闭原则，我应该说就是与实际数据库无关，而且在上层使用中，不需要在引用system.Data.SqlClient这样实际访问的东西。虽然笔者只写了sql server的实例，但是如果扩展其他的数据库，也无需大规模的修改旧的代码，并且使用参数，能够防止注入攻击，支持事务。

　　好，先看怎么使用框架。

DbHelper helper = new DbHelper();
            helper.createConnection("MyConnection","Data Source=CN-20161106HMJI;Initial Catalog=ShopInfo;Integrated Security=True",DbType.SQL);

            PlaceInfo model = helper.ExcuteString(o => o.From("PlaceInfo").Select().AndWhere("SAddNo", )).ToModel<PlaceInfo>();
            Console.Read();

　　上面是使用的一个例子，创建连接字符串，然后查询获取实例，已经没有打开数据库，或者是command的语句，使用起来是否十分简单，上面这句运行没有问题的，因为框架灵活度太大，测试的话不能所有都包含，这也是没办法，接下来跟着文章，一步步分析。

　　上次说，链式编程很好用，所以这次同样是链式编程，但这次更为强大。大家知道，dal的链式编程，主要是得到数据，而得到数据无非是对数据库查询语言进行封装。所以，在框架上，我封装了一个拼接语句的类，里面包含了我认为比较常用的数据库语句，支持order by。还有最强大的是，能够支持嵌套查询！也就是封装的sql语句可以是

select * from tableName where Id in(select id from tablename where ...)...这样子的。使用起来十分的方便。而且还有排序order by，等，可以在使用这套框架封装更使用的方法。

　　第二个新增的是连接控制，这个是这套框架的关键，因为框架不能占用内存，所以无论在拼接查询语句，还是在执行部分，都没有对数据库创建的语句，而是采用注入式，通过连接控制类，创建好数据库连接后，注入到所需要的部分中。而且这里控制了最耗性能的反射，对模型中的属性进行反射，都是耗时间，所以这里设置了缓存，对已经创建过对象的保存在这里，在拼接数据库语句或者是执行阶段需要用到，注入到其中，就可以省下时间。

　　第三个增加的是异常类，不过我封装的比较简单，里面就一个可重载的方法，这个是用来发生异常时候，用户能够自己设置发生错误之后应该做什么（比如保存到日志）而定的。

　　最后一个新增的是释放资源，因为对数据库连接，数据库连接数目比较少，但是command的数目在一般项目可就不是这样。可能大家为了方便，所以使用的时候尽情的new这样，那在我的框架设置了一个集合，专门存放command的，在用完后能够释放资源。因为考虑到在事务执行时候不能够对comand进行释放，所以在释放时候还做了判断。把有事务的command放到在事务执行后释放。

　　看完上边的功能，是不是觉得十分强大，因为这个框架理解和实现起来都不容易，所以笔者尽可能的让大家明白，知道我是怎么一步步完成的。

　　现在进入正题，先看下简单的结构图，看上去比较简单，不是我不会绘图，我在完成其他项目时候，都有完整的文档和图，因为现在没有太多时间，而且用软件画实在太慢了，所以大家将就的看吧。

　　上图就是我框架的结构图。箭头代表关联，从下到上，代表底层到用户使用的层次。框架是支持对数据库的扩展，上边三个部分写继承抽象类就是如此，因为这几个其实就是实际数据库会使用到，所以使用工厂模式，这样就能够扩展其他了。

　　好了，看完图，就开始讲解代码。

　　我第一步是从数据库拼接语句开始做的，因为这个虽然还不算底层，但是相对于其他可以独立，那么看下这一跪部分的类：

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

namespace Dal
{
    public interface IDbCode
    {

        /// <summary>
        /// 数据库执行表、视图、存储过程等对象
        /// </summary>
        /// <param name="Object">名称</param>
        /// <returns></returns>
        IDbCode From(object Object);

        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="Fields">查询的字段</param>
        /// <returns></returns>
        IDbCode Select(string Fields = "*");

        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        IDbCode Delete();

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="model">更新对象</param>
        /// <param name="Fields">更新字段</param>
        /// <returns></returns>
        IDbCode Update(object model,string Fields = "");

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

        /// <summary>
        /// 与条件
        /// </summary>
        /// <param name="Where">条件字符串</param>
        /// <returns></returns>
        IDbCode AndWhere(string Where);
        /// <summary>
        /// 与条件
        /// </summary>
        /// <param name="Field">字段</param>
        /// <param name="Value">值</param>
        /// <returns></returns>
        IDbCode AndWhere(string Field,object Value);

        /// <summary>
        /// 与条件
        /// </summary>
        /// <param name="Field">条件字段</param>
        /// <param name="Select">嵌套查询条件委托</param>
        /// <returns></returns>
        IDbCode AndWhere(string Field, Func<IDbCode, string> Select);

        /// <summary>
        /// 与条件
        /// </summary>
        /// <typeparam name="T">值的类型</typeparam>
        /// <param name="Field">条件字段</param>
        /// <param name="Values">值</param>
        /// <returns></returns>
        IDbCode AndWhere<T>(string Field,List<T> Values);

        /// <summary>
        /// 或条件
        /// </summary>
        /// <param name="Where">条件字符串</param>
        /// <returns></returns>
        IDbCode OrWhere(string Where);

        /// <summary>
        /// 或条件
        /// </summary>
        /// <param name="Field">条件字段</param>
        /// <param name="Value">值</param>
        /// <returns></returns>
        IDbCode OrWhere(string Field, object Value);

        /// <summary>
        /// 或条件
        /// </summary>
        /// <param name="Field">条件字段</param>
        /// <param name="Select">嵌套条件</param>
        /// <returns></returns>
        IDbCode OrWhere(string Field, Func<IDbCode, string> Select);

        /// <summary>
        /// 或条件
        /// </summary>
        /// <typeparam name="T">值类型</typeparam>
        /// <param name="Field">条件字段</param>
        /// <param name="Values">值</param>
        /// <returns></returns>
        IDbCode OrWhere<T>(string Field, List<T> Values);

        /// <summary>
        /// Top 语句
        /// </summary>
        /// <param name="topCount"></param>
        /// <returns></returns>
        IDbCode Top(int topCount);

        /// <summary>
        /// 排序从小到大
        /// </summary>
        /// <param name="Field">排序字段</param>
        /// <returns></returns>
        IDbCode OrderByAsc(string Field);

        /// <summary>
        /// 排序从大到小
        /// </summary>
        /// <param name="Field">排序字段</param>
        /// <returns></returns>
        IDbCode OrderByDesc(string Field);

        /// <summary>
        /// 多表查询时候必须加的条件
        /// </summary>
        /// <param name="Fields">在两张表中的相同字段</param>
        /// <returns></returns>
        IDbCode ForMulTable(string Fields);

        string ToString();

        /// <summary>
        /// 清空缓存
        /// </summary>
        /// <returns></returns>
        IDbCode Clear();

        IDbCode CreateCode(string sql);

        object Paras
        {
            get;
        }
        void Dispose();
    }
}

继承它的类：

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 SQLCode :IDbCode
    {
        string Object;
        StringBuilder ExcuteString = new StringBuilder();
        List<SqlParameter> paras;
        Dictionary<string, List<PropertyInfo>> pro;
        static string[] s = { "select", "delect", "update", "insert" };

        public SQLCode()
        {
            paras = new List<SqlParameter>();
        }
        public SQLCode(Dictionary<string, List<PropertyInfo>> pro)
        {
            paras = new List<SqlParameter>();
            this.pro = pro;
        }
        public SQLCode(List<SqlParameter> paras, Dictionary<string, List<PropertyInfo>> pro)
        {
            this.paras = paras;
            this.pro = pro;
        }
        public IDbCode From(object Object)
        {
            Type t = Object.GetType();
            if(t.Name.ToLower().Equals("string"))
            {
                this.Object = Object.ToString();
            }else
            {
                this.Object = t.Name;
            }

            return this;
        }

        public IDbCode Select(string Fields = "*")
        {
            if (this.Object.Length <= )
                return this;
            if (!Check())
                return this;
            ExcuteString.AppendLine("select " + Fields +" from "+ this.Object);
            ExcuteString.AppendLine(" where 1 = 1 ");
            return this;
        }

        bool Check(int Type)
        {
            int flag = ;
            string b = ExcuteString.ToString();
            for (int i = ; i < s.Length; i++)
                if(i!=Type)
                    flag += b.Contains(s[i]) ?  : ;
            return flag == ;
        }

        public IDbCode Delete()
        {
            if (Object.Length <= )
                return this;
            if (!Check())
                return this;
            ExcuteString.AppendLine("delete " + this.Object);
            ExcuteString.AppendLine(" where 1 = 1 ");
            return this;
        }

        public IDbCode Update(object model, string Fields = "")
        {
            if (this.Object.Length <= )
                return this;
            if (!Check())
                return this;

            Type t = model.GetType();
            if (t.Name != Object)
                return this;

            ExcuteString.AppendLine("update "+this.Object +" set ");

            List<PropertyInfo> p;
            if(pro.ContainsKey(t.Name))
            {
                p = pro[t.Name];
            }else
            {
                p = t.GetProperties().ToList();
                pro.Add(t.Name, p);
            }
            string f = "";
            if(Fields.Length==)
            {
                p.ForEach(o =>
                {
                    f += o.Name + " = @" + o.Name;
                    paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
                });
            }else
            {
                string[] a = Fields.Split(',');

                p.ForEach(o =>
                {
                    if (a.Contains(o.Name))
                    {
                        f += o.Name + " = @" + o.Name + ",";
                        paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
                    }
                });
            }
            ExcuteString.AppendLine(f);
            ExcuteString.AppendLine("where 1 = 1");

            return this;
        }

        public IDbCode Insert(object model, string Fields = "")
        {
            if (this.Object.Length <= )
                return this;
            if (!Check())
                return this;

            Type t = model.GetType();
            if (t.Name != Object)
                return this;

            ExcuteString.AppendLine("insert " + this.Object);

            List<PropertyInfo> p;
            if (pro.ContainsKey(t.Name))
            {
                p = pro[t.Name];
            }
            else
            {
                p = t.GetProperties().ToList();
                pro.Add(t.Name, p);
            }

            string f = "( ";
            string f1 = "values( ";

            if (Fields.Length == )
            {
                p.ForEach(o =>
                {
                    f += o.Name+",";
                    paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
                    f1 += "@" + o.Name + ",";
                });
            }
            else
            {
                string[] a = Fields.Split(',');

                p.ForEach(o =>
                {
                    if (a.Contains(o.Name))
                    {
                        f += o.Name + ",";
                        paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
                        f1 += "@" + o.Name + ",";
                    }
                });
            }
            f = f.Remove(f.LastIndexOf(','), ) + " ) ";
            f1 = f1.Remove(f1.LastIndexOf(','), ) + " ) ";
            ExcuteString.AppendLine(f);
            ExcuteString.AppendLine(f1);
            return this;
        }

        public IDbCode AndWhere(string Where)
        {
            ExcuteString.AppendLine(" and " + Where);
            return this;
        }

        public IDbCode AndWhere(string Field, object Value)
        {
            ExcuteString.AppendLine(" and " + Field + " = @" + Field);
            paras.Add(new SqlParameter(Field, Value));
            return this;
        }

        public IDbCode AndWhere(string Field, Func<IDbCode, string> Select)
        {
            ExcuteString.AppendLine(" and " + Field + " in " + Select(new SQLCode(this.paras,this.pro)));
            return this;
        }

        public IDbCode AndWhere<T>(string Field, List<T> Values)
        {
            string value = "(";

            Values.ForEach(o =>
            {
                value += o + ",";
            });
            ExcuteString.AppendLine(" and " + Field + " in " + value.Remove(value.LastIndexOf(','), ) + ")");
            return this;
        }

        public IDbCode OrWhere(string Where)
        {
            ExcuteString.AppendLine(" or " + Where);
            return this;
        }

        public IDbCode OrWhere(string Field, object Value)
        {
            ExcuteString.AppendLine(" or " + Field + " = @" + Field);
            paras.Add(new SqlParameter(Field, Value));
            return this;
        }

        public IDbCode OrWhere(string Field, Func<IDbCode, string> Select)
        {
            ExcuteString.AppendLine(" or " + Field + " in " + Select(new SQLCode(this.paras,this.pro)));
            return this;
        }

        public IDbCode OrWhere<T>(string Field, List<T> Values)
        {
            string value = "(";

            Values.ForEach(o =>
            {
                value += o + ",";
            });
            ExcuteString.AppendLine(" or " + Field + " in " + value.Remove(value.LastIndexOf(','), ) + ")");
            return this;
        }

        public IDbCode Top(int topCount)
        {
            if (!ExcuteString.ToString().Contains(s[]))
                return this;
            ExcuteString.Replace("select", "select top " + topCount +" ");
            return this;
        }

        bool CheckHasOrderBy()
        {
            return this.ExcuteString.ToString().Contains("order by");
        }
        public IDbCode OrderByAsc(string Field)
        {
            if (CheckHasOrderBy())
                ExcuteString.AppendLine("," + Field + " asc");
            else
                ExcuteString.AppendLine(" order by " + Field+" asc");

            return this;
        }

        public IDbCode OrderByDesc(string Field)
        {
            if (CheckHasOrderBy())
                ExcuteString.AppendLine("," + Field + " desc");
            else
                ExcuteString.AppendLine(" order by " + Field + " desc");

            return this;
        }

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

        public override string ToString()
        {
            return this.ExcuteString.ToString();
        }

        public IDbCode Clear()
        {
            pro.Clear();
            return this;
        }

        public IDbCode CreateCode(string sql)
        {
            ExcuteString.AppendLine(sql);
            return this;
        }

        public object Paras
        {
            get
            {
                return this.paras;
            }
        }

        public void Dispose()
        {
            this.pro = null;
        }
    }
}

　　如果有看过上次的文章，那么就知道这里部分方法用到反射，获取其中的属性来拼写语句。没什么难的，大家看到里面有许多的if条件，是我避免在链式组合时候，用户随便乱时候而设置的。这部分都是对字符串处理。

　　第二部分是执行语句，这个相信大家写多了，先给代码：

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

namespace Dal
{
    public interface IDbExcute
    {
        T ToModel<T>(IDbCode code, CommandType type = CommandType.Text)
            where T : class,new();

        List<T> ToList<T>(IDbCode code,CommandType type = CommandType.Text)
            where T : class,new();

        object ToResult(IDbCode code, CommandType type = CommandType.Text);

        int ExcuteResult(IDbCode code, CommandType type = CommandType.Text);

        DataTable ToDataTable(IDbCode code, CommandType type = CommandType.Text);

        DataSet ToDataSet(IDbCode code, CommandType type = CommandType.Text);

        void OpenConnection();
        void CloseConnection();

        void Dispose(object tran);

        void BeginTransation(string Name);
        void Commit();
        void RollBack();
    }
}

上面就是支持整个框架的执行方法

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 SQLExcute : IDbExcute
    {
        SqlConnection conn;
        Dictionary<string, List<PropertyInfo>> pro;
        Dictionary<string, SqlCommand> command;
        SqlTransaction tran = null;

        public SQLExcute(SqlConnection conn, Dictionary<string, List<PropertyInfo>> pro)
        {
            this.conn = conn;
            this.pro = pro;
            command = new Dictionary<string, SqlCommand>();
        }

        public List<T> ToList<T>(IDbCode code,CommandType type = CommandType.Text)
            where T:class,new()
        {
            List<T> list = new List<T>();
            string name = DateTime.Now.ToString();
            command.Add(name, new SqlCommand());
            SqlCommand com = command[name];
            com.Connection = conn;
            com.CommandText = code.ToString();
            com.CommandType = type;
            setCommand(com, (List<SqlParameter>)code.Paras);

            Type t = typeof(T);
            List<PropertyInfo> pros;
            if(pro.ContainsKey(t.Name))
            {
                pros = pro[t.Name];
            }else
            {
                pros = t.GetProperties().ToList();
                pro.Add(t.Name, pros);
            }

            try
            {
                this.OpenConnection();
                using (SqlDataReader reader = com.ExecuteReader())
                {
                    while(reader.Read())
                    {
                        T model = new T();
                        pros.ForEach(o =>
                        {
                            if(ReaderExists(reader,o.Name))
                            {
                                o.SetValue(model, reader[o.Name], null);
                            }
                        });
                        list.Add(model);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                this.Dispose(name);
                this.CloseConnection();
            }

            return list;
        }

        public bool ReaderExists(SqlDataReader reader, string columnName)
        {
            //reader.GetSchemaTable().DefaultView.RowFilter = "ColumnName= '" + columnName + "'";
            //return (reader.GetSchemaTable().DefaultView.Count > 0);
            return reader.GetSchemaTable().Select("ColumnName='" + columnName + "'").Length > ;
        }
        public void Dispose(string name)
        {
            if(command.ContainsKey(name))
            {
                SqlCommand com = command[name];
                command.Remove(name);
                com.Dispose();
            }
            if (command.Count <= )
                this.CloseConnection();
        }

        public void Dispose(object tran)
        {
            List<string> list = command.Keys.ToList();
            list.ForEach(o =>
            {
                if(command[o].Transaction!=null&&command[o].Transaction==(SqlTransaction)tran)
                {
                    this.Dispose(o);
                }
            });
        }

        public object ToResult(IDbCode code, CommandType type = CommandType.Text)
        {
            string name = DateTime.Now.ToString();
            command.Add(name, new SqlCommand());
            SqlCommand com = command[name];
            com.Connection = conn;
            com.CommandText = code.ToString();
            com.CommandType = type;
            setCommand(com, (List<SqlParameter>)code.Paras);

            object result =null;
            try
            {
                this.OpenConnection();
                result = com.ExecuteScalar();
            }
            catch (Exception ex)
            {
                DoException();
                throw ex;
            }finally
            {
                this.Dispose(name);
                this.CloseConnection();
            }

            return result;
        }

        private void DoException()
        {
            new DbException().Done();
        }

        public int ExcuteResult(IDbCode code, CommandType type = CommandType.Text)
        {
            string name = DateTime.Now.ToString();
            command.Add(name, new SqlCommand());
            SqlCommand com = command[name];
            com.Connection = conn;
            com.CommandText = code.ToString();
            com.CommandType = type;
            setCommand(com, (List<SqlParameter>)code.Paras);

            int result = ;
            try
            {
                this.OpenConnection();
                if (tran != null)
                    com.Transaction = (SqlTransaction)tran;
                result = com.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                DoException();
                throw ex;
            }
            finally
            {
                if (tran == null)
                    Dispose(name);
                this.CloseConnection();
            }
            return result;
        }

        public System.Data.DataTable ToDataTable(IDbCode code, CommandType type = CommandType.Text)
        {
            string name = DateTime.Now.ToString();
            command.Add(name, new SqlCommand());
            SqlCommand com = command[name];
            com.Connection = conn;
            com.CommandText = code.ToString();
            com.CommandType = type;
            setCommand(com, (List<SqlParameter>)code.Paras);

            DataTable dt = new DataTable();
            try
            {
                using(SqlDataAdapter adapter = new SqlDataAdapter(com))
                {
                    adapter.Fill(dt);
                }
            }
            catch (Exception ex)
            {
                DoException();
                throw ex;
            }finally
            {
                Dispose(name);
            }

            return dt;
        }

        public void setCommand(SqlCommand com,List<SqlParameter> paras)
        {
            paras.ForEach(o =>
            {
                com.Parameters.Add(o);
            });
        }

        public System.Data.DataSet ToDataSet(IDbCode code, CommandType type = CommandType.Text)
        {
            string name = DateTime.Now.ToString();
            command.Add(name, new SqlCommand());
            SqlCommand com = command[name];
            com.Connection = conn;
            com.CommandText = code.ToString();
            com.CommandType = type;
            setCommand(com, (List<SqlParameter>)code.Paras);

            DataSet dt = new DataSet();
            try
            {
                using (SqlDataAdapter adapter = new SqlDataAdapter(com))
                {
                    adapter.Fill(dt);
                }
            }
            catch (Exception ex)
            {
                DoException();
                throw ex;
            }
            finally
            {
                Dispose(name);
            }

            return dt;
        }

        public T ToModel<T>(IDbCode code, CommandType type = CommandType.Text)
            where T : class,new()
        {
            string name = DateTime.Now.ToString();
            command.Add(name, new SqlCommand());
            SqlCommand com = command[name];
            com.Connection = conn;
            com.CommandText = code.ToString();
            com.CommandType = type;
            setCommand(com, (List<SqlParameter>)code.Paras);

            Type t = typeof(T);
            List<PropertyInfo> p = null;
            if(pro.ContainsKey(t.Name))
            {
                p = pro[t.Name];
            }else
            {
                p = t.GetProperties().ToList();
                pro.Add(t.Name, p);
            }
            T model = new T();

            try
            {
                this.OpenConnection();
                using(SqlDataReader reader = com.ExecuteReader())
                {
                    if(reader.Read())
                    {
                        p.ForEach(o =>
                        {
                            if(ReaderExists(reader,o.Name))
                            {
                                o.SetValue(model, reader[o.Name], null);
                            }
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                DoException();
                throw ex;
            }
            finally
            {
                Dispose(name);
                this.CloseConnection();
            }

            return model;
        }

        public void OpenConnection()
        {
            if (this.conn.State != ConnectionState.Open)
                this.conn.Open();
        }

        public void CloseConnection()
        {
            command.Values.ToList().ForEach(o =>
            {
                if (o.Transaction != null)
                    return;
            });

            if (this.conn.State != ConnectionState.Closed)
                this.conn.Close();
        }

        public void BeginTransation(string Name)
        {
            tran = conn.BeginTransaction(Name);
        }

        public void Commit()
        {
            tran.Commit();
            Dispose(tran);
            tran = null;
        }

        public void RollBack()
        {
            tran.Rollback();
            Dispose(tran);
            tran = null;
        }
    }
}

　　具体类中，主要设计了最重要的执行方法外，还像刚开始所述，设置了List，就是用来存放command对象，在执行完成时候时候它会自己释放。跟这个类配合使用的是异常类：

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

namespace Dal
{
    public class DbException
    {
        public virtual void Done()
        {

        }
    }
}

只有短短几句话，这就是用于使用者想发生异常想它干什么而设置的。

其实封装到这里，整个框架的支持已经形成，但是用户不能直接操作底层，而且还需要怎么对数据库进行实例，所以还要对上进行封装，下一步，往上走，数据库实例部分。

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

namespace Dal
{
    public interface IDbInstance
    {
        /// <summary>
        /// 数据库名称
        /// </summary>
        string Name
        {
            get;
        }

        /// <summary>
        /// 获取执行语句类
        /// </summary>
        IDbExcute Excute
        {
            get;
        }

        /// <summary>
        /// 获取连接字符串
        /// </summary>
        string ConnectionString
        {
            get;
        }
        /// <summary>
        /// 开启事务
        /// </summary>
        /// <param name="TranName">事务名称</param>
        /// <returns></returns>
        object getTransation(string TranName);

        /// <summary>
        /// 获取拼写字符串类
        /// </summary>
        IDbCode Code
        {
            get;
        }
    }
}

实现它的具体类包含所有的底层的操作，其实就是可以说是一个数据库实例了，创建一个就相当于一个数据库。里面将上边封装的类都在这里使用。

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 SQLInstance :IDbInstance
    {
        private SqlConnection conn;
        private IDbExcute excute;
        Dictionary<string, List<PropertyInfo>> pro;
        private string name;
        private string connectionString;
        private SqlTransaction tran = null;
        public SQLInstance(string Name,Dictionary<string,List<PropertyInfo>> pro, string ConnectionString)
        {
            this.name = Name;
            this.connectionString = ConnectionString;
            conn = new SqlConnection(ConnectionString);
            this.pro = pro;
            excute = new SQLExcute(conn,pro);
        }

        public string Name
        {
            get
            {
                return this.name;
            }
        }
        public IDbExcute Excute
        {
            get
            {
                return this.excute;
            }
        }

        public string ConnectionString
        {
            get
            {
                return this.connectionString;
            }
        }

        public object getTransation(string TranName)
        {
            return this.conn.BeginTransaction(TranName);
        }

        public IDbCode Code
        {
            get
            {
                return new SQLCode(pro);
            }
        }
    }
}

接下来是控制连接的类：

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

namespace Dal
{
    public class DbControl
    {
        //数据库服务
        private static Dictionary<string, IDbInstance> Server = new Dictionary<string, IDbInstance>();
        //存放缓存
        private static Dictionary<string, List<PropertyInfo>> pro = new Dictionary<string, List<PropertyInfo>>();
        private static DbControl control = new DbControl();
        public static DbControl getInstance()
        {
            return control;
        }
        private DbControl()
        {

        }
        public IDbInstance createInstance(string Name,string ConnectionString,string type)
        {
            string nspace = typeof(IDbInstance).Namespace;
            Type t = Type.GetType(nspace + "." + type);
            object obj = Activator.CreateInstance(t, new object[] { Name, pro, ConnectionString });

            IDbInstance instance = obj as IDbInstance;

            Server.Add(Name, instance);

            return instance;
        }

        public IDbInstance this[string Name]
        {
            get
            {
                if (Server.ContainsKey(Name))
                    return Server[Name];
                else
                    return null;
            }
        }
    }
}

这里算是顶层的类，最主要就是存放数据库和缓存对象。也许会好奇如果存放数据库，还可以理解，但是放着模型对象的缓存，这是为什么？因为在字符连接，还有具体执行数据库语句时候都会使用到。而且，不仅这个数据库，别的数据库也会使用到，虽然在一个大项目可能用多个数据库，但是他们使用到项目里的模型是一致的吧，因此，将缓存设置在这里，最好不过。而且整个框架只有这一份，其他地方注入使用，就不会耗内存了。

最后就是用户使用的部分，这部分已经屏蔽掉许多底层的部分，只留下通用方法。这些都已经封装好了，直接在这里调用就可以。

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

namespace Dal
{
    public class DbHelper
    {
        private IDbInstance instance;
        private string Name;
        private DbControl control;
        private IDbCode Code;

        public DbHelper()
        {
            control = DbControl.getInstance();
        }

        public DbHelper createConnection(string Name, string ConnectionString, string type)
        {
            this.Name = Name;
            instance = control.createInstance(Name, ConnectionString, type);
            return this;
        }

        public DbHelper ExcuteString(Func<IDbCode,IDbCode> Fun)
        {
            Code = Fun(this.instance.Code);
            return this;
        }

        public DbHelper createTransation(string Name)
        {
            this.instance.Excute.BeginTransation(Name);
            return this;
        }

        public DbHelper Rollback()
        {
            this.instance.Excute.RollBack();
            return this;
        }
        public DbHelper Commit()
        {
            this.instance.Excute.Commit();
            return this;
        }

        public T ToModel<T>(CommandType Type = CommandType.Text)
            where T:class,new()
        {
            if (this.Code == null)
                return null;
            return this.instance.Excute.ToModel<T>(this.Code,Type);
        }
        List<T> ToList<T>(CommandType Type = CommandType.Text)
            where T:class,new()
        {
            if (this.Code == null)
                return null;
            return this.instance.Excute.ToList<T>(this.Code, Type);
        }
        object ToResult(CommandType Type = CommandType.Text)
        {
            if (this.Code == null)
                return null;
            return this.instance.Excute.ToResult(this.Code, Type);
        }
        int ExcuteResult(CommandType Type = CommandType.Text)
        {
            if (this.Code == null)
                return -;
            return this.instance.Excute.ExcuteResult(this.Code, Type);
        }
        DataTable ToDataTable(CommandType Type = CommandType.Text)
        {
            if (this.Code == null)
                return null;
            return this.instance.Excute.ToDataTable(this.Code, Type);
        }
        DataSet ToDataSet(CommandType Type = CommandType.Text)
        {
            if (this.Code == null)
                return null;
            return this.instance.Excute.ToDataSet(this.Code, Type);
        }
    }
}

　　结束：快要熄灯了，没办法在写文章。如果大家对框架有什么不明白，可以在下面评论区问我。这就是更新之后的框架，我觉得还是蛮好用的，虽然还没经过严密的检测。有什么问题，大家也可以指导下，我也在学习中~