Dapper是什么
Dapper是一款轻量级的微ORM，其核心是实现了“将查询结果映射到指定数据模型”，因此可以抛开DataSet、DataTable等数据集对象，以强类型的方式使用查询数据结果。Dapper是开源的，它的GitHub地址在这里：https://github.com/StackExchange/dapper-dot-net，本章节中选择1.4.0版本的Dapper下的.NET45下的核心类，点击下载该核心类：SqlMapper。
为什么要用Dapper来配合EntityFramework使用
EF作为纯粹的ORM，太重，其核心的linq to entity、lambda并不合适进行复杂的查询。那么复杂的查询就交给“能够将查询结果自动映射到指定数据模型”的工具吧，Dapper恰好符合。
EF虽然也暴露了3个执行sql的接口，但比较不方便，对参数的自动识别也没有做处理。Dapper对sql参数的自动识别处理非常棒。
Dapper非常轻量，其本身只有一个SqlMapper类。
Dapper执行速度快，性能高。
支持绝大部分的主流数据库。
Dapper层
Nuget上有Dapper下载，但为了能看源码，还是自己建一个类库来包装Dapper源码更好。
数据核心层
在数据核心层（S.Framework.DataCore）创建Dapper上下文实现类，使核心层支持Dapper，创建结构如下：
DapperContext类是Dapper上下文类（作用类似EF的entityContext），在这个类里将对“Dapper暴露出来的主要方法（如查询、执行）”进行封装，其完整代码如下：
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Threading.Tasks;
6 using System.Data;
7 using System.Data.Common;
8
9 using S.Dapper;
10 using S.Utilities;
11
12 namespace S.Framework.DataCore.Dapper
13 {
14 /// <summary>
15 /// 数据Dapper工具
16 /// </summary>
17 public class DapperContext : IDisposable
18 {
19 /// <summary>
20 /// 数据连接
21 /// </summary>
22 private IDbConnection dbConnecttion { get; set; }
23
24 /// <summary>
25 /// 数据事务
26 /// </summary>
27 private IDbTransaction dbTransaction { get; set; }
28
29 /// <summary>
30 /// 数据管道
31 /// </summary>
32 private DbProviderFactory dbProviderFactory { get; set; }
33
34 /// <summary>
35 /// 持久化行数
36 /// </summary>
37 public int PersistenceLine = 0;
38
39 /// <summary>
40 /// 构造函数
41 /// </summary>
42 /// <param name="connString">连接字符串</param>
43 /// <param name="providerName">提供商名称</param>
44 public DapperContext(string connString, string providerName)
45 : this(DbProviderFactories.GetFactory(providerName),connString)
46 {
47
48 }
49
50 /// <summary>
51 /// 构造函数
52 /// </summary>
53 /// <param name="providerFactory">管道工厂对象</param>
54 /// <param name="connString">连接字符串</param>
55 public DapperContext(DbProviderFactory providerFactory, string connString)
56 {
57 this.dbProviderFactory = providerFactory;
58 this.dbConnecttion = this.dbProviderFactory.CreateConnection();
59 this.dbConnecttion.ConnectionString = connString;
60 }
61
62 /// <summary>
63 /// 构造函数
64 /// </summary>
65 /// <param name="conn">数据库连接对象</param>
66 public DapperContext(DbConnection conn)
67 {
68 this.dbProviderFactory = DbProviderFactories.GetFactory(conn);
69 this.dbConnecttion = conn;
70 }
71
72 /// <summary>
73 /// 开始事务
74 /// </summary>
75 public void BeginTransaction()
76 {
77 this.TryOpenConnection();
78 this.BeginTransaction(this.dbConnecttion.BeginTransaction());
79 }
80
81 /// <summary>
82 /// 设置事务
83 /// </summary>
84 /// <param name="dbTransaction">事务对象</param>
85 public void BeginTransaction(IDbTransaction dbTransaction)
86 {
87 this.TryOpenConnection();
88 this.dbTransaction = dbTransaction;
89 this.PersistenceLine = 0;
90 }
91
92 /// <summary>
93 /// 提交事务
94 /// </summary>
95 public int Commit()
96 {
97 if (this.dbTransaction != null)
98 {
99 this.dbTransaction.Commit();
100 this.dbTransaction = null;//Commit之后虽会将事务对象的连接信息清空，但对象本身仍旧存在。为方便外部获取事务对象后判定空，此处清空事务对象。
101 }
102 int result = this.PersistenceLine;
103 this.PersistenceLine = 0;
104 return result;
105 }
106
107 /// <summary>
108 /// 回滚事务
109 /// </summary>
110 public void Rollback()
111 {
112 if (this.dbTransaction != null)
113 {
114 this.dbTransaction.Rollback();
115 this.dbTransaction = null;//Rollback之后虽会将事务对象的连接信息清空，但对象本身仍旧存在。为方便外部获取事务对象后判定空，此处清空事务对象。
116 this.PersistenceLine = 0;
117 }
118 }
119
120 /// <summary>
121 /// 获取事务对象
122 /// </summary>
123 /// <returns></returns>
124 public DbTransaction GetTransaction()
125 {
126 return this.dbTransaction as DbTransaction;
127 }
128
129 #region 原生函数
130
131 /// <summary>
132 /// 根据SQL查询列表
133 /// </summary>
134 /// <typeparam name="T">实体类型</typeparam>
135 /// <param name="sql">SQL</param>
136 /// <param name="param">参数</param>
137 /// <param name="buffered">是否缓冲</param>
138 /// <param name="commandTimeout">超时时间</param>
139 /// <returns>查询结果泛型序列</returns>
140 public IEnumerable<T> Query<T>(string sql, object param = null, bool buffered = true, int? commandTimeout = null)
141 {
142 this.TryOpenConnection();
143 return this.dbConnecttion.Query<T>(sql, param, this.dbTransaction, buffered, commandTimeout, CommandType.Text);
144 }
145
146 /// <summary>
147 /// 执行SQL语句
148 /// </summary>
149 /// <param name="sql">SQL</param>
150 /// <param name="param">参数</param>
151 /// <param name="commandTimeout">超时时间</param>
152 /// <returns>受影响行数</returns>
153 public int Execute(string sql, object param = null, int? commandTimeout = null)
154 {
155 this.TryOpenConnection();
156 int result = this.dbConnecttion.Execute(sql, param, this.dbTransaction, commandTimeout, CommandType.Text);
157 this.PersistenceLine += result;
158 return result;
159 }
160
161 /// <summary>
162 /// 查询取值
163 /// </summary>
164 /// <param name="sql">查询字符串</param>
165 /// <param name="param">参数</param>
166 /// <param name="commandTimeout">超时时间</param>
167 /// <returns></returns>
168 public object ExecuteScalar(string sql, object param = null, int? commandTimeout = null)
169 {
170 this.TryOpenConnection();
171 return this.dbConnecttion.ExecuteScalar(sql, param, this.dbTransaction, commandTimeout, CommandType.Text);
172 }
173
174 /// <summary>
175 /// 查询取值
176 /// </summary>
177 /// <typeparam name="T">返回值类型</typeparam>
178 /// <param name="sql">查询字符串</param>
179 /// <param name="param">参数</param>
180 /// <param name="commandTimeout">超时时间</param>
181 /// <returns></returns>
182 public T ExecuteScalar<T>(string sql, object param = null, int? commandTimeout = null)
183 {
184 this.TryOpenConnection();
185 return this.dbConnecttion.ExecuteScalar<T>(sql, param, this.dbTransaction, commandTimeout, CommandType.Text);
186 }
187
188 /// <summary>
189 /// 执行存储过程返回列表
190 /// </summary>
191 /// <param name="name">存储过程名称</param>
192 /// <param name="param">参数</param>
193 /// <param name="buffered">是否缓冲</param>
194 /// <param name="commandTimeout">超时时间</param>
195 /// <returns>查询结果泛型序列</returns>
196 public IEnumerable<T> StoredQuery<T>(string name, object param = null, bool buffered = true, int? commandTimeout = null)
197 {
198 this.TryOpenConnection();
199 return this.dbConnecttion.Query<T>(name, param, this.dbTransaction, buffered, commandTimeout, CommandType.StoredProcedure);
200 }
201
202 /// <summary>
203 /// 存储过程取值
204 /// </summary>
205 /// <param name="name">存储过程名称</param>
206 /// <param name="param">参数</param>
207 /// <param name="commandTimeout">超时时间</param>
208 /// <returns></returns>
209 public object StoredScalar(string name, object param = null, int? commandTimeout = null)
210 {
211 this.TryOpenConnection();
212 return this.dbConnecttion.ExecuteScalar(name, param, this.dbTransaction, commandTimeout, CommandType.StoredProcedure);
213 }
214
215 /// <summary>
216 /// 存储过程取值
217 /// </summary>
218 /// <typeparam name="T">返回值类型</typeparam>
219 /// <param name="name">存储过程名称</param>
220 /// <param name="param">参数</param>
221 /// <param name="commandTimeout">超时时间</param>
222 /// <returns></returns>
223 public T StoredScalar<T>(string name, object param = null, int? commandTimeout = null)
224 {
225 this.TryOpenConnection();
226 return this.dbConnecttion.ExecuteScalar<T>(name, param, this.dbTransaction, commandTimeout, CommandType.StoredProcedure);
227 }
228
229 /// <summary>
230 /// 执行存储过程
231 /// </summary>
232 /// <param name="name">存储过程名称</param>
233 /// <param name="param">参数</param>
234 /// <param name="commandTimeout">超时时间</param>
235 public void StoredExecute(string name, object param = null, int? commandTimeout = null)
236 {
237 this.TryOpenConnection();
238 this.dbConnecttion.Execute(name, param, this.dbTransaction, commandTimeout, CommandType.StoredProcedure);
239 }
240
241 #endregion
242
243 /// <summary>
244 /// 尝试打开数据库连接
245 /// </summary>
246 private void TryOpenConnection()
247 {
248 if (this.dbConnecttion.State == ConnectionState.Closed)
249 {
250 try { this.dbConnecttion.Open(); }
251 catch (Exception e)
252 {
253 throw ExceptionHelper.ThrowDataAccessException("Dapper打开数据库连接时发生异常。", e);
254 }
255 }
256 }
257
258 /// <summary>
259 /// 释放资源
260 /// </summary>
261 public void Dispose()
262 {
263 Dispose(true);
264 GC.SuppressFinalize(this);
265 }
266
267 protected virtual void Dispose(bool disposing)
268 {
269 if (disposing)
270 {
271 if (dbTransaction != null) { try { dbTransaction.Dispose(); dbTransaction = null; } catch { } }
272 if (dbConnecttion != null) { try { dbConnecttion.Dispose(); dbConnecttion = null; } catch { } }
273 }
274 }
275
276 ~DapperContext() { Dispose(false); }
277 }
278 }
279
DapperContext类
除了暴露Dapper的常用方法之外，还封装了事务相关的方法。这个类可以比较简单，也可以复杂到支持泛型Insert、Update、Delete等操作，但不是本文重点，此处不展开。如果需要暴露更多的Dapper方法，可以在这里添加。
数据实现层 - 工作单元
工作单元是定义数据库上下文的地方，EF的上下文对象就定义在这里，同样也要在此处增加“Dapper上下文”的定义。
这样一来，事务处理要同时考虑EF和Dapper的上下文，释放资源时一样。
开启事务时，仅是设置标记，因为此时上下文对象可能还不存在（初次调用仓储时才会初始化EF上下文），等到初始化上下文（无论是EF还是Dapper）时，再根据事务标记去决定是否需要对上下文开启事务，并保证两个上下文（如果两个上下文都存在）处于同一事务中。
不过需要注意的是，这里的事务是以数据库为单位的。工作单元的事务虽然涵盖所有数据库的事务，但各自独立。
工作单元的主要部分是由T4模板自动生成的，因此上述改动最后都在T4模板中调整，调整后的工作单元模板代码如下：
1 <#+
2 // <copyright file="UnitOfWork.tt" company="">
3 // Copyright ? . All Rights Reserved.
4 // </copyright>
5
6 public class UnitOfWork : CSharpTemplate
7 {
8
9 private IEnumerable<string> _prefixNameList;
10
11 public UnitOfWork(IEnumerable<string> prefixNameList)
12 {
13 this._prefixNameList = prefixNameList;
14 }
15 public override string TransformText()
16 {
17 base.TransformText();
18 #>
19 using System;
20 using System.Collections.Generic;
21 using System.Linq;
22 using System.Text;
23 using System.Threading.Tasks;
24
25 using S.Framework.DataInterface;
26 using S.Framework.DataInterface.IRepositoryFactories;
27 using S.Utilities;
28
29 namespace S.Framework.DataAchieve.EntityFramework
30 {
31 public partial class UnitOfWork : IUnitOfWork
32 {
33 <#+
34 foreach(string item in _prefixNameList)
35 {
36 #>
37 #region <#= item #> 的数据库连接字符串、数据库提供程序名称、上下文对象
38
39 /// <summary>
40 /// 当前工作单元中 <#= item #> 数据库连接字符串
41 /// </summary>
42 internal string <#= item #>ConnString { get; private set; }
43
44 /// <summary>
45 /// 当前工作单元中 <#= item #> 数据库提供程序名称
46 /// </summary>
47 internal string <#= item #>ProviderName { get; private set; }
48
49 private System.Data.Entity.DbContext _db<#= item #>;
50
51 private S.Framework.DataCore.Dapper.DapperContext _dapper<#= item #>;
52
53 /// <summary>
54 /// 当前工作单元中 <#= item #> 数据库的 EF 上下文
55 /// </summary>
56 internal System.Data.Entity.DbContext Db<#= item #>
57 {
58 get
59 {
60 if (!this.<#= item #>DbIsExist)
61 {
62 this._db<#= item #> = new S.Framework.DataCore.EntityFramework.EntityContexts.<#= item #>EntityContext(this.<#= item #>ConnString);
63 if (this.HasTransaction)
64 {
65 if (this.<#= item #>DapperIsExist)
66 {
67 //如果 <#= item #>Dapper 存在
68 var trans = this._dapper<#= item #>.GetTransaction();
69 if (trans != null)
70 {
71 //并且 <#= item #>Dapper 的事务存在，就用 <#= item #>Dapper 的事务作为 <#= item #>Db 的事务
72 this._db<#= item #>.Database.UseTransaction(trans);
73 }
74 else
75 {
76 //否则由 <#= item #>Db 启动事务，并将该事务设置给 <#= item #>Dapper
77 this._db<#= item #>.Database.BeginTransaction();
78 this._dapper<#= item #>.BeginTransaction(this._db<#= item #>.Database.CurrentTransaction.UnderlyingTransaction);
79 }
80 }
81 else
82 {
83 //如果 <#= item #>Dapper 不存在，则由 <#= item #>Db 启动事务
84 if (this._db<#= item #>.Database.CurrentTransaction == null)
85 {
86 this._db<#= item #>.Database.BeginTransaction();
87 }
88 }
89 }
90 }
91 return this._db<#= item #>;
92 }
93 }
94
95 /// <summary>
96 /// 当前工作单元中 <#= item #> 数据库的 Dapper 上下文
97 /// </summary>
98 internal S.Framework.DataCore.Dapper.DapperContext Dapper<#= item #>
99 {
100 get
101 {
102 if (!this.<#= item #>DapperIsExist)
103 {
104 if (this.<#= item #>DbIsExist)
105 {
106 this._dapper<#= item #> = new S.Framework.DataCore.Dapper.DapperContext(this._db<#= item #>.Database.Connection);
107 }
108 else
109 {
110 this._dapper<#= item #> = new S.Framework.DataCore.Dapper.DapperContext(this.<#= item #>ConnString, this.<#= item #>ProviderName);
111 }
112 if (this.HasTransaction)
113 {
114 if (this.<#= item #>DbIsExist)
115 {
116 //如果 <#= item #>Db 存在
117 var trans = this._db<#= item #>.Database.CurrentTransaction;
118 if (trans != null)
119 {
120 //并且 <#= item #>Db 的事务存在，就用 <#= item #>Db 的事务作为 <#= item #>Dapper 的事务
121 this._dapper<#= item #>.BeginTransaction(trans.UnderlyingTransaction);
122 }
123 else
124 {
125 //否则由 <#= item #>Dapper 启动事务，并将该事务设置给 <#= item #>Db
126 this._dapper<#= item #>.BeginTransaction();
127 System.Data.Common.DbTransaction tr = this._dapper<#= item #>.GetTransaction();
128 this._db<#= item #>.Database.UseTransaction(tr);
129 }
130 }
131 else
132 {
133 //如果 <#= item #>Db 不存在，则由 <#= item #>Dapper 启动事务
134 if (this._dapper<#= item #>.GetTransaction() == null)
135 {
136 this._dapper<#= item #>.BeginTransaction();
137 }
138 }
139 }
140 }
141 return this._dapper<#= item #>;
142 }
143 }
144
145 /// <summary>
146 /// <#= item #> 数据库是否存在 EF 上下文
147 /// </summary>
148 private bool <#= item #>DbIsExist { get { return this._db<#= item #> != null; } }
149
150 /// <summary>
151 /// <#= item #> 数据库是否存在 Dapper 上下文
152 /// </summary>
153 private bool <#= item #>DapperIsExist { get { return this._dapper<#= item #> != null; } }
154
155 /// <summary>
156 /// 是否存在事务
157 /// </summary>
158 private bool HasTransaction { get; set; }
159
160 #endregion
161
162 <#+
163 }
164 #>
165 #region 仓储工厂对象
166
167 <#+
168 foreach(string item in _prefixNameList)
169 {
170 #>
171 /// <summary>
172 /// <#= item #> 仓储工厂
173 /// </summary>
174 public I<#= item #>IRepositoryFactory <#= item #>
175 {
176 get { return GetRepositoryFactoryByInstance<RepositoryFactories.<#= item #>IRepositoryFactory>(); }
177 }
178 <#+
179 }
180 #>
181
182 #endregion
183
184 #region 构造函数
185
186 /// <summary>
187 /// 构造函数
188 /// <param name="connectionStringNames">数据库连接字符串名称集合，Key表示数据库标识名称，Value表示数据库连接字符串名称</param>
189 /// </summary>
190 public UnitOfWork(Dictionary<string, string> connectionStringNames)
191 {
192 if (connectionStringNames.IsNullOrEmpty())
193 {
194 throw ExceptionHelper.ThrowDataAccessException("初始化工作单元对象时发生异常。", new ArgumentException("数据库连接信息集合参数不可为空。"));
195 }
196 <#+
197 foreach(string item in _prefixNameList)
198 {
199 #>
200 if (connectionStringNames.ContainsKey("<#= item #>"))
201 {
202 var name = connectionStringNames["<#= item #>"];
203 string connectionString = ConfigHelper.ConnectionString(name);
204 string providerName = ConfigHelper.ProviderName(name);
205
206 if (string.IsNullOrWhiteSpace(connectionString) || string.IsNullOrWhiteSpace(providerName))
207 { throw ExceptionHelper.ThrowDataAccessException("初始化工作单元对象时发生异常。", new ArgumentException(name + "数据库连接信息有误。")); }
208
209 this.<#= item #>ConnString = connectionString;
210 this.<#= item #>ProviderName = providerName;
211 }
212 <#+
213 }
214 #>
215 }
216
217 #endregion
218
219 /// <summary>
220 /// 以数据库为单位开启事务
221 /// </summary>
222 public void BeginTransaction()
223 {
224 this.HasTransaction = true;
225 }
226
227 /// <summary>
228 /// 提交工作单元
229 /// </summary>
230 /// <returns>受影响行数</returns>
231 public int Commit()
232 {
233 int result = 0;
234 <#+
235 foreach(string item in _prefixNameList)
236 {
237 #>
238 if (this.<#= item #>DbIsExist && this._db<#= item #>.ChangeTracker.HasChanges())
239 {
240 try
241 { result += this._db<#= item #>.SaveChanges(); }
242 catch (Exception e)
243 {
244 throw ExceptionHelper.ThrowDataAccessException("db<#= item #>执行SaveChange时发生异常。", e);
245 }
246 }
247 if (this.<#= item #>DapperIsExist && this.HasTransaction)
248 {
249 try
250 {
251 result += this._dapper<#= item #>.Commit();
252 }
253 catch(Exception e){
254 this._dapper<#= item #>.Rollback();
255 result = 0;
256 }
257 }
258 this.HasTransaction = false;
259 <#+
260 }
261 #>
262 return result;
263 }
264
265 /// <summary>
266 /// 执行回滚事务
267 /// </summary>
268 public void Rollback()
269 {
270 <#+
271 foreach(string item in _prefixNameList)
272 {
273 #>
274 if (this.<#= item #>DbIsExist && this._db<#= item #>.ChangeTracker.HasChanges())
275 {
276 var entities = this._db<#= item #>.ChangeTracker.Entries();
277 foreach (var entity in entities.Where(e => e.State == System.Data.Entity.EntityState.Added || e.State == System.Data.Entity.EntityState.Modified || e.State == System.Data.Entity.EntityState.Deleted))
278 {
279 entity.State = System.Data.Entity.EntityState.Detached;
280 }
281 }
282 if (this.<#= item #>DapperIsExist && this.HasTransaction)
283 {
284 this._dapper<#= item #>.Rollback();
285 }
286 this.HasTransaction = false;
287 <#+
288 }
289 #>
290 }
291
292 #region 释放资源
293
294 /// <summary>
295 /// 释放资源
296 /// </summary>
297 public void Dispose()
298 {
299 Dispose(true); GC.SuppressFinalize(this);
300 }
301
302 /// <summary>
303 /// 释放资源
304 /// </summary>
305 /// <param name="disposing">是否释放</param>
306 protected virtual void Dispose(bool disposing)
307 {
308 if (disposing)
309 {
310 <#+
311 foreach(string item in _prefixNameList)
312 {
313 #>
314 if (this.<#= item #>DbIsExist)
315 {
316 try
317 {
318 this.Db<#= item #>.Dispose();
319 this._db<#= item #> = null;
320 }
321 catch { }
322 }
323 if (this.<#= item #>DapperIsExist)
324 {
325 try
326 {
327 this.Dapper<#= item #>.Dispose();
328 this._dapper<#= item #> = null;
329 }
330 catch { }
331 }
332 <#+
333 }
334 #>
335 }
336 }
337
338 #endregion
339 }
340 }
341 <#+
342 return this.GenerationEnvironment.ToString();
343 }
344 }
345 #>
346
调整后的工作单元模板
除了“由T4生成的工作单元类”之外，还需在“手动创建的工作单元类”中增加一个方法：
1 private System.Reflection.PropertyInfo[] _propertiesCache;
2
3 /// <summary>
4 /// 获取指定数据库的 Dapper 上下文
5 /// </summary>
6 /// <param name="databaseKey">数据库标记</param>
7 /// <returns></returns>
8 internal S.Framework.DataCore.Dapper.DapperContext GetDapperDbContext(string databaseKey)
9 {
10 if (_propertiesCache == null)
11 {
12 _propertiesCache = this.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
13 }
14 var the = _propertiesCache.FirstOrDefault(f => f.Name.Contains("Dapper") && f.Name.Contains(databaseKey) && f.PropertyType == typeof(S.Framework.DataCore.Dapper.DapperContext));
15 if (the != null)
16 {
17 S.Framework.DataCore.Dapper.DapperContext db = the.GetMethod.Invoke(this, null) as S.Framework.DataCore.Dapper.DapperContext;
18 return db;
19 }
20 return null;
21 }
该方法用于实现“让Dapper上下文能够按需初始化”，也就是说调用仓储后自动初始化的仅仅是EF上下文，只有在调用Dapper时才会初始化Dapper上下文。这样就避免了“仅使用EF的情况下也要初始化Dapper”的情况。
数据实现层 - 基本仓储
在前面的实现仓储的章节中，通过“数据库仓储工厂对象”把所属数据库的EF上下文传入基本仓储的方式来确定“基本仓储中的EF上下文是工作单元中的哪个EF上下文（因为工作单元中可能存在多个数据库的EF上下文）”。同样，Dapper上下文也需要“类似但稍有差异”的方式来确定。
先调整基本仓储接口（IBaseRepository），增加方法定义：
1 /// <summary> 2 /// 设置数据库标记。设置了编辑器不可见，但只有跨解决方案时才有用。当前解决方案下，还是会被智能提示捕捉到。 3 /// <param name="key">数据库标记</param> 4 /// </summary> 5 [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 6 void SetDatabaseKey(string key);
然后在基本仓储实现（BaseRepository）中，定义数据库标记：
1 private string DatabaseKey { get; set; }
并实现接口中的SetDatabaseKey方法：
1 /// <summary>
2 /// 设置数据库标记
3 /// </summary>
4 /// <param name="key">设置数据库标记</param>
5 public void SetDatabaseKey(string key)
6 {
7 this.DatabaseKey = key;
8 }
最后实现Dapper上下文：
1 private S.Framework.DataCore.Dapper.DapperContext _dapperDb;
2
3 /// <summary>
4 /// Dapper数据库上下文，该上下文实现了按需初始化
5 /// </summary>
6 private S.Framework.DataCore.Dapper.DapperContext DapperDb
7 {
8 get
9 {
10 if (this._dapperDb == null)
11 {
12 this._dapperDb = this.UnitOfWork.GetDapperDbContext(this.DatabaseKey);
13 }
14 return this._dapperDb;
15 }
16 }
数据实现层 - 仓储工厂
基本仓储中用于设置数据库标记的SetDatabaseKey方法已经准备好，那么在仓储工厂中初始化仓储时需要调用该方法并传递正确的参数。
修改基本仓储工厂（BaseRepositoryFactory）中的获取仓储方法（GetRepositoryByInstance），增加一个string类型的参数，并在调用SetDatabaseKey时传入：
1 /// <summary>
2 /// 获取仓储
3 /// </summary>
4 /// <typeparam name="TEntity">实体类型</typeparam>
5 /// <typeparam name="R">仓储接口</typeparam>
6 /// <param name="db">EF数据库上下文</param>
7 /// <param name="databaseKey">数据库标记</param>
8 /// <returns>仓储实例</returns>
9 protected R GetRepositoryByInstance<TEntity, R>(System.Data.Entity.DbContext db, string databaseKey)
10 where TEntity : class
11 where R : class, IBaseRepository<TEntity>, new()
12 {
13 if (!repositoryCache.ContainsKey(typeof(TEntity)))
14 {
15 var repository = new R();
16 repository.SetUnitOfWork(this.UnitOfWork);
17 repository.SetDataContext(db);
18 repository.SetDatabaseKey(databaseKey);
19
20 repositoryCache.Add(typeof(TEntity), repository);
21
22 return repository;
23 }
24 else { return (R)repositoryCache[typeof(TEntity)]; }
25 }
再修改仓储工厂模板，调用上述方法时增加传入的参数即可，调整后的模板代码如下：
1 <#+
2 // <copyright file="RepositoryFactories.tt" company="">
3 // Copyright ? . All Rights Reserved.
4 // </copyright>
5
6 public class RepositoryFactories : CSharpTemplate
7 {
8
9 private string _prefixName;
10 private IEnumerable<Type> _typeList;
11
12 public RepositoryFactories(string prefixName, IEnumerable<Type> typeList)
13 {
14 this._prefixName = prefixName;
15 this._typeList = typeList;
16 }
17
18 public override string TransformText()
19 {
20 base.TransformText();
21 #>
22 using System;
23 using System.Collections.Generic;
24 using System.Linq;
25 using System.Text;
26 using System.Threading.Tasks;
27
28 using S.Framework.Entity.<#= _prefixName #>;
29 using S.Framework.DataInterface.IRepositories.<#= _prefixName #>;
30 using S.Framework.DataInterface.IRepositoryFactories;
31 using S.Framework.DataAchieve.EntityFramework.Repositories.<#= _prefixName #>;
32
33 namespace S.Framework.DataAchieve.EntityFramework.RepositoryFactories
34 {
35 public class <#= _prefixName #>IRepositoryFactory : BaseRepositoryFactory, I<#= _prefixName #>IRepositoryFactory
36 {
37 private string _databaseKey = "<#= _prefixName #>";
38
39 #region 仓储对象
40
41 <#+
42 foreach(Type item in _typeList)
43 {
44 #>
45 /// <summary>
46 /// <#= item.Name #> 仓储接口
47 /// </summary>
48 public I<#= item.Name #>Repository <#= item.Name #>
49 {
50 get
51 {
52 return this.GetRepositoryByInstance<<#= item.Name #>, <#= item.Name #>Repository>(this.UnitOfWork.Db<#= _prefixName #>, this._databaseKey);
53 }
54 }
55 <#+
56 }
57 #>
58
59 #endregion
60 }
61 }
62 <#+
63 return this.GenerationEnvironment.ToString();
64 }
65 }
66 #>
67
调整后的仓储工厂模板
到这一步，Dapper上下文已经准备完毕，接下来就要考虑“如何将Dapper上下文暴露给实体仓储”。
EF上下文是通过定义在基本仓储中的Query方法把IQueryable接口来实现暴露的，而没有直接暴露EF上下文对象本身。同样的，如果直接把Dapper上下文暴露出去，那么在实体仓储中将可以使用Dapper上下文内的所有公开成员，但其实Dapper上下文中的部分公开方法是为了在工作单元中更好地结合EF而已，不该全部暴露给实体仓储。并且可能还需要对Dapper上下文的方法进行扩充，所以应该在基本仓储中暴露原始方法并扩充新方法。
在基本仓储实现类（BaseRepository）中，增加以下代码（直接在类中加，不是并列）：
1 #region Dapper对外公开的方法，为方便区分，用子类隔离
2
3 private DapperIsolate _dapper;
4
5 /// <summary>
6 /// Dapper成员封装对象
7 /// </summary>
8 internal DapperIsolate Dapper
9 {
10 get
11 {
12 if (this._dapper == null)
13 {
14 this._dapper = new DapperIsolate(this.DapperDb);
15 }
16 return this._dapper;
17 }
18 }
19
20 /// <summary>
21 /// Dapper隔离类
22 /// </summary>
23 internal class DapperIsolate
24 {
25 /// <summary>
26 /// Dapper 数据库上下文
27 /// </summary>
28 private S.Framework.DataCore.Dapper.DapperContext DapperDb { get; set; }
29
30 public DapperIsolate(S.Framework.DataCore.Dapper.DapperContext db)
31 {
32 this.DapperDb = db;
33 }
34
35 /// <summary>
36 /// 根据SQL查询列表
37 /// </summary>
38 /// <typeparam name="T">实体类型</typeparam>
39 /// <param name="sql">SQL</param>
40 /// <param name="param">参数</param>
41 /// <param name="buffered">是否缓冲</param>
42 /// <param name="commandTimeout">超时时间</param>
43 /// <returns>查询结果泛型序列</returns>
44 public IEnumerable<T> Query<T>(string sql, object param = null, bool buffered = true, int? commandTimeout = null)
45 {
46 return this.DapperDb.Query<T>(sql, param, buffered, commandTimeout);
47 }
48
49 /// <summary>
50 /// 执行SQL语句
51 /// </summary>
52 /// <param name="sql">SQL</param>
53 /// <param name="param">参数</param>
54 /// <param name="commandTimeout">超时时间</param>
55 /// <returns>受影响行数</returns>
56 public int Execute(string sql, object param = null, int? commandTimeout = null)
57 {
58 return this.DapperDb.Execute(sql, param, commandTimeout);
59 }
60
61 /// <summary>
62 /// 查询取值
63 /// </summary>
64 /// <param name="sql">查询字符串</param>
65 /// <param name="param">参数</param>
66 /// <param name="commandTimeout">超时时间</param>
67 /// <returns></returns>
68 public object ExecuteScalar(string sql, object param = null, int? commandTimeout = null)
69 {
70 return this.DapperDb.ExecuteScalar(sql, param, commandTimeout);
71 }
72
73 /// <summary>
74 /// 查询取值
75 /// </summary>
76 /// <typeparam name="T">返回值类型</typeparam>
77 /// <param name="sql">查询字符串</param>
78 /// <param name="param">参数</param>
79 /// <param name="commandTimeout">超时时间</param>
80 /// <returns></returns>
81 public T ExecuteScalar<T>(string sql, object param = null, int? commandTimeout = null)
82 {
83 return this.DapperDb.ExecuteScalar<T>(sql, param, commandTimeout);
84 }
85
86 /// <summary>
87 /// 执行存储过程返回列表
88 /// </summary>
89 /// <param name="name">存储过程名称</param>
90 /// <param name="param">参数</param>
91 /// <param name="buffered">是否缓冲</param>
92 /// <param name="commandTimeout">超时时间</param>
93 /// <returns>查询结果泛型序列</returns>
94 public IEnumerable<T> StoredQuery<T>(string name, object param = null, bool buffered = true, int? commandTimeout = null)
95 {
96 return this.DapperDb.StoredQuery<T>(name, param, buffered, commandTimeout);
97 }
98
99 /// <summary>
100 /// 存储过程取值
101 /// </summary>
102 /// <param name="name">存储过程名称</param>
103 /// <param name="param">参数</param>
104 /// <param name="commandTimeout">超时时间</param>
105 /// <returns></returns>
106 public object StoredScalar(string name, object param = null, int? commandTimeout = null)
107 {
108 return this.DapperDb.StoredScalar(name, param, commandTimeout);
109 }
110
111 /// <summary>
112 /// 存储过程取值
113 /// </summary>
114 /// <typeparam name="T">返回值类型</typeparam>
115 /// <param name="name">存储过程名称</param>
116 /// <param name="param">参数</param>
117 /// <param name="commandTimeout">超时时间</param>
118 /// <returns></returns>
119 public T StoredScalar<T>(string name, object param = null, int? commandTimeout = null)
120 {
121 return this.DapperDb.StoredScalar<T>(name, param, commandTimeout);
122 }
123
124 /// <summary>
125 /// 执行存储过程
126 /// </summary>
127 /// <param name="name">存储过程名称</param>
128 /// <param name="param">参数</param>
129 /// <param name="commandTimeout">超时时间</param>
130 public void StoredExecute(string name, object param = null, int? commandTimeout = null)
131 {
132 this.DapperDb.StoredExecute(name, param, commandTimeout);
133 }
134 }
135
136 #endregion
在BaseRepository中的Dapper封装
其中为了隔离EF、Dapper的方法，特地嵌套了一个中间隔离类，使得能够在实体仓储中这样写：
1 this.Dapper.Query<int>("select ID from table");
此致，混搭完成。
测试效果
把用户仓储（SysUserRepository）中用于登录校验的GetByUserName方法从linq to entity改成通过dapper查询：
1 /// <summary>
2 /// 根据用户名获取用户实体
3 /// </summary>
4 /// <param name="userName">用户名</param>
5 /// <returns>用户实体</returns>
6 public SysUser GetByUserName(string userName)
7 {
8 return this.Dapper.Query<SysUser>("select * from SysUser where UserName = @UserName", new { UserName = userName }).FirstOrDefault();
9 //return this.Query(w => w.UserName == userName).FirstOrDefault();
10 }
编译运行，登录正常，说明Dapper功能有效。
再来检验一下Dapper与EF混搭之后事务的效果。
在用户仓储中写一个以Dapper方式插入用户的方法：
1 public void TestDapperAdd(SysUser entity)
2 {
3 StringBuilder sb = new StringBuilder();
4 sb.Append(" insert SysUser (ID,UserName,Password,IsDisabled,IsDeleted,CreateUser,CreateDate)");
5 sb.Append(" Values ");
6 sb.Append(" (@ID,@UserName,@Password,@IsDisabled,@IsDeleted,@CreateUser,@CreateDate) ");
7 sb.Append(";");
8
9 //传递user对象，dapper会自动解析对象属性名，并取值与sql中的同名参数相对应
10 this.Dapper.Execute(sb.ToString(), entity);
11 }
别忘了在用户仓储接口中定义同方法。
在用户业务类（SysUserBll）中写个测试方法：
1 public void TestEFDapperTransaction()
2 {
3 using (var unit = IUnitOfWorkFactory.UnitOfWork)
4 {
5 //开启事务
6 //其实 unit 内部只是设置一个标记而已，此时并未初始化任何数据库上下文
7 unit.BeginTransaction();
8
9 var u1 = new S.Framework.Entity.Master.SysUser { ID = Guid.NewGuid().ToString(), UserName = "ef", Password = "123456", CreateUser = "admin", CreateDate = DateTime.Now };
10 //调用到 SysUser 的仓储，自动初始化 ef 上下文，并开启事务，但不会初始化 dapper 上下文
11 unit.Master.SysUser.Add(u1);
12
13 var u2 = new S.Framework.Entity.Master.SysUser { ID = Guid.NewGuid().ToString(), UserName = "dapper", Password = "123456", CreateUser = "admin", CreateDate = DateTime.Now };
14 //通过 TestDapperAdd 方法调用到 Dapper 时，自动初始化 dapper 上下文，并获取 ef 上下文的事务对象，设置为 dapper 上下文的事务，这样就保证了共用1个事务
15 unit.Master.SysUser.TestDapperAdd(u2);
16
17 //如果不进行 commit，ef 不会插入数据（因为 commit 中才会 SaveChanges ），dapper 也不会插入数据（执行了 sql 但回滚了，说明 dapper 是开启了事务的）
18 //如果进行 commit，则 ef 和 dapper 都会插入数据
19 //如果需要测试 ef 和 dapper 是否共用1个事务，需要将 unit 中的 Commit 方法中对 dapper.Commit 的代码注释掉，才能测试“EF SaveChanges 之后不对事务 Commit也无法插入数据”。
20 unit.Commit();
21 }
在Home/Index中调用该业务方法，运行一下首页进行测试。
可以发现结果与代码中注释的描述一致。
这个章节比较长，最后回顾一下本章节实现的内容：
1、引入 dapper，封装 dapper 上下文类
2、在工作单元和仓储中实现 dapper 上下文的使用，并实现：
（1）使 dapper 上下文能够按需初始化
（2）使 ef 和 dapper 仅在使用时才根据“事务标记”决定是否开启事务
（3）使 ef 和 dapper 可以共用1个事务
下一章节将演示，我还没想好。
时间： 2024-10-11 16:14:26