当前位置：Gxlcms > 数据库问题 > C# .NET数据库操作

C# .NET数据库操作

时间：2021-07-01 10:21:17 帮助过：18人阅读 

  1. DbHelper helper = new DbHelper();
  2.             helper.createConnection("MyConnection","Data Source=CN-20161106HMJI;Initial Catalog=ShopInfo;Integrated Security=True",DbType.SQL);
  3.             
  4.             PlaceInfo model = helper.ExcuteString(o => o.From("PlaceInfo").Select().AndWhere("SAddNo", 1)).ToModel<PlaceInfo>();
  5.             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放到在事务执行后释放。

 

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

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

技术分享

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

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

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

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace Dal
  6. {
  7.     public interface IDbCode
  8.     {
  9.         /// <summary>
  10.         /// 数据库执行表、视图、存储过程等对象
  11.         /// </summary>
  12.         /// <param name="Object">名称</param>
  13.         /// <returns></returns>
  14.         IDbCode From(object Object);
  15.         /// <summary>
  16.         /// 查询
  17.         /// </summary>
  18.         /// <param name="Fields">查询的字段</param>
  19.         /// <returns></returns>
  20.         IDbCode Select(string Fields = "*");
  21.         /// <summary>
  22.         /// 删除
  23.         /// </summary>
  24.         /// <returns></returns>
  25.         IDbCode Delete();
  26.         /// <summary>
  27.         /// 更新
  28.         /// </summary>
  29.         /// <param name="model">更新对象</param>
  30.         /// <param name="Fields">更新字段</param>
  31.         /// <returns></returns>
  32.         IDbCode Update(object model,string Fields = "");
  33.         /// <summary>
  34.         /// 插入
  35.         /// </summary>
  36.         /// <param name="model">插入对象</param>
  37.         /// <param name="Fields">插入字段</param>
  38.         /// <returns></returns>
  39.         IDbCode Insert(object model,string Fields = "");
  40.         /// <summary>
  41.         /// 与条件
  42.         /// </summary>
  43.         /// <param name="Where">条件字符串</param>
  44.         /// <returns></returns>
  45.         IDbCode AndWhere(string Where);
  46.         /// <summary>
  47.         /// 与条件
  48.         /// </summary>
  49.         /// <param name="Field">字段</param>
  50.         /// <param name="Value">值</param>
  51.         /// <returns></returns>
  52.         IDbCode AndWhere(string Field,object Value);
  53.         /// <summary>
  54.         /// 与条件
  55.         /// </summary>
  56.         /// <param name="Field">条件字段</param>
  57.         /// <param name="Select">嵌套查询条件委托</param>
  58.         /// <returns></returns>
  59.         IDbCode AndWhere(string Field, Func<IDbCode, string> Select);
  60.         /// <summary>
  61.         /// 与条件
  62.         /// </summary>
  63.         /// <typeparam name="T">值的类型</typeparam>
  64.         /// <param name="Field">条件字段</param>
  65.         /// <param name="Values">值</param>
  66.         /// <returns></returns>
  67.         IDbCode AndWhere<T>(string Field,List<T> Values);
  68.         /// <summary>
  69.         /// 或条件
  70.         /// </summary>
  71.         /// <param name="Where">条件字符串</param>
  72.         /// <returns></returns>
  73.         IDbCode OrWhere(string Where);
  74.         /// <summary>
  75.         /// 或条件
  76.         /// </summary>
  77.         /// <param name="Field">条件字段</param>
  78.         /// <param name="Value">值</param>
  79.         /// <returns></returns>
  80.         IDbCode OrWhere(string Field, object Value);
  81.         /// <summary>
  82.         /// 或条件
  83.         /// </summary>
  84.         /// <param name="Field">条件字段</param>
  85.         /// <param name="Select">嵌套条件</param>
  86.         /// <returns></returns>
  87.         IDbCode OrWhere(string Field, Func<IDbCode, string> Select);
  88.         /// <summary>
  89.         /// 或条件
  90.         /// </summary>
  91.         /// <typeparam name="T">值类型</typeparam>
  92.         /// <param name="Field">条件字段</param>
  93.         /// <param name="Values">值</param>
  94.         /// <returns></returns>
  95.         IDbCode OrWhere<T>(string Field, List<T> Values);
  96.         /// <summary>
  97.         /// Top 语句
  98.         /// </summary>
  99.         /// <param name="topCount"></param>
  100.         /// <returns></returns>
  101.         IDbCode Top(int topCount);
  102.         /// <summary>
  103.         /// 排序从小到大
  104.         /// </summary>
  105.         /// <param name="Field">排序字段</param>
  106.         /// <returns></returns>
  107.         IDbCode OrderByAsc(string Field);
  108.         /// <summary>
  109.         /// 排序从大到小
  110.         /// </summary>
  111.         /// <param name="Field">排序字段</param>
  112.         /// <returns></returns>
  113.         IDbCode OrderByDesc(string Field);
  114.         /// <summary>
  115.         /// 多表查询时候必须加的条件
  116.         /// </summary>
  117.         /// <param name="Fields">在两张表中的相同字段</param>
  118.         /// <returns></returns>
  119.         IDbCode ForMulTable(string Fields);
  120.         string ToString();
  121.         /// <summary>
  122.         /// 清空缓存
  123.         /// </summary>
  124.         /// <returns></returns>
  125.         IDbCode Clear();
  126.         IDbCode CreateCode(string sql);
  127.         object Paras
  128.         {
  129.             get;
  130.         }
  131.         void Dispose();
  132.     }
  133. }
