zoukankan html css js c++ java

Dapper小型ORM的使用（随便吐槽下公司）

　　近来公司又有新项目要做，之前做项目用过蛮多ORM，包括ef,NetTiers,ServiceStack.OrmLite等ROM，每种ORM都有一定的坑（或者说是使用者的问题吧~~）。用来用去都觉的有一定的不爽。这次打算用Dapper这个ORM来做项目看看。首先感谢http://www.cnblogs.com/wywnet/p/33422150.html这位老兄给出的文章还有demo（建议大家可以看看），看了后深受启发。所以也确定用Dapper来练练手。好了，先介绍下Dapper这个ORM

1，Dapper是一个轻型的ORM类。代码就一个SqlMapper.cs文件，编译后就40K的一个很小的Dll. 小型ORM

2，Dapper很快。Dapper的速度接近与IDataReader，取列表的数据超过了DataTable。 速度快

3，Dapper支持什么数据库。Dapper支持Mysql,SqlLite,Mssql2000,Mssql2005,Oracle等一系列的数据库 支持多数据库

4，Dapper的r支持多表并联的对象。支持一对多多对多的关系。并且没侵入性，想用就用，不想用就不用。无XML无属性。代码以前怎么写现在还怎么写。 灵活性高

5，Dapper原理通过Emit反射IDataReader的序列队列，来快速的得到和产生对象。性能实在高高高。 性能高

6，Dapper支持net2.0,3.0,3.5,4.0。【如果想在Net2.0下使用，可以去网上找一下Net2.0下如何配置运行Net3.5即可。】 支持多个.net版本

7，Dapper语法十分简单。并且无须迁就数据库的设计。 语法简单，可扩展性强

Dapper官网：https://code.google.com/p/dapper-dot-net/

Dapper简单使用：http://www.cnblogs.com/wywnet/p/3422150.html

SqlMapper.cs 是最基础的底层文件，为了更好的运用，先对Dapper进行扩展，这里写一个Dapper的扩展类（这里只列出主要的类，一些辅助类就不列出了）

