MyException - 我的异常网
当前位置:我的异常网» ASP.NET » Dapper小型ORM的使用(任意吐槽下公司)

Dapper小型ORM的使用(任意吐槽下公司)

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

公司也不是没有好的地方,自我感觉:

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

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

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

 

呵呵,说的有点多了,还是继续学习了,明天晚上估计是加班的前奏~~加油咯!!!(勿喷,勿喷)

 

1楼『大雪无痕』
楼主是在北京么?,,北京的公司,十个公司八个坑。
Re: 最爱晴天
@『大雪无痕』,不是哦~~北京消费蛮高的,我是广州#183;#183;#183;

文章评论

我的丈夫是个程序员
我的丈夫是个程序员
每天工作4小时的程序员
每天工作4小时的程序员
Java程序员必看电影
Java程序员必看电影
一个程序员的时间管理
一个程序员的时间管理
程序员的一天:一寸光阴一寸金
程序员的一天:一寸光阴一寸金
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
“肮脏的”IT工作排行榜
“肮脏的”IT工作排行榜
程序员都该阅读的书
程序员都该阅读的书
总结2014中国互联网十大段子
总结2014中国互联网十大段子
为啥Android手机总会越用越慢?
为啥Android手机总会越用越慢?
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
旅行,写作,编程
旅行,写作,编程
Web开发人员为什么越来越懒了?
Web开发人员为什么越来越懒了?
2013年中国软件开发者薪资调查报告
2013年中国软件开发者薪资调查报告
程序员和编码员之间的区别
程序员和编码员之间的区别
代码女神横空出世
代码女神横空出世
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
如何成为一名黑客
如何成为一名黑客
亲爱的项目经理,我恨你
亲爱的项目经理,我恨你
我是如何打败拖延症的
我是如何打败拖延症的
团队中“技术大拿”并非越多越好
团队中“技术大拿”并非越多越好
2013年美国开发者薪资调查报告
2013年美国开发者薪资调查报告
老程序员的下场
老程序员的下场
看13位CEO、创始人和高管如何提高工作效率
看13位CEO、创始人和高管如何提高工作效率
“懒”出效率是程序员的美德
“懒”出效率是程序员的美德
 程序员的样子
程序员的样子
要嫁就嫁程序猿—钱多话少死的早
要嫁就嫁程序猿—钱多话少死的早
Java 与 .NET 的平台发展之争
Java 与 .NET 的平台发展之争
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
老美怎么看待阿里赴美上市
老美怎么看待阿里赴美上市
漫画:程序员的工作
漫画:程序员的工作
科技史上最臭名昭著的13大罪犯
科技史上最臭名昭著的13大罪犯
为什么程序员都是夜猫子
为什么程序员都是夜猫子
那些性感的让人尖叫的程序员
那些性感的让人尖叫的程序员
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
10个帮程序员减压放松的网站
10个帮程序员减压放松的网站
10个调试和排错的小建议
10个调试和排错的小建议
编程语言是女人
编程语言是女人
中美印日四国程序员比较
中美印日四国程序员比较
程序员应该关注的一些事儿
程序员应该关注的一些事儿
鲜为人知的编程真相
鲜为人知的编程真相
程序员必看的十大电影
程序员必看的十大电影
程序员的鄙视链
程序员的鄙视链
程序员最害怕的5件事 你中招了吗?
程序员最害怕的5件事 你中招了吗?
不懂技术不要对懂技术的人说这很容易实现
不懂技术不要对懂技术的人说这很容易实现
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
程序员周末都喜欢做什么?
程序员周末都喜欢做什么?
Web开发者需具备的8个好习惯
Web开发者需具备的8个好习惯
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有