技术分享

继承它的类：

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Data;
  6. using System.Data.SqlClient;
  7. using System.Reflection;
  8. namespace Dal
  9. {
  10.     public class SQLCode :IDbCode
  11.     {
  12.         string Object;
  13.         StringBuilder ExcuteString = new StringBuilder();
  14.         List<SqlParameter> paras;
  15.         Dictionary<string, List<PropertyInfo>> pro;
  16.         static string[] s = { "select", "delect", "update", "insert" };
  17.         
  18.         public SQLCode()
  19.         {
  20.             paras = new List<SqlParameter>();
  21.         }
  22.         public SQLCode(Dictionary<string, List<PropertyInfo>> pro)
  23.         {
  24.             paras = new List<SqlParameter>();
  25.             this.pro = pro;
  26.         }
  27.         public SQLCode(List<SqlParameter> paras, Dictionary<string, List<PropertyInfo>> pro)
  28.         {
  29.             this.paras = paras;
  30.             this.pro = pro;
  31.         }
  32.         public IDbCode From(object Object)
  33.         {
  34.             Type t = Object.GetType();
  35.             if(t.Name.ToLower().Equals("string"))
  36.             {
  37.                 this.Object = Object.ToString();
  38.             }else
  39.             {
  40.                 this.Object = t.Name;
  41.             }
  42.             return this;
  43.         }
  44.         public IDbCode Select(string Fields = "*")
  45.         {
  46.             if (this.Object.Length <= 0)
  47.                 return this;
  48.             if (!Check(0))
  49.                 return this;
  50.             ExcuteString.AppendLine("select " + Fields +" from "+ this.Object);
  51.             ExcuteString.AppendLine(" where 1 = 1 ");
  52.             return this;
  53.         }
  54.         bool Check(int Type)
  55.         {
  56.             int flag = 0;
  57.             string b = ExcuteString.ToString();
  58.             for (int i = 0; i < s.Length; i++)
  59.                 if(i!=Type)
  60.                     flag += b.Contains(s[i]) ? 1 : 0;
  61.             return flag == 0;
  62.         }
  63.         public IDbCode Delete()
  64.         {
  65.             if (Object.Length <= 0)
  66.                 return this;
  67.             if (!Check(1))
  68.                 return this;
  69.             ExcuteString.AppendLine("delete " + this.Object);
  70.             ExcuteString.AppendLine(" where 1 = 1 ");
  71.             return this;
  72.         }
  73.         public IDbCode Update(object model, string Fields = "")
  74.         {
  75.             if (this.Object.Length <= 0)
  76.                 return this;
  77.             if (!Check(2))
  78.                 return this;
  79.             Type t = model.GetType();
  80.             if (t.Name != Object)
  81.                 return this;
  82.             
  83.             ExcuteString.AppendLine("update "+this.Object +" set ");
  84.             List<PropertyInfo> p;
  85.             if(pro.ContainsKey(t.Name))
  86.             {
  87.                 p = pro[t.Name];
  88.             }else
  89.             {
  90.                 p = t.GetProperties().ToList();
  91.                 pro.Add(t.Name, p);
  92.             }
  93.             string f = "";
  94.             if(Fields.Length==0)
  95.             {
  96.                 p.ForEach(o =>
  97.                 {
  98.                     f += o.Name + " = @" + o.Name;
  99.                     paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
  100.                 });
  101.             }else
  102.             {
  103.                 string[] a = Fields.Split(‘,‘);
  104.                 
  105.                 p.ForEach(o =>
  106.                 {
  107.                     if (a.Contains(o.Name))
  108.                     {
  109.                         f += o.Name + " = @" + o.Name + ",";
  110.                         paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
  111.                     }
  112.                 });
  113.             }
  114.             ExcuteString.AppendLine(f);
  115.             ExcuteString.AppendLine("where 1 = 1");
  116.             return this;
  117.         }
  118.         public IDbCode Insert(object model, string Fields = "")
  119.         {
  120.             if (this.Object.Length <= 0)
  121.                 return this;
  122.             if (!Check(3))
  123.                 return this;
  124.             Type t = model.GetType();
  125.             if (t.Name != Object)
  126.                 return this;
  127.             ExcuteString.AppendLine("insert " + this.Object);
  128.             List<PropertyInfo> p;
  129.             if (pro.ContainsKey(t.Name))
  130.             {
  131.                 p = pro[t.Name];
  132.             }
  133.             else
  134.             {
  135.                 p = t.GetProperties().ToList();
  136.                 pro.Add(t.Name, p);
  137.             }
  138.             string f = "( ";
  139.             string f1 = "values( ";
  140.             if (Fields.Length == 0)
  141.             {
  142.                 p.ForEach(o =>
  143.                 {
  144.                     f += o.Name+",";
  145.                     paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
  146.                     f1 += "@" + o.Name + ",";
  147.                 });
  148.             }
  149.             else
  150.             {
  151.                 string[] a = Fields.Split(‘,‘);
  152.                 p.ForEach(o =>
  153.                 {
  154.                     if (a.Contains(o.Name))
  155.                     {
  156.                         f += o.Name + ",";
  157.                         paras.Add(new SqlParameter(o.Name, o.GetValue(model, null)));
  158.                         f1 += "@" + o.Name + ",";
  159.                     }
  160.                 });
  161.             }
  162.             f = f.Remove(f.LastIndexOf(‘,‘), 1) + " ) ";
  163.             f1 = f1.Remove(f1.LastIndexOf(‘,‘), 1) + " ) ";
  164.             ExcuteString.AppendLine(f);
  165.             ExcuteString.AppendLine(f1);
  166.             return this;
  167.         }
  168.         public IDbCode AndWhere(string Where)
  169.         {
  170.             ExcuteString.AppendLine(" and " + Where);
  171.             return this;
  172.         }
  173.         public IDbCode AndWhere(string Field, object Value)
  174.         {
  175.             ExcuteString.AppendLine(" and " + Field + " = @" + Field);
  176.             paras.Add(new SqlParameter(Field, Value));
  177.             return this;
  178.         }
  179.         public IDbCode AndWhere(string Field, Func<IDbCode, string> Select)
  180.         {
  181.             ExcuteString.AppendLine(" and " + Field + " in " + Select(new SQLCode(this.paras,this.pro)));
  182.             return this;
  183.         }
  184.         public IDbCode AndWhere<T>(string Field, List<T> Values)
  185.         {
  186.             string value = "(";
  187.             Values.ForEach(o =>
  188.             {
  189.                 value += o + ",";
  190.             });
  191.             ExcuteString.AppendLine(" and " + Field + " in " + value.Remove(value.LastIndexOf(‘,‘), 1) + ")");
  192.             return this;
  193.         }
  194.         public IDbCode OrWhere(string Where)
  195.         {
  196.             ExcuteString.AppendLine(" or " + Where);
  197.             return this;
  198.         }
  199.         public IDbCode OrWhere(string Field, object Value)
  200.         {
  201.             ExcuteString.AppendLine(" or " + Field + " = @" + Field);
  202.             paras.Add(new SqlParameter(Field, Value));
  203.             return this;
  204.         }
  205.         public IDbCode OrWhere(string Field, Func<IDbCode, string> Select)
  206.         {
  207.             ExcuteString.AppendLine(" or " + Field + " in " + Select(new SQLCode(this.paras,this.pro)));
  208.             return this;
  209.         }
  210.         public IDbCode OrWhere<T>(string Field, List<T> Values)
  211.         {
  212.             string value = "(";
  213.             Values.ForEach(o =>
  214.             {
  215.                 value += o + ",";
  216.             });
  217.             ExcuteString.AppendLine(" or " + Field + " in " + value.Remove(value.LastIndexOf(‘,‘), 1) + ")");
  218.             return this;
  219.         }
  220.         public IDbCode Top(int topCount)
  221.         {
  222.             if (!ExcuteString.ToString().Contains(s[0]))
  223.                 return this;
  224.             ExcuteString.Replace("select", "select top " + topCount +" ");
  225.             return this;
  226.         }
  227.         bool CheckHasOrderBy()
  228.         {
  229.             return this.ExcuteString.ToString().Contains("order by");
  230.         }
  231.         public IDbCode OrderByAsc(string Field)
  232.         {
  233.             if (CheckHasOrderBy())
  234.                 ExcuteString.AppendLine("," + Field + " asc");
  235.             else
  236.                 ExcuteString.AppendLine(" order by " + Field+" asc");
  237.             return this;
  238.         }
  239.         public IDbCode OrderByDesc(string Field)
  240.         {
  241.             if (CheckHasOrderBy())
  242.                 ExcuteString.AppendLine("," + Field + " desc");
  243.             else
  244.                 ExcuteString.AppendLine(" order by " + Field + " desc");
  245.             return this;
  246.         }
  247.         public IDbCode ForMulTable(string Fields)
  248.         {
  249.             List<string> tables = this.Object.Split(‘,‘).ToList();
  250.             Fields.Split(‘,‘).ToList().ForEach(o =>
  251.             {
  252.                 for (int i = 0; i < tables.Count - 1; i++)
  253.                 {
  254.                     ExcuteString.AppendLine(" and " + tables[i] + "." + o + " = " + tables[i + 1] + "." + o);
  255.                 }
  256.             });
  257.             return this;
  258.         }
  259.         
  260.         public override string ToString()
  261.         {
  262.             return this.ExcuteString.ToString();
  263.         }
  264.         public IDbCode Clear()
  265.         {
  266.             pro.Clear();
  267.             return this;
  268.         }
  269.         public IDbCode CreateCode(string sql)
  270.         {
  271.             ExcuteString.AppendLine(sql);
  272.             return this;
  273.         }
  274.         public object Paras
  275.         {
  276.             get
  277.             {
  278.                 return this.paras;
  279.             }
  280.         }
  281.         public void Dispose()
  282.         {
  283.             this.pro = null;
  284.         }
  285.     }
  286. }
