前述：
第一次发表文章，不过是对数据库简单的封装，主要是阐述下思路。那么在上篇文章，在大家的指导下和提出意见，并自己对代码进行了思考。在这两天我重构了新的框架，我觉得我写的可以称得上框架，为什么？请大家往下看。不过在项目中没有很多注释。笔者除了课余学习时候，大部分时间在完成学校的功课，没有许多时间，所以也就偷下懒，请大家体谅。
这次框架分为几个部分：拼接数据库语句、数据库执行、数据库连接控制、异常类、用户使用的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);
}
}
}
结束：快要熄灯了，没办法在写文章。如果大家对框架有什么不明白，可以在下面评论区问我。这就是更新之后的框架，我觉得还是蛮好用的，虽然还没经过严密的检测。有什么问题，大家也可以指导下，我也在学习中~