Dapper扩展类，DapperEx.cs

  1    public static class DapperEx
  2     {
  3 
  4 
  5         /// <summary>
  6         /// 插入数据
  7         /// </summary>
  8         /// <typeparam name="T"></typeparam>
  9         /// <param name="dbs"></param>
 10         /// <param name="t"></param>
 11         /// <param name="transaction"></param>
 12         /// <param name="commandTimeout"></param>
 13         /// <returns></returns>
 14         public static int Insert<T>(this DbBase dbs, T t, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
 15         {
 16             var db = dbs.DbConnecttion;
 17             var sql = SqlQuery<T>.Builder(dbs);
 18             var flag = db.Execute(sql.InsertSql, t, transaction, commandTimeout);
 19             int KeyID = 0;
 20             SetIdentity(db, (id) => { KeyID = id; }, transaction);
 21             return KeyID;
 22             //return flag == 1;
 23         }
 24 
 25         /// <summary>
 26         ///  批量插入数据
 27         /// </summary>
 28         /// <typeparam name="T"></typeparam>
 29         /// <param name="dbs"></param>
 30         /// <param name="lt"></param>
 31         /// <param name="transaction"></param>
 32         /// <param name="commandTimeout"></param>
 33         /// <returns></returns>
 34         public static bool InsertBatch<T>(this DbBase dbs, IList<T> lt, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
 35         {
 36             var db = dbs.DbConnecttion;
 37             var sql = SqlQuery<T>.Builder(dbs);
 38             var flag = db.Execute(sql.InsertSql, lt, transaction, commandTimeout);
 39             return flag == lt.Count;
 40         }
 41 
 42         /// <summary>
 43         /// 按条件删除
 44         /// </summary>
 45         /// <typeparam name="T"></typeparam>
 46         /// <param name="dbs"></param>
 47         /// <param name="sql"></param>
 48         /// <returns></returns>
 49         public static bool Delete<T>(this DbBase dbs, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
 50         {
 51             var db = dbs.DbConnecttion;
 52             if (sql == null)
 53             {
 54                 sql = SqlQuery<T>.Builder(dbs);
 55             }
 56             var f = db.Execute(sql.DeleteSql, sql.Param, transaction);
 57             return f > 0;
 58         }
 59 
 60         /// <summary>
 61         /// 按指定某型删除
 62         /// </summary>
 63         /// <typeparam name="T"></typeparam>
 64         /// <param name="dbs"></param>
 65         /// <param name="sql">如果sql为null，则根据t的主键进行修改</param>
 66         /// <returns></returns>
 67         public static bool Delete<T>(this DbBase dbs, T t, IDbTransaction transaction = null) where T : class
 68         {
 69             var db = dbs.DbConnecttion;
 70             SqlQuery sql = SqlQuery<T>.Builder(dbs);
 71             sql = sql.AppendParam<T>(t);
 72             var f = db.Execute(sql.DeleteSql, sql.Param, transaction);
 73             return f > 0;
 74         }
 75 
 76         /// <summary>
 77         /// 指定主键ID删除数据
 78         /// </summary>
 79         /// <typeparam name="T"></typeparam>
 80         /// <param name="dbs"></param>
 81         /// <param name="ID"></param>
 82         /// <param name="transaction"></param>
 83         /// <returns></returns>
 84         public static bool DeleteByID<T>(this DbBase dbs, object ID, IDbTransaction transaction = null) where T : class
 85         {
 86             var db = dbs.DbConnecttion;
 87             SqlQuery sql = SqlQuery<T>.Builder(dbs);
 88             sql.KeyValue = ID;
 89             var f = db.Execute(sql.DeleteKeySql, sql.Param, transaction);
 90             return f > 0;
 91         }
 92 
 93         /// <summary>
 94         /// 修改
 95         /// </summary>
 96         /// <typeparam name="T"></typeparam>
 97         /// <param name="dbs"></param>
 98         /// <param name="t">如果sql为null，则根据t的主键进行修改</param>
 99         /// <param name="sql">按条件修改</param>
100         /// <returns></returns>
101         public static bool Update<T>(this DbBase dbs, T t, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
102         {
103             var db = dbs.DbConnecttion;
104             if (sql == null)
105             {
106                 sql = SqlQuery<T>.Builder(dbs);
107             }
108             sql = sql.AppendParam<T>(t);
109             var f = db.Execute(sql.UpdateSql, sql.Param, transaction);
110             return f > 0;
111         }
112 
113         /// <summary>
114         /// 修改
115         /// </summary>
116         /// <typeparam name="T"></typeparam>
117         /// <param name="dbs"></param>
118         /// <param name="t">如果sql为null，则根据t的主键进行修改</param>
119         /// <param name="updateProperties">要修改的属性集合</param>
120         /// <param name="sql">按条件修改</param>
121         /// <returns></returns>
122         public static bool Update<T>(this DbBase dbs, T t, IList<string> updateProperties, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
123         {
124             var db = dbs.DbConnecttion;
125             if (sql == null)
126             {
127                 sql = SqlQuery<T>.Builder(dbs);
128             }
129             sql = sql.AppendParam<T>(t)
130                 .SetExcProperties<T>(updateProperties);
131             var f = db.Execute(sql.UpdateSql, sql.Param, transaction);
132             return f > 0;
133         }
134 
135         /// <summary>
136         /// 获取默认一条数据，没有则为NULL
137         /// </summary>
138         /// <typeparam name="T"></typeparam>
139         /// <param name="dbs"></param>
140         /// <param name="sql"></param>
141         /// <returns></returns>
142         public static T SingleOrDefault<T>(this DbBase dbs, SqlQuery sql, IDbTransaction transaction = null) where T : class
143         {
144             var db = dbs.DbConnecttion;
145             if (sql == null)
146             {
147                 sql = SqlQuery<T>.Builder(dbs);
148             }
149             sql = sql.Top(1);
150             var result = db.Query<T>(sql.QuerySql, sql.Param, transaction);
151             return result.FirstOrDefault();
152         }
153 
154         /// <summary>
155         /// 分页查询
156         /// </summary>
157         /// <typeparam name="T"></typeparam>
158         /// <param name="dbs"></param>
159         /// <param name="pageIndex"></param>
160         /// <param name="pageSize"></param>
161         /// <param name="dataCount"></param>
162         /// <param name="sqlQuery"></param>
163         /// <returns></returns>
164         public static IList<T> Page<T>(this DbBase dbs, int pageIndex, int pageSize, out long dataCount, SqlQuery sqlQuery = null, IDbTransaction transaction = null) where T : class
165         {
166             var db = dbs.DbConnecttion;
167             var result = new List<T>();
168             dataCount = 0;
169             if (sqlQuery == null)
170             {
171                 sqlQuery = SqlQuery<T>.Builder(dbs);
172             }
173             sqlQuery = sqlQuery.Page(pageIndex, pageSize);
174             var para = sqlQuery.Param;
175             var cr = db.Query(sqlQuery.CountSql, para, transaction).SingleOrDefault();
176             dataCount =  (long)cr.DataCount;
177             result = db.Query<T>(sqlQuery.PageSql, para, transaction).ToList();
178             return result;
179         }
180 
181         /// <summary>
182         /// 查询
183         /// </summary>
184         /// <typeparam name="T"></typeparam>
185         /// <param name="dbs"></param>
186         /// <param name="sql"></param>
187         /// <returns></returns>
188         public static IList<T> Query<T>(this DbBase dbs, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
189         {
190             var db = dbs.DbConnecttion;
191             if (sql == null)
192             {
193                 sql = SqlQuery<T>.Builder(dbs);
194             }
195             var result = db.Query<T>(sql.QuerySql, sql.Param, transaction);
196             return result.ToList();
197         }
198 
199         /// <summary>
200         /// 通过主键查询
201         /// </summary>
202         /// <typeparam name="T"></typeparam>
203         /// <param name="dbs"></param>
204         /// <param name="sql"></param>
205         /// <returns></returns>
206         public static T QueryByID<T>(this DbBase dbs, object ID, IDbTransaction transaction = null) where T : class
207         {
208             var db = dbs.DbConnecttion;
209             SqlQuery sql = SqlQuery<T>.Builder(dbs);
210             sql.KeyValue = ID;
211             var result = db.Query<T>(sql.QueryKeySql, sql.Param, transaction).FirstOrDefault();
212             return result;
213         }
214 
215         /// <summary>
216         /// 数据数量
217         /// </summary>
218         /// <typeparam name="T"></typeparam>
219         /// <param name="dbs"></param>
220         /// <param name="sql"></param>
221         /// <returns></returns>
222         public static long Count<T>(this DbBase dbs, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
223         {
224             var db = dbs.DbConnecttion;
225             if (sql == null)
226             {
227                 sql = SqlQuery<T>.Builder(dbs);
228             }
229             var cr = db.Query(sql.CountSql, sql.Param, transaction).SingleOrDefault();
230             return (long)cr.DataCount;
231         }
232 
233         public static void SetIdentity(IDbConnection conn, Action<int> setId, IDbTransaction transaction = null)
234         {
235             dynamic identity = conn.Query("SELECT @@IDENTITY AS Id", null, transaction).Single();
236             int newId = (int)identity.Id;
237             setId(newId);
238         }
239 
240         /// <summary>
241         /// 判断对象是否存在
242         /// </summary>
243         /// <typeparam name="T"></typeparam>
244         /// <param name="dbs"></param>
245         /// <param name="ID"></param>
246         /// <param name="transaction"></param>
247         /// <returns></returns>
248         public static bool Exists<T>(this DbBase dbs, object ID, IDbTransaction transaction = null) where T : class
249         {
250             var db = dbs.DbConnecttion;
251             SqlQuery sql = SqlQuery<T>.Builder(dbs);
252             sql.KeyValue = ID;
253             var f = db.Query(sql.ExistsSql, sql.Param, transaction).SingleOrDefault();
254             return f.DataCount > 0; ;// f > 0;
255         }
256 
257         /// <summary>
258         ///自定义语句和存储过程查询--返回集合
259         /// </summary>
260         /// <typeparam name="T">返回集合</typeparam>
261         /// <param name="sql">sql语句或存储过程名字</param>
262         /// <param name="p">参数</param>
263         /// <param name="cmdType">执行的命令类型</param>
264         /// <param name="transaction">事物控制</param>
265         /// DynamicParameters
266         /// <returns></returns>
267         public static IEnumerable<T> Query<T>(this DbBase dbs, string query, object p = null, CommandType cmdType = CommandType.Text, IDbTransaction transaction = null)
268         {
269             var db = dbs.DbConnecttion;
270             return db.Query<T>(query, p, transaction, true, null, cmdType);
271         }
272 
273         /// <summary>
274         /// 自定义语句和存储过程的增删改--返回影响的行数
275         /// </summary>
276         /// <typeparam name="T"></typeparam>
277         /// <param name="dbs"></param>
278         /// <param name="query">执行的语句</param>
279         /// <param name="parans">参数</param>
280         /// <param name="transaction">事物控制</param>
281         /// <returns>影响的行数</returns>
282         public static int Execute(this DbBase dbs, string query, object parans, CommandType cmdType = CommandType.Text,IDbTransaction transaction = null)
283         {
284             var db = dbs.DbConnecttion;
285             int row = db.Execute(query, parans, transaction,null,cmdType);
286             return row;
287         }
288 
289     }

DapperEx.cs

有这个扩展类后面的操作的方便了，接下来是用DAL层来调用，这里写个封装个基类

DAL基类 DataAccessBase.cs

  1     public  class DataAccessBase
  2     {
  3         public DbBase db { get; private set; }
  4 
  5         public DataAccessBase(DbBase Db)
  6         {
  7             this.db = Db;
  8         }
  9         #region 自定义其他方法
 10 
 11         #endregion
 12     }
 13     public  class DataAccessBase<T> : DataAccessBase where T : class
 14     {
 15         public DataAccessBase(DbBase db) : base(db) { }
 16 
 17         #region  INSERT
 18         /// <summary>
 19         /// //插入一条数据
 20         /// </summary>
 21         /// <param name="user"></param>
 22         /// <returns></returns>
 23         public int Insert(T model, IDbTransaction tran = null)
 24         {
 25             var result = db.Insert<T>(model, tran);
 26             return result;
 27         }
 28 
 29         /// <summary>
 30         /// 插入批量数据
 31         /// </summary>
 32         /// <param name="models"></param>
 33         public bool InsertBatch(List<T> models, IDbTransaction tran = null)
 34         {
 35             var result = db.InsertBatch<T>(models, tran);
 36             return result;
 37 
 38         }
 39         #endregion
 40 
 41         #region SELECT
 42         /// <summary>
 43         /// 获取默认一条数据，没有则为NULL
 44         /// </summary>
 45         /// <param name="sqlWhere"></param>
 46         /// <returns></returns>
 47         public T SingleOrDefault(SqlQuery sqlWhere = null, IDbTransaction tran = null)
 48         {
 49             var result = db.SingleOrDefault<T>(sqlWhere, tran);
 50             return result;
 51         }
 52 
 53         /// <summary>
 54         /// 根据主键查询
 55         /// </summary>
 56         /// <param name="ID"></param>
 57         /// <returns></returns>
 58         public T GetByID(object ID, IDbTransaction tran = null)
 59         {
 60             var result = db.QueryByID<T>(ID, tran);
 61             return result;
 62         }
 63 
 64         /// <summary>
 65         /// 获取全部数据
 66         /// </summary>
 67         /// <returns></returns>
 68         public IList<T> GetAll(IDbTransaction tran = null)
 69         {
 70             var result = db.Query<T>(null, tran);
 71             return result;
 72 
 73         }
 74 
 75         /// <summary>
 76         /// 带条件查询
 77         /// </summary>
 78         /// <param name="d"></param>
 79         /// <returns></returns>
 80         public IList<T> GetAll(SqlQuery sqlWhere, IDbTransaction tran = null)
 81         {
 82             var result = db.Query<T>(sqlWhere, tran);
 83             return result;
 84         }
 85 
 86         /// <summary>
 87         /// 分页查询
 88         /// </summary>
 89         /// <param name="PageIndex"></param>
 90         /// <param name="PageSize"></param>
 91         /// <param name="row"></param>
 92         /// <param name="sql"></param>
 93         /// <returns></returns>
 94         public IList<T> Page(int PageIndex, int PageSize, out long row, SqlQuery sql = null, IDbTransaction tran = null)
 95         {
 96             var result = db.Page<T>(PageIndex, PageSize, out row, sql, tran);
 97             return result;
 98 
 99         }
100         #endregion
101 
102         #region DELETE
103         /// <summary>
104         /// 自定义条件删除
105         /// </summary>
106         /// <param name="sqlWhere"></param>
107         /// <returns></returns>
108         public bool Delete(SqlQuery sqlWhere, IDbTransaction tran = null)
109         {
110             var result = db.Delete<T>(sqlWhere, tran);
111             return result;
112         }
113 
114         /// <summary>
115         /// 按模型删除
116         /// </summary>
117         /// <param name="model"></param>
118         /// <returns></returns>
119         public bool Delete(T model, IDbTransaction tran = null)
120         {
121             var result = db.Delete<T>(model, tran);
122             return result;
123         }
124 
125         /// <summary>
126         /// 根据主键ID删除
127         /// </summary>
128         /// <param name="ID"></param>
129         /// <returns></returns>
130         public bool DeleteByID(object ID, IDbTransaction tran = null)
131         {
132             var result = db.DeleteByID<T>(ID, tran);
133             return result;
134         }
135 
136         /// <summary>
137         /// 按主键批量删除
138         /// </summary>
139         /// <param name="idValues"></param>
140         /// <returns></returns>
141         public bool DeleteByIds(IEnumerable idValues, IDbTransaction tran = null)
142         {
143             bool result = false;
144             //开启事务
145             if (tran == null)
146             {
147                 tran = db.DbTransaction;
148             }
149             foreach (var item in idValues)
150             {
151                 result = db.DeleteByID<T>(item, tran);
152                 if (!result)
153                 {
154                     break;
155                 }
156             }
157             if (result)
158             {
159                 tran.Commit();
160             }
161             else
162             {
163                 tran.Rollback();
164             }
165             return result;
166         }
167 
168         /// <summary>
169         /// 批量删除
170         /// </summary>
171         /// <param name="model"></param>
172         /// <returns></returns>
173         public bool DeleteBatch(List<T> model, IDbTransaction tran = null)
174         {
175             bool result = false;
176             //开启事务
177             if (tran == null)
178             {
179                 tran = db.DbTransaction;
180             }
181             foreach (var item in model)
182             {
183                 result = db.Delete<T>(item, tran);
184                 if (!result)
185                 {
186                     break;
187                 }
188             }
189             if (result)
190             {
191                 tran.Commit();
192             }
193             else
194             {
195                 tran.Rollback();
196             }
197             return result;
198         }
199         #endregion
200 
201         #region UPDATE
202         /// <summary>
203         /// 修改--（带T和sqlWhere时可实现统一修改）
204         /// </summary>
205         /// <param name="model">如果sql为null，则根据model的主键进行修改</param>
206         /// <param name="sqlWhere">按条件修改</param>
207         public bool Update(T model, SqlQuery sqlWhere = null, IDbTransaction tran = null)
208         {
209             var result = db.Update<T>(model, sqlWhere, tran);
210             return result;
211         }
212 
213         /// <summary>
214         /// 修改--可指定属性修改
215         /// </summary>
216         /// <param name="model">如果sql为null，则根据t的主键进行修改</param>
217         /// <param name="updateProperties">要修改的属性集合</param>
218         /// <param name="sqlWhere">按条件修改</param>
219         /// <returns></returns>
220         public bool Update(T model, IList<string> updateProperties, SqlQuery sqlWhere = null, IDbTransaction tran = null)
221         {
222             var result = db.Update<T>(model, updateProperties, sqlWhere, tran);
223             return result;
224 
225         }
226 
227         /// <summary>
228         /// 批量插入
229         /// </summary>
230         /// <param name="model"></param>
231         /// <returns></returns>
232         public bool UpdateBatch(List<T> model, IDbTransaction tran = null)
233         {
234             bool result = false;
235             //开启事务
236             if (tran == null)
237             {
238                 tran = db.DbTransaction;
239             }
240             foreach (var item in model)
241             {
242                 result = db.Update<T>(item, null, tran);
243                 if (!result)
244                 {
245                     break;
246                 }
247             }
248             if (result)
249             {
250                 tran.Commit();
251             }
252             else
253             {
254                 tran.Rollback();
255             }
256             return result;
257         }
258         #endregion
259 
260         #region ORTHER
261         /// <summary>
262         /// 获取数量
263         /// </summary>
264         /// <param name="sqlWhere"></param>
265         /// <returns></returns>
266         public long GetCount(SqlQuery sqlWhere = null, IDbTransaction tran = null)
267         {
268             return db.Count<T>(sqlWhere, tran);
269         }
270 
271         /// <summary>
272         /// 判断对象是否存在
273         /// </summary>
274         /// <param name="ID"></param>
275         /// <returns></returns>
276         public bool Exists(object ID, IDbTransaction tran = null)
277         {
278             return db.Exists<T>(ID, tran);
279         }
280 
281         /// <summary>
282         /// 自定义语句和存储过程查询--返回集合
283         /// </summary>
284         /// <param name="sql">自定的语句或存储过程名字</param>
285         /// <param name="param">参数</param>
286         /// <param name="cmdType">类型</param>
287         /// <returns></returns>
288         public IEnumerable<T> Query<T>(string sql, object param = null, CommandType cmdType = CommandType.Text, IDbTransaction tran = null)
289         {
290             return db.Query<T>(sql, param, cmdType, tran);
291         }
292 
293         /// <summary>
294         /// 自定义语句和存储过程的增删改--返回影响的行数
295         /// </summary>
296         /// <param name="sql">自定的语句或存储过程名字</param>
297         /// <param name="param">参数</param>
298         /// <param name="cmdType">类型</param>
299         /// <returns></returns>
300         public int Execute(string sql, object param = null, CommandType cmdType = CommandType.Text, IDbTransaction tran = null)
301         {
302             return db.Execute(sql, param, cmdType, tran);
303         }
304 
305         /// <summary>
306         /// 使用DynamicParameters方式
307         /// </summary>
308         /// <param name="sql"></param>
309         /// <param name="param"></param>
310         /// <param name="cmdType"></param>
311         /// <returns></returns>
312         public int Execute(string sql, DynamicParameters param = null, CommandType cmdType = CommandType.Text, IDbTransaction tran = null)
313         {
314             //param.Add("@ID", 123);
315             return db.Execute(sql, param, cmdType, tran);
316         }
317         #endregion
318 
319     }

DataAccessBase.cs

再写个生成DAL的T4模板

DALAuto.tt

 1 <#@ template debug="true" hostspecific="true" language="C#"  #>
 2 <#@ output extension=".cs" #>
 3 <#@ assembly name="System.Core"#>
 4 <#@ import namespace="System"#>
 5 <#@ import namespace="System.Collections.Generic"#>
 6 <#@ include file="DBSchema.ttinclude"#>
 7 
 8 using DapperEx;
 9 using System;
10 using System.Collections.Generic;
11 using System.Linq;
12 using System.Text;
13 using Entity;
14 
15 namespace DAL
16 {
17 
18 <# 
19      var dbSchema=DBSchemaFactory.GetDBSchema();
20     List<string> tableList=dbSchema.GetTablesList();
21     string Extension="Info";
22     foreach(string tableName in tableList)
23     { #>
24     public partial class <#=tableName#>DAL: DataAccessBase<<#=tableName#><#=Extension#>>
25     {        
26         public <#=tableName#>DAL(DbBase db) : base(db) { }
27     }
28 <# } #>
29 }

DALAuto.tt

然后通过BLL层调用，也封装个基类和生成BLL的T4模板

BLL 基类 BusinessBase.cs

  1     public class BusinessBase
  2     {
  3         public DbBase OpenConnection(string name = null)
  4         {
  5             if (String.IsNullOrWhiteSpace(name))
  6             {
  7                 name = "strSqlCe";
  8             }
  9             return new DbBase(name);
 10         }
 11     }
 12 
 13     public class BusinessBase<T> : BusinessBase where T : class
 14     {
 15         public int Insert(T model)
 16         {
 17             using (var db = OpenConnection())
 18             {
 19                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 20                 return dal.Insert(model);
 21             }
 22         }
 23         public bool InsertBatch(List<T> models)
 24         {
 25             using (var db = OpenConnection())
 26             {
 27                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 28                 return dal.InsertBatch(models);
 29             }
 30         }
 31         public T SingleOrDefault(SqlQuery sqlWhere = null)
 32         {
 33             using (var db = OpenConnection())
 34             {
 35                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 36                 var result = dal.SingleOrDefault(sqlWhere);
 37                 return result;
 38             }
 39         }
 40         public T GetByID(object ID)
 41         {
 42             using (var db = OpenConnection())
 43             {
 44                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 45                 var result = dal.GetByID(ID);
 46                 return result;
 47             }
 48         }
 49         public IList<T> GetAll()
 50         {
 51             using (var db = OpenConnection())
 52             {
 53                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 54                 return dal.GetAll();
 55             }
 56         }
 57         public IList<T> GetAll(SqlQuery<T> sqlWhere)
 58         {
 59             using (var db = OpenConnection())
 60             {
 61                 if (sqlWhere == null)
 62                 {
 63                     sqlWhere = SqlQuery<T>.Builder(db);
 64                 }
 65                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 66                 return dal.GetAll(sqlWhere);
 67             }
 68         }
 69         public IList<T> Page(int PageIndex, int PageSize, out long row, SqlQuery sql = null)
 70         {
 71             using (var db = OpenConnection())
 72             {
 73                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 74                 var result = dal.Page(PageIndex, PageSize, out row, sql);
 75                 return result;
 76             }
 77 
 78         }
 79         public bool Delete(SqlQuery sqlWhere)
 80         {
 81             using (var db = OpenConnection())
 82             {
 83                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 84                 var result = dal.Delete(sqlWhere);
 85                 return result;
 86             }
 87         }
 88         public bool Delete(T model)
 89         {
 90             using (var db = OpenConnection())
 91             {
 92                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
 93                 var result = dal.Delete(model);
 94                 return result;
 95             }
 96         }
 97         public bool DeleteByID(object ID)
 98         {
 99             using (var db = OpenConnection())
100             {
101                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
102                 var result = dal.DeleteByID(ID);
103                 return result;
104             }
105         }
106         public bool DeleteByIds(IEnumerable idValues)
107         {
108             using (var db = OpenConnection())
109             {
110                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
111                 var result = dal.DeleteByIds(idValues);
112                 return result;
113             }
114         }
115         public bool DeleteBatch(List<T> model)
116         {
117             using (var db = OpenConnection())
118             {
119                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
120                 var result = dal.DeleteBatch(model);
121                 return result;
122             }
123         }
124         public bool Update(T Model, SqlQuery sqlWhere = null)
125         {
126             using (var db = OpenConnection())
127             {
128                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
129                 var result = dal.Update(Model, sqlWhere);
130                 return result;
131             }
132         }
133         public bool UpdateAll(List<T> model)
134         {
135             using (var db = OpenConnection())
136             {
137                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
138                 var result = dal.UpdateBatch(model);
139                 return result;
140             }
141         }
142         public long GetCount(SqlQuery sqlWhere = null)
143         {
144             using (var db = OpenConnection())
145             {
146                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
147                 var result = dal.GetCount(sqlWhere);
148                 return result;
149             }
150         }
151         public bool Exists(object ID)
152         {
153             using (var db = OpenConnection())
154             {
155                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
156                 var result = dal.Exists(ID);
157                 return result;
158             }
159         }
160         public IEnumerable<T> Query<T>(string sql, object param = null, CommandType cmdType = CommandType.Text) where T : class
161         {
162             using (var db = OpenConnection())
163             {
164                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
165                 return dal.Query<T>(sql, param, cmdType);
166             }
167         }
168         public int Execute(string sql, object param = null, CommandType cmdType = CommandType.Text)
169         {
170             using (var db = OpenConnection())
171             {
172                 DataAccessBase<T> dal = new DataAccessBase<T>(db);
173                 return dal.Execute(sql, param, cmdType);
174             }
175         }
176       
177     }

BusinessBase.cs

BLLAuto.tt

 1 <#@ template debug="true" hostspecific="true" language="C#"  #>
 2 <#@ output extension=".cs" #>
 3 <#@ assembly name="System.Core"#>
 4 <#@ import namespace="System"#>
 5 <#@ import namespace="System.Collections.Generic"#>
 6 <#@ include file="DBSchema.ttinclude"#>
 7 
 8 using Entity;
 9 using System;
10 using System.Collections.Generic;
11 using System.Linq;
12 using System.Text;
13 using DapperEx;
14 using System.Collections;
15 using System.Data;
16 using DAL;
17 
18 namespace BLL
19 {
20 
21 <# 
22      var dbSchema=DBSchemaFactory.GetDBSchema();
23     List<string> tableList=dbSchema.GetTablesList();
24     foreach(string tableName in tableList)
25     {
26         string Entity=tableName+"Info";
27         string DAL=tableName+"DAL";
28      #>
29     
30     public  partial  class <#=tableName#>BLL : BusinessBase<<#=Entity#>>
31     {
32 
33     }
34 <# } #>
35 }

BLLAuto.tt

噢~~这里一开始少了个Model层，同样，也是写个生成Model的T4模板

ModelAuto.tt

  1 <#@ template debug="true" hostspecific="true" language="C#"  #>
  2 <#@ output extension=".cs" #>
  3 <#@ assembly name="System.Core"#>
  4 <#@ import namespace="System"#>
  5 <#@ import namespace="System.Collections.Generic"#>
  6 <#@ include file="DBSchema.ttinclude"#>
  7 
  8 using System;
  9 using System.Collections.Generic;
 10 using System.Text;
 11 using System.IO;
 12 using System.Runtime.Serialization.Formatters.Binary;
 13 using DapperEx;
 14 
 15 namespace Entity
 16 {
 17 
 18 <#
 19     var dbSchema=DBSchemaFactory.GetDBSchema();
 20     List<string> tableList=dbSchema.GetTablesList();
 21     string Extension="Info";
 22     foreach(string tableName in tableList)
 23     {
 24         Table table=dbSchema.GetTableMetadata(tableName);
 25 #>
 26 
 27     [Serializable]
 28     [TableAttribute(Name = "<#=tableName#>")]
 29      /// <summary>
 30      ///<#=tableName#><#=Extension#><#= table.TableExplain??""#>
 31      /// </summary>
 32     public partial class <#=tableName#><#=Extension#>
 33     {
 34         #region 构造函数
 35         public <#=tableName#><#=Extension#>() { }
 36 
 37         public <#=tableName#><#=Extension#>(<#=table.ColumnTypeNames#>)
 38         {
 39 <#
 40         foreach(Column c in table.Columns)
 41         {
 42 #>
 43             this.<#=c.LowerColumnName#> = <#=c.LowerColumnName#>;
 44 <#
 45         }
 46 #>
 47         }
 48         #endregion
 49 
 50         #region 属性
 51 <#
 52         foreach(Column c in table.Columns)
 53         {
 54 #>
 55 
 56         private <#=GeneratorHelper.GetQuesMarkByType(c.AllowDBNull,c.TypeName)#> <#=c.LowerColumnName#>;
 57 
 58          /// <summary>
 59 <#  
 60             string ColumnExplain="";
 61             if(!String.IsNullOrWhiteSpace(c.ColumnExplain))
 62             {
 63                 string []  ColumnExplains = c.ColumnExplain.Split(new [] {'
', '
'}, StringSplitOptions.RemoveEmptyEntries);
 64                 foreach (var line in ColumnExplains)
 65                 {#>
 66          ///<#=line#>
 67 <#              }
 68             }
 69              #>
 70          /// </summary>
 71 <#
 72             if(c.AutoIncrement)
 73             {#>    
 74         [Id(true)]
 75 <#            }
 76 #>
 77         public <#=GeneratorHelper.GetQuesMarkByType(c.AllowDBNull,c.TypeName)#> <#=c.UpColumnName#>
 78         {
 79             get { return <#=c.LowerColumnName#>; }
 80             set { <#=c.LowerColumnName#> = value; }
 81         }
 82 <#
 83         }
 84 #>
 85         #endregion
 86 
 87         #region 验证
 88         public List<string> ErrorList = new List<string>();
 89         private bool Validator()
 90         {    
 91             bool validatorResult = true;
 92 <#
 93         foreach(Column c in table.Columns)
 94         {
 95             if(!c.AllowDBNull)
 96             {
 97                 if(c.TypeName==GeneratorHelper.StringType)
 98                 {
 99 #>
100             if (string.IsNullOrEmpty(this.<#=c.UpColumnName#>))
101             {
102                 validatorResult = false;
103                 this.ErrorList.Add("The <#=c.UpColumnName#> should not be empty!");
104             }
105 <#
106                 }
107                 if(c.TypeName==GeneratorHelper.DateTimeType)
108                 {
109 #>
110             if (this.<#=c.UpColumnName#>==null)
111             {
112                 validatorResult = false;
113                 this.ErrorList.Add("The <#=c.UpColumnName#> should not be empty!");
114             }
115 <#
116                 }
117             }
118             if(c.TypeName==GeneratorHelper.StringType)
119             {
120 #>
121             if (this.<#=c.UpColumnName#> != null && <#=c.MaxLength#> < this.<#=c.UpColumnName#>.Length)
122             {
123                 validatorResult = false;
124                 this.ErrorList.Add("The length of <#=c.UpColumnName#> should not be greater then <#=c.MaxLength#>!");
125             }
126 <#
127             }
128         }
129 #>
130             return validatorResult;
131         }
132 
133         #endregion
134 
135         #region 辅助方法
136         public  <#=tableName#><#=Extension#> Clone(bool isDeepCopy)
137         {
138             <#=tableName#><#=Extension#>  footman;
139             if (isDeepCopy)
140             {
141                 MemoryStream memoryStream = new MemoryStream();
142                 BinaryFormatter formatter = new BinaryFormatter();
143                 formatter.Serialize(memoryStream, this);
144                 memoryStream.Position = 0;
145                 footman = (<#=tableName#><#=Extension#>)formatter.Deserialize(memoryStream);
146             }
147             else
148             { 
149                 footman = (<#=tableName#><#=Extension#>)this.MemberwiseClone();
150             } 
151             return footman;
152         }
153         #endregion    
154 
155      }
156 
157 <#
158     }
159     dbSchema.Dispose();
160 #>
161 }

ModelAuto.tt

这样基础的框架就算搭好了。表达能力上有点差，所以描述上也有点粗糙，希望路过的朋友们不要见怪。后面会跟同事探讨这个ORM，补充完善再后写一个Demo分享出来给大家。

这里也发下牢骚，吐槽下公司：

人员变动太大了，领导上台1-2个月就下台，换来换去，项目一手接一手，中间都不知道丢了多少......
公司制度不好，就更新一个xml文件，还要跑一天的流程，早上申请更新，快到晚上下班才走完更新流程......（效率上来讲实在太慢了）
忽悠能力强，每次开会老板都会说：大家好好努力，等过阵子带大家去旅游，出去搞个活动，或者聚个餐，只要大家努力，都是有回报的（然后，然后也只是说说而已）
公司是做产品的，算是中小型公司，年底了项目越来越多，旧项目还没维护好，就着急开发新项目
项目时间紧，需求还没做好就开始开发，后面改需求的程度大于前期的开发
天天加班没加班费就算了，人手还不够，几个人同时要搞几个项目，赶时间做出来后面太多BUG要维护不说，代码乱到....（真心担忧这种产品以后的维护）
年底了，还期待天天努力加班最后会不会有点物质上的鼓励，结果是：年终奖也没，年货也没，年会也没 老板一句“今年公司没赚~~”（后面听老同事说，老板每年都是这样说），我能不能大逆不道的说一句”老板太抠了“。
公司发展不明朗：公司后期打算申请上市，可是公司人员变动实在太大，很多项目留下来都没人维护，甚至有部分项目出现代码遗失。自我感觉公司产品还不太完美吧~~~

公司也不是没有好的地方，自我感觉：

　　部门同事团结，遇到问题大家都很热情，一起研究，气氛很不错。很多都会技术相互交流，真的很有团队合作精神。这点是我非常喜欢的

我该不该有换工作的念头：

　　到公司也快一年了，接触了很多的人和事，初进公司，就明显感觉到公司人员的不稳定性，最初在部门的一些老员工都是走到只剩一个（我都快成老员工了...），领导变动性就更不用说，到现在我的领导都换了5个了。一路走来都是M多次加班，M多次去适应每个领导带来的新制度。再累的时候都没想过换工作。但是累，辛苦都不算什么，毕竟每次做完项目都是有一个满足感，加班再多，再辛苦都期待这年底能有点奖金来补充下能量，曾经还怀着” 找一下公司，好好努力，争取力争上流 “的希望，可是差强人意，感觉一切都是想得太好了，是不是每个员工都必须要无私的工作（好吧，我承认我不是好员工，没法做到这么无私）。回去近一年的努力还是有点心寒，突然开始想明年是否应该换工作，不过毕竟才在公司待一年，这样走是不是也不好，而且部门同事的那种一起开发，一起交流的劲还是很值吸引我。之后跟其他同事聊起，有几个同事表示明年回来就想走了，所以目前是属于又想走，又不好意思走的状态。

呵呵，说的有点多了，还是继续学习了，明天晚上估计是加班的前奏~~加油咯！！！（勿喷，勿喷）

查看全文

相关阅读:
winform中Dock的布局规则
 如何为VS添加编写NHibernate配置文件智能提示的功能
 c# winform 给PictureBox控件添上滚动条，使用滚动条来查看图片，panel滚动条
 Nhibernate使用中遇到的问题
 Best gotchas of C++/CLI
关于progressbar
对象序列化
 10个非常不错的CSS技巧
 清除浮动
 Sublime Text2 常用快捷键

原文地址：https://www.cnblogs.com/qtqq/p/4280245.html