技术分享

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

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

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Data;
  6. using System.Data.SqlClient;
  7. namespace Dal
  8. {
  9.     public interface IDbExcute
  10.     {
  11.         T ToModel<T>(IDbCode code, CommandType type = CommandType.Text)
  12.             where T : class,new();
  13.         List<T> ToList<T>(IDbCode code,CommandType type = CommandType.Text)
  14.             where T : class,new();
  15.         object ToResult(IDbCode code, CommandType type = CommandType.Text);
  16.         int ExcuteResult(IDbCode code, CommandType type = CommandType.Text);
  17.         DataTable ToDataTable(IDbCode code, CommandType type = CommandType.Text);
  18.         DataSet ToDataSet(IDbCode code, CommandType type = CommandType.Text);
  19.         void OpenConnection();
  20.         void CloseConnection();
  21.         void Dispose(object tran);
  22.         void BeginTransation(string Name);
  23.         void Commit();
  24.         void RollBack();
  25.     }
  26. }
技术分享

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

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Data;
  6. using System.Data.SqlClient;
  7. using System.Reflection;
  8. namespace Dal
  9. {
  10.     public class SQLExcute : IDbExcute
  11.     {
  12.         SqlConnection conn;
  13.         Dictionary<string, List<PropertyInfo>> pro;
  14.         Dictionary<string, SqlCommand> command;
  15.         SqlTransaction tran = null;
  16.          
  17.         public SQLExcute(SqlConnection conn, Dictionary<string, List<PropertyInfo>> pro)
  18.         {
  19.             this.conn = conn;
  20.             this.pro = pro;
  21.             command = new Dictionary<string, SqlCommand>();
  22.         }
  23.         public List<T> ToList<T>(IDbCode code,CommandType type = CommandType.Text)
  24.             where T:class,new()
  25.         {
  26.             List<T> list = new List<T>();
  27.             string name = DateTime.Now.ToString();
  28.             command.Add(name, new SqlCommand());
  29.             SqlCommand com = command[name];
  30.             com.Connection = conn;
  31.             com.CommandText = code.ToString();
  32.             com.CommandType = type;
  33.             setCommand(com, (List<SqlParameter>)code.Paras);
  34.             Type t = typeof(T);
  35.             List<PropertyInfo> pros;
  36.             if(pro.ContainsKey(t.Name))
  37.             {
  38.                 pros = pro[t.Name];
  39.             }else
  40.             {
  41.                 pros = t.GetProperties().ToList();
  42.                 pro.Add(t.Name, pros);
  43.             }
  44.             try
  45.             {
  46.                 this.OpenConnection();
  47.                 using (SqlDataReader reader = com.ExecuteReader())
  48.                 {
  49.                     while(reader.Read())
  50.                     {
  51.                         T model = new T();
  52.                         pros.ForEach(o =>
  53.                         {
  54.                             if(ReaderExists(reader,o.Name))
  55.                             {
  56.                                 o.SetValue(model, reader[o.Name], null);
  57.                             }
  58.                         });
  59.                         list.Add(model);
  60.                     }
  61.                 }
  62.             }
  63.             catch (Exception ex)
  64.             {
  65.                 throw ex;
  66.             }
  67.             finally
  68.             {
  69.                 this.Dispose(name);
  70.                 this.CloseConnection();
  71.             }
  72.             
  73.             return list;
  74.         }
  75.         public bool ReaderExists(SqlDataReader reader, string columnName)
  76.         {
  77.             //reader.GetSchemaTable().DefaultView.RowFilter = "ColumnName= ‘" + columnName + "‘";
  78.             //return (reader.GetSchemaTable().DefaultView.Count > 0);
  79.             return reader.GetSchemaTable().Select("ColumnName=‘" + columnName + "‘").Length > 0;
  80.         }
  81.         public void Dispose(string name)
  82.         {
  83.             if(command.ContainsKey(name))
  84.             {
  85.                 SqlCommand com = command[name];
  86.                 command.Remove(name);
  87.                 com.Dispose();
  88.             }
  89.             if (command.Count <= 0)
  90.                 this.CloseConnection();
  91.         }
  92.         public void Dispose(object tran)
  93.         {
  94.             List<string> list = command.Keys.ToList();
  95.             list.ForEach(o =>
  96.             {
  97.                 if(command[o].Transaction!=null&&command[o].Transaction==(SqlTransaction)tran)
  98.                 {
  99.                     this.Dispose(o);
  100.                 }
  101.             });
  102.         }
  103.         public object ToResult(IDbCode code, CommandType type = CommandType.Text)
  104.         {
  105.             string name = DateTime.Now.ToString();
  106.             command.Add(name, new SqlCommand());
  107.             SqlCommand com = command[name];
  108.             com.Connection = conn;
  109.             com.CommandText = code.ToString();
  110.             com.CommandType = type;
  111.             setCommand(com, (List<SqlParameter>)code.Paras);
  112.             object result =null;
  113.             try
  114.             {
  115.                 this.OpenConnection();
  116.                 result = com.ExecuteScalar();
  117.             }
  118.             catch (Exception ex)
  119.             {
  120.                 DoException();
  121.                 throw ex;
  122.             }finally
  123.             {
  124.                 this.Dispose(name);
  125.                 this.CloseConnection();
  126.             }
  127.             
  128.             return result;
  129.         }
  130.         private void DoException()
  131.         {
  132.             new DbException().Done();
  133.         }
  134.         public int ExcuteResult(IDbCode code, CommandType type = CommandType.Text)
  135.         {
  136.             string name = DateTime.Now.ToString();
  137.             command.Add(name, new SqlCommand());
  138.             SqlCommand com = command[name];
  139.             com.Connection = conn;
  140.             com.CommandText = code.ToString();
  141.             com.CommandType = type;
  142.             setCommand(com, (List<SqlParameter>)code.Paras);
  143.             int result = 0;
  144.             try
  145.             {
  146.                 this.OpenConnection();
  147.                 if (tran != null)
  148.                     com.Transaction = (SqlTransaction)tran;
  149.                 result = com.ExecuteNonQuery();
  150.             }
  151.             catch (Exception ex)
  152.             {
  153.                 DoException();
  154.                 throw ex;
  155.             }
  156.             finally
  157.             {
  158.                 if (tran == null)
  159.                     Dispose(name);
  160.                 this.CloseConnection();
  161.             }
  162.             return result;
  163.         }
  164.         public System.Data.DataTable ToDataTable(IDbCode code, CommandType type = CommandType.Text)
  165.         {
  166.             string name = DateTime.Now.ToString();
  167.             command.Add(name, new SqlCommand());
  168.             SqlCommand com = command[name];
  169.             com.Connection = conn;
  170.             com.CommandText = code.ToString();
  171.             com.CommandType = type;
  172.             setCommand(com, (List<SqlParameter>)code.Paras);
  173.             DataTable dt = new DataTable();
  174.             try
  175.             {
  176.                 using(SqlDataAdapter adapter = new SqlDataAdapter(com))
  177.                 {
  178.                     adapter.Fill(dt);
  179.                 }
  180.             }
  181.             catch (Exception ex)
  182.             {
  183.                 DoException();
  184.                 throw ex;
  185.             }finally
  186.             {
  187.                 Dispose(name);
  188.             }
  189.             return dt;
  190.         }
  191.         public void setCommand(SqlCommand com,List<SqlParameter> paras)
  192.         {
  193.             paras.ForEach(o =>
  194.             {
  195.                 com.Parameters.Add(o);
  196.             });
  197.         }
  198.         public System.Data.DataSet ToDataSet(IDbCode code, CommandType type = CommandType.Text)
  199.         {
  200.             string name = DateTime.Now.ToString();
  201.             command.Add(name, new SqlCommand());
  202.             SqlCommand com = command[name];
  203.             com.Connection = conn;
  204.             com.CommandText = code.ToString();
  205.             com.CommandType = type;
  206.             setCommand(com, (List<SqlParameter>)code.Paras);
  207.             DataSet dt = new DataSet();
  208.             try
  209.             {
  210.                 using (SqlDataAdapter adapter = new SqlDataAdapter(com))
  211.                 {
  212.                     adapter.Fill(dt);
  213.                 }
  214.             }
  215.             catch (Exception ex)
  216.             {
  217.                 DoException();
  218.                 throw ex;
  219.             }
  220.             finally
  221.             {
  222.                 Dispose(name);
  223.             }
  224.             return dt;
  225.         }
  226.         public T ToModel<T>(IDbCode code, CommandType type = CommandType.Text)
  227.             where T : class,new()
  228.         {
  229.             string name = DateTime.Now.ToString();
  230.             command.Add(name, new SqlCommand());
  231.             SqlCommand com = command[name];
  232.             com.Connection = conn;
  233.             com.CommandText = code.ToString();
  234.             com.CommandType = type;
  235.             setCommand(com, (List<SqlParameter>)code.Paras);
  236.             
  237.             Type t = typeof(T);
  238.             List<PropertyInfo> p = null;
  239.             if(pro.ContainsKey(t.Name))
  240.             {
  241.                 p = pro[t.Name];
  242.             }else
  243.             {
  244.                 p = t.GetProperties().ToList();
  245.                 pro.Add(t.Name, p);
  246.             }
  247.             T model = new T();
  248.             try
  249.             {
  250.                 this.OpenConnection();
  251.                 using(SqlDataReader reader = com.ExecuteReader())
  252.                 {
  253.                     if(reader.Read())
  254.                     {
  255.                         p.ForEach(o =>
  256.                         {
  257.                             if(ReaderExists(reader,o.Name))
  258.                             {
  259.                                 o.SetValue(model, reader[o.Name], null);
  260.                             }
  261.                         });
  262.                     }
  263.                 }
  264.             }
  265.             catch (Exception ex)
  266.             {
  267.                 DoException();
  268.                 throw ex;
  269.             }
  270.             finally
  271.             {
  272.                 Dispose(name);
  273.                 this.CloseConnection();
  274.             }
  275.             return model;
  276.         }
  277.         public void OpenConnection()
  278.         {
  279.             if (this.conn.State != ConnectionState.Open)
  280.                 this.conn.Open();
  281.         }
  282.         public void CloseConnection()
  283.         {
  284.             command.Values.ToList().ForEach(o =>
  285.             {
  286.                 if (o.Transaction != null)
  287.                     return;
  288.             });
  289.             if (this.conn.State != ConnectionState.Closed)
  290.                 this.conn.Close();
  291.         }
  292.         public void BeginTransation(string Name)
  293.         {
  294.             tran = conn.BeginTransaction(Name);
  295.         }
  296.         public void Commit()
  297.         {
  298.             tran.Commit();
  299.             Dispose(tran);
  300.             tran = null;
  301.         }
  302.         public void RollBack()
  303.         {
  304.             tran.Rollback();
  305.             Dispose(tran);
  306.             tran = null;
  307.         }
  308.     }
  309. }
