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", 1)).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 <= 0)                return this;            if (!Check(0))                return this;            ExcuteString.AppendLine("select " + Fields +" from "+ this.Object);            ExcuteString.AppendLine(" where 1 = 1 ");            return this;        }        bool Check(int Type)        {            int flag = 0;            string b = ExcuteString.ToString();            for (int i = 0; i < s.Length; i++)                if(i!=Type)                    flag += b.Contains(s[i]) ? 1 : 0;            return flag == 0;        }        public IDbCode Delete()        {            if (Object.Length <= 0)                return this;            if (!Check(1))                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 <= 0)                return this;            if (!Check(2))                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==0)            {                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 <= 0)                return this;            if (!Check(3))                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 == 0)            {                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(','), 1) + " ) ";            f1 = f1.Remove(f1.LastIndexOf(','), 1) + " ) ";            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(','), 1) + ")");            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(','), 1) + ")");            return this;        }        public IDbCode Top(int topCount)        {            if (!ExcuteString.ToString().Contains(s[0]))                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 = 0; i < tables.Count - 1; i++)                {                    ExcuteString.AppendLine(" and " + tables[i] + "." + o + " = " + tables[i + 1] + "." + 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 > 0;        }        public void Dispose(string name)        {            if(command.ContainsKey(name))            {                SqlCommand com = command[name];                command.Remove(name);                com.Dispose();            }            if (command.Count <= 0)                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 = 0;            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 -1;            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);        }    }}

 

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