技术分享

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

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace Dal
  6. {
  7.     public class DbException
  8.     {
  9.         public virtual void Done()
  10.         {
  11.         }
  12.     }
  13. }
技术分享

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

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

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace Dal
  6. {
  7.     public interface IDbInstance
  8.     {
  9.         /// <summary>
  10.         /// 数据库名称
  11.         /// </summary>
  12.         string Name
  13.         {
  14.             get;
  15.         }
  16.         /// <summary>
  17.         /// 获取执行语句类
  18.         /// </summary>
  19.         IDbExcute Excute
  20.         {
  21.             get;
  22.         }
  23.         /// <summary>
  24.         /// 获取连接字符串
  25.         /// </summary>
  26.         string ConnectionString
  27.         {
  28.             get;
  29.         }
  30.         /// <summary>
  31.         /// 开启事务
  32.         /// </summary>
  33.         /// <param name="TranName">事务名称</param>
  34.         /// <returns></returns>
  35.         object getTransation(string TranName);
  36.         /// <summary>
  37.         /// 获取拼写字符串类
  38.         /// </summary>
  39.         IDbCode Code
  40.         {
  41.             get;
  42.         }
  43.     }
  44. }
技术分享

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

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Data;
  6. using System.Data.SqlClient;
  7. using System.Reflection;
  8. namespace Dal
  9. {
  10.     public class SQLInstance :IDbInstance
  11.     {
  12.         private SqlConnection conn;
  13.         private IDbExcute excute;
  14.         Dictionary<string, List<PropertyInfo>> pro;
  15.         private string name;
  16.         private string connectionString;
  17.         private SqlTransaction tran = null;
  18.         public SQLInstance(string Name,Dictionary<string,List<PropertyInfo>> pro, string ConnectionString)
  19.         {
  20.             this.name = Name;
  21.             this.connectionString = ConnectionString;
  22.             conn = new SqlConnection(ConnectionString);
  23.             this.pro = pro;
  24.             excute = new SQLExcute(conn,pro);
  25.         }
  26.         public string Name
  27.         {
  28.             get
  29.             {
  30.                 return this.name;
  31.             }
  32.         }
  33.         public IDbExcute Excute
  34.         {
  35.             get
  36.             {
  37.                 return this.excute;
  38.             }
  39.         }
  40.         public string ConnectionString
  41.         {
  42.             get
  43.             {
  44.                 return this.connectionString;
  45.             }
  46.         }
  47.         public object getTransation(string TranName)
  48.         {
  49.             return this.conn.BeginTransaction(TranName);
  50.         }
  51.         public IDbCode Code
  52.         {
  53.             get
  54.             {
  55.                 return new SQLCode(pro);
  56.             }
  57.         }
  58.     }
  59. }
技术分享

接下来是控制连接的类：

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Reflection;
  6. namespace Dal
  7. {
  8.     public class DbControl
  9.     {
  10.         //数据库服务
  11.         private static Dictionary<string, IDbInstance> Server = new Dictionary<string, IDbInstance>();
  12.         //存放缓存
  13.         private static Dictionary<string, List<PropertyInfo>> pro = new Dictionary<string, List<PropertyInfo>>();
  14.         private static DbControl control = new DbControl();
  15.         public static DbControl getInstance()
  16.         {
  17.             return control;
  18.         }
  19.         private DbControl()
  20.         {
  21.         }
  22.         public IDbInstance createInstance(string Name,string ConnectionString,string type)
  23.         {
  24.             string nspace = typeof(IDbInstance).Namespace;
  25.             Type t = Type.GetType(nspace + "." + type);
  26.             object obj = Activator.CreateInstance(t, new object[] { Name, pro, ConnectionString });
  27.             
  28.             IDbInstance instance = obj as IDbInstance;
  29.             Server.Add(Name, instance);
  30.             return instance;
  31.         }
  32.         public IDbInstance this[string Name]
  33.         {
  34.             get
  35.             {
  36.                 if (Server.ContainsKey(Name))
  37.                     return Server[Name];
  38.                 else
  39.                     return null;
  40.             }
  41.         }
  42.     }
  43. }
技术分享

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

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

技术分享 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Data;
  6. namespace Dal
  7. {
  8.     public class DbHelper
  9.     {
  10.         private IDbInstance instance;
  11.         private string Name;
  12.         private DbControl control;
  13.         private IDbCode Code;
  14.         public DbHelper()
  15.         {
  16.             control = DbControl.getInstance();
  17.         }
  18.         public DbHelper createConnection(string Name, string ConnectionString, string type)
  19.         {
  20.             this.Name = Name;
  21.             instance = control.createInstance(Name, ConnectionString, type);
  22.             return this;
  23.         }
  24.         public DbHelper ExcuteString(Func<IDbCode,IDbCode> Fun)
  25.         {
  26.             Code = Fun(this.instance.Code);
  27.             return this;
  28.         }
  29.         public DbHelper createTransation(string Name)
  30.         {
  31.             this.instance.Excute.BeginTransation(Name);
  32.             return this;
  33.         }
  34.         public DbHelper Rollback()
  35.         {
  36.             this.instance.Excute.RollBack();
  37.             return this;
  38.         }
  39.         public DbHelper Commit()
  40.         {
  41.             this.instance.Excute.Commit();
  42.             return this;
  43.         }
  44.         public T ToModel<T>(CommandType Type = CommandType.Text)
  45.             where T:class,new()
  46.         {
  47.             if (this.Code == null)
  48.                 return null;
  49.             return this.instance.Excute.ToModel<T>(this.Code,Type);
  50.         }
  51.         List<T> ToList<T>(CommandType Type = CommandType.Text)
  52.             where T:class,new()
  53.         {
  54.             if (this.Code == null)
  55.                 return null;
  56.             return this.instance.Excute.ToList<T>(this.Code, Type);
  57.         }
  58.         object ToResult(CommandType Type = CommandType.Text)
  59.         {
  60.             if (this.Code == null)
  61.                 return null;
  62.             return this.instance.Excute.ToResult(this.Code, Type);
  63.         }
  64.         int ExcuteResult(CommandType Type = CommandType.Text)
  65.         {
  66.             if (this.Code == null)
  67.                 return -1;
  68.             return this.instance.Excute.ExcuteResult(this.Code, Type);
  69.         }
  70.         DataTable ToDataTable(CommandType Type = CommandType.Text)
  71.         {
  72.             if (this.Code == null)
  73.                 return null;
  74.             return this.instance.Excute.ToDataTable(this.Code, Type);
  75.         }
  76.         DataSet ToDataSet(CommandType Type = CommandType.Text)
  77.         {
  78.             if (this.Code == null)
  79.                 return null;
  80.             return this.instance.Excute.ToDataSet(this.Code, Type);
  81.         }
  82.     }
  83. }
技术分享

 

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

C# .NET数据库操作

标签：[]   sts   几句话   文档   实例   规模   .com   反射   http   

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！