七色花基本权限系统（14）- 实现EntityFramework和Dapper的混搭

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暴露出来的主要方法（如查询、执行）”进行封装，其完整代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.Common;

using S.Dapper;
using S.Utilities;

namespace S.Framework.DataCore.Dapper
{
    /// <summary>
    /// 数据Dapper工具
    /// </summary>
    public class DapperContext : IDisposable
    {
        /// <summary>
        /// 数据连接
        /// </summary>
        private IDbConnection dbConnecttion { get; set; }

        /// <summary>
        /// 数据事务
        /// </summary>
        private IDbTransaction dbTransaction { get; set; }

        /// <summary>
        /// 数据管道
        /// </summary>
        private DbProviderFactory dbProviderFactory { get; set; }

        /// <summary>
        /// 持久化行数
        /// </summary>
        public int PersistenceLine = 0;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="connString">连接字符串</param>
        /// <param name="providerName">提供商名称</param>
        public DapperContext(string connString, string providerName)
            : this(DbProviderFactories.GetFactory(providerName),connString)
        {

        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="providerFactory">管道工厂对象</param>
        /// <param name="connString">连接字符串</param>
        public DapperContext(DbProviderFactory providerFactory, string connString)
        {
            this.dbProviderFactory = providerFactory;
            this.dbConnecttion = this.dbProviderFactory.CreateConnection();
            this.dbConnecttion.ConnectionString = connString;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="conn">数据库连接对象</param>
        public DapperContext(DbConnection conn)
        {
            this.dbProviderFactory = DbProviderFactories.GetFactory(conn);
            this.dbConnecttion = conn;
        }

        /// <summary>
        /// 开始事务
        /// </summary>
        public void BeginTransaction()
        {
            this.TryOpenConnection();
            this.BeginTransaction(this.dbConnecttion.BeginTransaction());
        }

        /// <summary>
        /// 设置事务
        /// </summary>
        /// <param name="dbTransaction">事务对象</param>
        public void BeginTransaction(IDbTransaction dbTransaction)
        {
            this.TryOpenConnection();
            this.dbTransaction = dbTransaction;
            this.PersistenceLine = 0;
        }

        /// <summary>
        /// 提交事务
        /// </summary>
        public int Commit()
        {
            if (this.dbTransaction != null)
            {
                this.dbTransaction.Commit();
                this.dbTransaction = null;//Commit之后虽会将事务对象的连接信息清空，但对象本身仍旧存在。为方便外部获取事务对象后判定空，此处清空事务对象。
            }
            int result = this.PersistenceLine;
            this.PersistenceLine = 0;
            return result;
        }

        /// <summary>
        /// 回滚事务
        /// </summary>
        public void Rollback()
        {
            if (this.dbTransaction != null)
            {
                this.dbTransaction.Rollback();
                this.dbTransaction = null;//Rollback之后虽会将事务对象的连接信息清空，但对象本身仍旧存在。为方便外部获取事务对象后判定空，此处清空事务对象。
                this.PersistenceLine = 0;
            }
        }

        /// <summary>
        /// 获取事务对象
        /// </summary>
        /// <returns></returns>
        public DbTransaction GetTransaction()
        {
            return this.dbTransaction as DbTransaction;
        }

        #region 原生函数

        /// <summary>
        /// 根据SQL查询列表
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="sql">SQL</param>
        /// <param name="param">参数</param>
        /// <param name="buffered">是否缓冲</param>
        /// <param name="commandTimeout">超时时间</param>
        /// <returns>查询结果泛型序列</returns>
        public IEnumerable<T> Query<T>(string sql, object param = null, bool buffered = true, int? commandTimeout = null)
        {
            this.TryOpenConnection();
            return this.dbConnecttion.Query<T>(sql, param, this.dbTransaction, buffered, commandTimeout, CommandType.Text);
        }

        /// <summary>
        /// 执行SQL语句
        /// </summary>
        /// <param name="sql">SQL</param>
        /// <param name="param">参数</param>
        /// <param name="commandTimeout">超时时间</param>
        /// <returns>受影响行数</returns>
        public int Execute(string sql, object param = null, int? commandTimeout = null)
        {
            this.TryOpenConnection();
            int result = this.dbConnecttion.Execute(sql, param, this.dbTransaction, commandTimeout, CommandType.Text);
            this.PersistenceLine += result;
            return result;
        }

        /// <summary>
        /// 查询取值
        /// </summary>
        /// <param name="sql">查询字符串</param>
        /// <param name="param">参数</param>
        /// <param name="commandTimeout">超时时间</param>
        /// <returns></returns>
        public object ExecuteScalar(string sql, object param = null, int? commandTimeout = null)
        {
            this.TryOpenConnection();
            return this.dbConnecttion.ExecuteScalar(sql, param, this.dbTransaction, commandTimeout, CommandType.Text);
        }

        /// <summary>
        /// 查询取值
        /// </summary>
        /// <typeparam name="T">返回值类型</typeparam>
        /// <param name="sql">查询字符串</param>
        /// <param name="param">参数</param>
        /// <param name="commandTimeout">超时时间</param>
        /// <returns></returns>
        public T ExecuteScalar<T>(string sql, object param = null, int? commandTimeout = null)
        {
            this.TryOpenConnection();
            return this.dbConnecttion.ExecuteScalar<T>(sql, param, this.dbTransaction, commandTimeout, CommandType.Text);
        }

        /// <summary>
        /// 执行存储过程返回列表
        /// </summary>
        /// <param name="name">存储过程名称</param>
        /// <param name="param">参数</param>
        /// <param name="buffered">是否缓冲</param>
        /// <param name="commandTimeout">超时时间</param>
        /// <returns>查询结果泛型序列</returns>
        public IEnumerable<T> StoredQuery<T>(string name, object param = null, bool buffered = true, int? commandTimeout = null)
        {
            this.TryOpenConnection();
            return this.dbConnecttion.Query<T>(name, param, this.dbTransaction, buffered, commandTimeout, CommandType.StoredProcedure);
        }

        /// <summary>
        /// 存储过程取值
        /// </summary>
        /// <param name="name">存储过程名称</param>
        /// <param name="param">参数</param>
        /// <param name="commandTimeout">超时时间</param>
        /// <returns></returns>
        public object StoredScalar(string name, object param = null, int? commandTimeout = null)
        {
            this.TryOpenConnection();
            return this.dbConnecttion.ExecuteScalar(name, param, this.dbTransaction, commandTimeout, CommandType.StoredProcedure);
        }

        /// <summary>
        /// 存储过程取值
        /// </summary>
        /// <typeparam name="T">返回值类型</typeparam>
        /// <param name="name">存储过程名称</param>
        /// <param name="param">参数</param>
        /// <param name="commandTimeout">超时时间</param>
        /// <returns></returns>
        public T StoredScalar<T>(string name, object param = null, int? commandTimeout = null)
        {
            this.TryOpenConnection();
            return this.dbConnecttion.ExecuteScalar<T>(name, param, this.dbTransaction, commandTimeout, CommandType.StoredProcedure);
        }

        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="name">存储过程名称</param>
        /// <param name="param">参数</param>
        /// <param name="commandTimeout">超时时间</param>
        public void StoredExecute(string name, object param = null, int? commandTimeout = null)
        {
            this.TryOpenConnection();
            this.dbConnecttion.Execute(name, param, this.dbTransaction, commandTimeout, CommandType.StoredProcedure);
        }

        #endregion

        /// <summary>
        /// 尝试打开数据库连接
        /// </summary>
        private void TryOpenConnection()
        {
            if (this.dbConnecttion.State == ConnectionState.Closed)
            {
                try { this.dbConnecttion.Open(); }
                catch (Exception e)
                {
                    throw ExceptionHelper.ThrowDataAccessException("Dapper打开数据库连接时发生异常。", e);
                }
            }
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (dbTransaction != null) { try { dbTransaction.Dispose(); dbTransaction = null; } catch { } }
                if (dbConnecttion != null) { try { dbConnecttion.Dispose(); dbConnecttion = null; } catch { } }
            }
        }

        ~DapperContext() { Dispose(false); }
    }
}

除了暴露Dapper的常用方法之外，还封装了事务相关的方法。这个类可以比较简单，也可以复杂到支持泛型Insert、Update、Delete等操作，但不是本文重点，此处不展开。如果需要暴露更多的Dapper方法，可以在这里添加。

数据实现层 - 工作单元

工作单元是定义数据库上下文的地方，EF的上下文对象就定义在这里，同样也要在此处增加“Dapper上下文”的定义。

这样一来，事务处理要同时考虑EF和Dapper的上下文，释放资源时一样。

开启事务时，仅是设置标记，因为此时上下文对象可能还不存在（初次调用仓储时才会初始化EF上下文），等到初始化上下文（无论是EF还是Dapper）时，再根据事务标记去决定是否需要对上下文开启事务，并保证两个上下文（如果两个上下文都存在）处于同一事务中。

不过需要注意的是，这里的事务是以数据库为单位的。工作单元的事务虽然涵盖所有数据库的事务，但各自独立。

工作单元的主要部分是由T4模板自动生成的，因此上述改动最后都在T4模板中调整，调整后的工作单元模板代码如下：

<#+
// <copyright file="UnitOfWork.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class UnitOfWork : CSharpTemplate
{

    private IEnumerable<string> _prefixNameList;

    public UnitOfWork(IEnumerable<string> prefixNameList)
    {
        this._prefixNameList = prefixNameList;
    }
	public override string TransformText()
	{
		base.TransformText();
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using S.Framework.DataInterface;
using S.Framework.DataInterface.IRepositoryFactories;
using S.Utilities;

namespace S.Framework.DataAchieve.EntityFramework
{
	public partial class UnitOfWork : IUnitOfWork
    {
<#+
            foreach(string item in _prefixNameList)
            {
#>
        #region <#= item #> 的数据库连接字符串、数据库提供程序名称、上下文对象

        /// <summary>
        /// 当前工作单元中 <#= item #>  数据库连接字符串
        /// </summary>
        internal string <#= item #>ConnString { get; private set; }

        /// <summary>
        /// 当前工作单元中 <#= item #> 数据库提供程序名称
        /// </summary>
        internal string <#= item #>ProviderName { get; private set; }

        private System.Data.Entity.DbContext _db<#= item #>;

        private S.Framework.DataCore.Dapper.DapperContext _dapper<#= item #>;

        /// <summary>
        /// 当前工作单元中 <#= item #> 数据库的 EF 上下文
        /// </summary>
        internal System.Data.Entity.DbContext Db<#= item #>
        {
            get
            {
                if (!this.<#= item #>DbIsExist)
                {
                    this._db<#= item #> = new S.Framework.DataCore.EntityFramework.EntityContexts.<#= item #>EntityContext(this.<#= item #>ConnString);
                    if (this.HasTransaction)
                    {
                        if (this.<#= item #>DapperIsExist)
                        {
                            //如果 <#= item #>Dapper 存在
                            var trans = this._dapper<#= item #>.GetTransaction();
                            if (trans != null)
                            {
                                //并且 <#= item #>Dapper 的事务存在，就用 <#= item #>Dapper 的事务作为 <#= item #>Db 的事务
                                this._db<#= item #>.Database.UseTransaction(trans);
                            }
                            else
                            {
                                //否则由 <#= item #>Db 启动事务，并将该事务设置给 <#= item #>Dapper
                                this._db<#= item #>.Database.BeginTransaction();
                                this._dapper<#= item #>.BeginTransaction(this._db<#= item #>.Database.CurrentTransaction.UnderlyingTransaction);
                            }
                        }
                        else
                        {
                            //如果 <#= item #>Dapper 不存在，则由 <#= item #>Db 启动事务
                            if (this._db<#= item #>.Database.CurrentTransaction == null)
                            {
                                this._db<#= item #>.Database.BeginTransaction();
                            }
                        }
                    }
                }
                return this._db<#= item #>;
            }
        }

        /// <summary>
        /// 当前工作单元中 <#= item #> 数据库的 Dapper 上下文
        /// </summary>
        internal S.Framework.DataCore.Dapper.DapperContext Dapper<#= item #>
        {
            get
            {
                if (!this.<#= item #>DapperIsExist)
                {
                    if (this.<#= item #>DbIsExist)
                    {
                        this._dapper<#= item #> = new S.Framework.DataCore.Dapper.DapperContext(this._db<#= item #>.Database.Connection);
                    }
                    else
                    {
                        this._dapper<#= item #> = new S.Framework.DataCore.Dapper.DapperContext(this.<#= item #>ConnString, this.<#= item #>ProviderName);
                    }
                    if (this.HasTransaction)
                    {
                        if (this.<#= item #>DbIsExist)
                        {
                            //如果 <#= item #>Db 存在
                            var trans = this._db<#= item #>.Database.CurrentTransaction;
                            if (trans != null)
                            {
                                //并且 <#= item #>Db 的事务存在，就用 <#= item #>Db 的事务作为 <#= item #>Dapper 的事务
                                this._dapper<#= item #>.BeginTransaction(trans.UnderlyingTransaction);
                            }
                            else
                            {
                                //否则由 <#= item #>Dapper 启动事务，并将该事务设置给 <#= item #>Db
                                this._dapper<#= item #>.BeginTransaction();
                                System.Data.Common.DbTransaction tr = this._dapper<#= item #>.GetTransaction();
                                this._db<#= item #>.Database.UseTransaction(tr);
                            }
                        }
                        else
                        {
                            //如果 <#= item #>Db 不存在，则由 <#= item #>Dapper 启动事务
                            if (this._dapper<#= item #>.GetTransaction() == null)
                            {
                                this._dapper<#= item #>.BeginTransaction();
                            }
                        }
                    }
                }
                return this._dapper<#= item #>;
            }
        }

        /// <summary>
        /// <#= item #> 数据库是否存在 EF 上下文
        /// </summary>
        private bool <#= item #>DbIsExist { get { return this._db<#= item #> != null; } }

        /// <summary>
        /// <#= item #> 数据库是否存在 Dapper 上下文
        /// </summary>
        private bool <#= item #>DapperIsExist { get { return this._dapper<#= item #> != null; } }

        /// <summary>
        /// 是否存在事务
        /// </summary>
        private bool HasTransaction { get; set; }

        #endregion

<#+
            }
#>
        #region 仓储工厂对象

<#+
        foreach(string item in _prefixNameList)
        {
#>
        /// <summary>
        /// <#= item #> 仓储工厂
        /// </summary>
        public I<#= item #>IRepositoryFactory <#= item #>
        {
            get { return GetRepositoryFactoryByInstance<RepositoryFactories.<#= item #>IRepositoryFactory>(); }
        }
<#+
        }
#>

        #endregion

        #region 构造函数

        /// <summary>
        /// 构造函数
        /// <param name="connectionStringNames">数据库连接字符串名称集合，Key表示数据库标识名称，Value表示数据库连接字符串名称</param>
        /// </summary>
        public UnitOfWork(Dictionary<string, string> connectionStringNames)
        {
            if (connectionStringNames.IsNullOrEmpty())
            {
                throw ExceptionHelper.ThrowDataAccessException("初始化工作单元对象时发生异常。", new ArgumentException("数据库连接信息集合参数不可为空。"));
            }
<#+
        foreach(string item in _prefixNameList)
        {
#>
            if (connectionStringNames.ContainsKey("<#= item #>"))
            {
                var name = connectionStringNames["<#= item #>"];
                string connectionString = ConfigHelper.ConnectionString(name);
                string providerName = ConfigHelper.ProviderName(name);

                if (string.IsNullOrWhiteSpace(connectionString) || string.IsNullOrWhiteSpace(providerName))
                { throw ExceptionHelper.ThrowDataAccessException("初始化工作单元对象时发生异常。", new ArgumentException(name + "数据库连接信息有误。")); }

                this.<#= item #>ConnString = connectionString;
                this.<#= item #>ProviderName = providerName;
            }
<#+
        }
#>
        }

        #endregion

        /// <summary>
        /// 以数据库为单位开启事务
        /// </summary>
        public void BeginTransaction()
        {
            this.HasTransaction = true;
        }

        /// <summary>
        /// 提交工作单元
        /// </summary>
        /// <returns>受影响行数</returns>
        public int Commit()
        {
            int result = 0;
<#+
        foreach(string item in _prefixNameList)
        {
#>
            if (this.<#= item #>DbIsExist && this._db<#= item #>.ChangeTracker.HasChanges())
            {
                try
                { result += this._db<#= item #>.SaveChanges(); }
                catch (Exception e)
                {
                    throw ExceptionHelper.ThrowDataAccessException("db<#= item #>执行SaveChange时发生异常。", e);
                }
            }
            if (this.<#= item #>DapperIsExist && this.HasTransaction)
            {
                try
                {
                    result += this._dapper<#= item #>.Commit();
                }
                catch(Exception e){
                    this._dapper<#= item #>.Rollback();
                    result = 0;
                }
            }
            this.HasTransaction = false;
<#+
        }
#>
            return result;
        }

        /// <summary>
        /// 执行回滚事务
        /// </summary>
        public void Rollback()
        {
<#+
        foreach(string item in _prefixNameList)
        {
#>
            if (this.<#= item #>DbIsExist && this._db<#= item #>.ChangeTracker.HasChanges())
            {
                var entities = this._db<#= item #>.ChangeTracker.Entries();
                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))
                {
                    entity.State = System.Data.Entity.EntityState.Detached;
                }
            }
            if (this.<#= item #>DapperIsExist && this.HasTransaction)
            {
                this._dapper<#= item #>.Rollback();
            }
            this.HasTransaction = false;
<#+
        }
#>
        }

        #region 释放资源

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            Dispose(true); GC.SuppressFinalize(this);
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        /// <param name="disposing">是否释放</param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
<#+
        foreach(string item in _prefixNameList)
        {
#>
                if (this.<#= item #>DbIsExist)
                {
                    try
                    {
                        this.Db<#= item #>.Dispose();
                        this._db<#= item #> = null;
                    }
                    catch { }
                }
                if (this.<#= item #>DapperIsExist)
                {
                    try
                    {
                        this.Dapper<#= item #>.Dispose();
                        this._dapper<#= item #> = null;
                    }
                    catch { }
                }
<#+
        }
#>
            }
        }

        #endregion
    }
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

除了“由T4生成的工作单元类”之外，还需在“手动创建的工作单元类”中增加一个方法：

private System.Reflection.PropertyInfo[] _propertiesCache;

/// <summary>
/// 获取指定数据库的 Dapper 上下文
/// </summary>
/// <param name="databaseKey">数据库标记</param>
/// <returns></returns>
internal S.Framework.DataCore.Dapper.DapperContext GetDapperDbContext(string databaseKey)
{
    if (_propertiesCache == null)
    {
        _propertiesCache = this.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
    }
    var the = _propertiesCache.FirstOrDefault(f => f.Name.Contains("Dapper") && f.Name.Contains(databaseKey) && f.PropertyType == typeof(S.Framework.DataCore.Dapper.DapperContext));
    if (the != null)
    {
        S.Framework.DataCore.Dapper.DapperContext db = the.GetMethod.Invoke(this, null) as S.Framework.DataCore.Dapper.DapperContext;
        return db;
    }
    return null;
}

该方法用于实现“让Dapper上下文能够按需初始化”，也就是说调用仓储后自动初始化的仅仅是EF上下文，只有在调用Dapper时才会初始化Dapper上下文。这样就避免了“仅使用EF的情况下也要初始化Dapper”的情况。

数据实现层 - 基本仓储

在前面的实现仓储的章节中，通过“数据库仓储工厂对象”把所属数据库的EF上下文传入基本仓储的方式来确定“基本仓储中的EF上下文是工作单元中的哪个EF上下文（因为工作单元中可能存在多个数据库的EF上下文）”。同样，Dapper上下文也需要“类似但稍有差异”的方式来确定。

先调整基本仓储接口（IBaseRepository），增加方法定义：

/// <summary>
/// 设置数据库标记。设置了编辑器不可见，但只有跨解决方案时才有用。当前解决方案下，还是会被智能提示捕捉到。
/// <param name="key">数据库标记</param>
/// </summary>
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
void SetDatabaseKey(string key);

然后在基本仓储实现（BaseRepository）中，定义数据库标记：

private string DatabaseKey { get; set; }

并实现接口中的SetDatabaseKey方法：

/// <summary>
/// 设置数据库标记
/// </summary>
/// <param name="key">设置数据库标记</param>
public void SetDatabaseKey(string key)
{
    this.DatabaseKey = key;
}

最后实现Dapper上下文：

private S.Framework.DataCore.Dapper.DapperContext _dapperDb;

/// <summary>
/// Dapper数据库上下文，该上下文实现了按需初始化
/// </summary>
private S.Framework.DataCore.Dapper.DapperContext DapperDb
{
    get
    {
        if (this._dapperDb == null)
        {
            this._dapperDb = this.UnitOfWork.GetDapperDbContext(this.DatabaseKey);
        }
        return this._dapperDb;
    }
}

数据实现层 - 仓储工厂

基本仓储中用于设置数据库标记的SetDatabaseKey方法已经准备好，那么在仓储工厂中初始化仓储时需要调用该方法并传递正确的参数。

修改基本仓储工厂（BaseRepositoryFactory）中的获取仓储方法（GetRepositoryByInstance），增加一个string类型的参数，并在调用SetDatabaseKey时传入：

/// <summary>
/// 获取仓储
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="R">仓储接口</typeparam>
/// <param name="db">EF数据库上下文</param>
/// <param name="databaseKey">数据库标记</param>
/// <returns>仓储实例</returns>
protected R GetRepositoryByInstance<TEntity, R>(System.Data.Entity.DbContext db, string databaseKey)
    where TEntity : class
    where R : class, IBaseRepository<TEntity>, new()
{
    if (!repositoryCache.ContainsKey(typeof(TEntity)))
    {
        var repository = new R();
        repository.SetUnitOfWork(this.UnitOfWork);
        repository.SetDataContext(db);
        repository.SetDatabaseKey(databaseKey);

        repositoryCache.Add(typeof(TEntity), repository);

        return repository;
    }
    else { return (R)repositoryCache[typeof(TEntity)]; }
}

再修改仓储工厂模板，调用上述方法时增加传入的参数即可，调整后的模板代码如下：

<#+
// <copyright file="RepositoryFactories.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class RepositoryFactories : CSharpTemplate
{

    private string _prefixName;
    private IEnumerable<Type> _typeList;

    public RepositoryFactories(string prefixName, IEnumerable<Type> typeList)
    {
        this._prefixName = prefixName;
        this._typeList = typeList;
    }

	public override string TransformText()
	{
		base.TransformText();
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using S.Framework.Entity.<#= _prefixName #>;
using S.Framework.DataInterface.IRepositories.<#= _prefixName #>;
using S.Framework.DataInterface.IRepositoryFactories;
using S.Framework.DataAchieve.EntityFramework.Repositories.<#= _prefixName #>;

namespace S.Framework.DataAchieve.EntityFramework.RepositoryFactories
{
    public class <#= _prefixName #>IRepositoryFactory : BaseRepositoryFactory, I<#= _prefixName #>IRepositoryFactory
    {
        private string _databaseKey = "<#= _prefixName #>";

        #region 仓储对象

<#+
        foreach(Type item in _typeList)
        {
#>
        /// <summary>
        /// <#= item.Name #> 仓储接口
        /// </summary>
        public I<#= item.Name #>Repository <#= item.Name #>
        {
            get
            {
                return this.GetRepositoryByInstance<<#= item.Name #>, <#= item.Name #>Repository>(this.UnitOfWork.Db<#= _prefixName #>, this._databaseKey);
            }
        }
<#+
        }
#>

        #endregion
    }
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

到这一步，Dapper上下文已经准备完毕，接下来就要考虑“如何将Dapper上下文暴露给实体仓储”。

EF上下文是通过定义在基本仓储中的Query方法把IQueryable接口来实现暴露的，而没有直接暴露EF上下文对象本身。同样的，如果直接把Dapper上下文暴露出去，那么在实体仓储中将可以使用Dapper上下文内的所有公开成员，但其实Dapper上下文中的部分公开方法是为了在工作单元中更好地结合EF而已，不该全部暴露给实体仓储。并且可能还需要对Dapper上下文的方法进行扩充，所以应该在基本仓储中暴露原始方法并扩充新方法。

在基本仓储实现类（BaseRepository）中，增加以下代码（直接在类中加，不是并列）：

#region Dapper对外公开的方法，为方便区分，用子类隔离

        private DapperIsolate _dapper;

        /// <summary>
        /// Dapper成员封装对象
        /// </summary>
        internal DapperIsolate Dapper
        {
            get
            {
                if (this._dapper == null)
                {
                    this._dapper = new DapperIsolate(this.DapperDb);
                }
                return this._dapper;
            }
        }

        /// <summary>
        /// Dapper隔离类
        /// </summary>
        internal class DapperIsolate
        {
            /// <summary>
            /// Dapper 数据库上下文
            /// </summary>
            private S.Framework.DataCore.Dapper.DapperContext DapperDb { get; set; }

            public DapperIsolate(S.Framework.DataCore.Dapper.DapperContext db)
            {
                this.DapperDb = db;
            }

            /// <summary>
            /// 根据SQL查询列表
            /// </summary>
            /// <typeparam name="T">实体类型</typeparam>
            /// <param name="sql">SQL</param>
            /// <param name="param">参数</param>
            /// <param name="buffered">是否缓冲</param>
            /// <param name="commandTimeout">超时时间</param>
            /// <returns>查询结果泛型序列</returns>
            public IEnumerable<T> Query<T>(string sql, object param = null, bool buffered = true, int? commandTimeout = null)
            {
                return this.DapperDb.Query<T>(sql, param, buffered, commandTimeout);
            }

            /// <summary>
            /// 执行SQL语句
            /// </summary>
            /// <param name="sql">SQL</param>
            /// <param name="param">参数</param>
            /// <param name="commandTimeout">超时时间</param>
            /// <returns>受影响行数</returns>
            public int Execute(string sql, object param = null, int? commandTimeout = null)
            {
                return this.DapperDb.Execute(sql, param, commandTimeout);
            }

            /// <summary>
            /// 查询取值
            /// </summary>
            /// <param name="sql">查询字符串</param>
            /// <param name="param">参数</param>
            /// <param name="commandTimeout">超时时间</param>
            /// <returns></returns>
            public object ExecuteScalar(string sql, object param = null, int? commandTimeout = null)
            {
                return this.DapperDb.ExecuteScalar(sql, param, commandTimeout);
            }

            /// <summary>
            /// 查询取值
            /// </summary>
            /// <typeparam name="T">返回值类型</typeparam>
            /// <param name="sql">查询字符串</param>
            /// <param name="param">参数</param>
            /// <param name="commandTimeout">超时时间</param>
            /// <returns></returns>
            public T ExecuteScalar<T>(string sql, object param = null, int? commandTimeout = null)
            {
                return this.DapperDb.ExecuteScalar<T>(sql, param, commandTimeout);
            }

            /// <summary>
            /// 执行存储过程返回列表
            /// </summary>
            /// <param name="name">存储过程名称</param>
            /// <param name="param">参数</param>
            /// <param name="buffered">是否缓冲</param>
            /// <param name="commandTimeout">超时时间</param>
            /// <returns>查询结果泛型序列</returns>
            public IEnumerable<T> StoredQuery<T>(string name, object param = null, bool buffered = true, int? commandTimeout = null)
            {
                return this.DapperDb.StoredQuery<T>(name, param, buffered, commandTimeout);
            }

            /// <summary>
            /// 存储过程取值
            /// </summary>
            /// <param name="name">存储过程名称</param>
            /// <param name="param">参数</param>
            /// <param name="commandTimeout">超时时间</param>
            /// <returns></returns>
            public object StoredScalar(string name, object param = null, int? commandTimeout = null)
            {
                return this.DapperDb.StoredScalar(name, param, commandTimeout);
            }

            /// <summary>
            /// 存储过程取值
            /// </summary>
            /// <typeparam name="T">返回值类型</typeparam>
            /// <param name="name">存储过程名称</param>
            /// <param name="param">参数</param>
            /// <param name="commandTimeout">超时时间</param>
            /// <returns></returns>
            public T StoredScalar<T>(string name, object param = null, int? commandTimeout = null)
            {
                return this.DapperDb.StoredScalar<T>(name, param, commandTimeout);
            }

            /// <summary>
            /// 执行存储过程
            /// </summary>
            /// <param name="name">存储过程名称</param>
            /// <param name="param">参数</param>
            /// <param name="commandTimeout">超时时间</param>
            public void StoredExecute(string name, object param = null, int? commandTimeout = null)
            {
                this.DapperDb.StoredExecute(name, param, commandTimeout);
            }
        }

#endregion

其中为了隔离EF、Dapper的方法，特地嵌套了一个中间隔离类，使得能够在实体仓储中这样写：

this.Dapper.Query<int>("select ID from table");

此致，混搭完成。

测试效果

把用户仓储（SysUserRepository）中用于登录校验的GetByUserName方法从linq to entity改成通过dapper查询：

/// <summary>
/// 根据用户名获取用户实体
/// </summary>
/// <param name="userName">用户名</param>
/// <returns>用户实体</returns>
public SysUser GetByUserName(string userName)
{
    return this.Dapper.Query<SysUser>("select * from SysUser where UserName = @UserName", new { UserName = userName }).FirstOrDefault();
    //return this.Query(w => w.UserName == userName).FirstOrDefault();
}

编译运行，登录正常，说明Dapper功能有效。

再来检验一下Dapper与EF混搭之后事务的效果。

在用户仓储中写一个以Dapper方式插入用户的方法：

public void TestDapperAdd(SysUser entity)
{
    StringBuilder sb = new StringBuilder();
    sb.Append(" insert SysUser (ID,UserName,Password,IsDisabled,IsDeleted,CreateUser,CreateDate)");
    sb.Append(" Values ");
    sb.Append(" (@ID,@UserName,@Password,@IsDisabled,@IsDeleted,@CreateUser,@CreateDate) ");
    sb.Append(";");

    //传递user对象，dapper会自动解析对象属性名，并取值与sql中的同名参数相对应
    this.Dapper.Execute(sb.ToString(), entity);
}

别忘了在用户仓储接口中定义同方法。

在用户业务类（SysUserBll）中写个测试方法：

public void TestEFDapperTransaction()
{
    using (var unit = IUnitOfWorkFactory.UnitOfWork)
    {
        //开启事务
        //其实 unit 内部只是设置一个标记而已，此时并未初始化任何数据库上下文
        unit.BeginTransaction();

        var u1 = new S.Framework.Entity.Master.SysUser { ID = Guid.NewGuid().ToString(), UserName = "ef", Password = "123456", CreateUser = "admin", CreateDate = DateTime.Now };
        //调用到 SysUser 的仓储，自动初始化 ef 上下文，并开启事务，但不会初始化 dapper 上下文
        unit.Master.SysUser.Add(u1);

        var u2 = new S.Framework.Entity.Master.SysUser { ID = Guid.NewGuid().ToString(), UserName = "dapper", Password = "123456", CreateUser = "admin", CreateDate = DateTime.Now };
        //通过 TestDapperAdd 方法调用到 Dapper 时，自动初始化 dapper 上下文，并获取 ef 上下文的事务对象，设置为 dapper 上下文的事务，这样就保证了共用1个事务
        unit.Master.SysUser.TestDapperAdd(u2);

        //如果不进行 commit，ef 不会插入数据（因为 commit 中才会 SaveChanges ），dapper 也不会插入数据（执行了 sql 但回滚了，说明 dapper 是开启了事务的）
        //如果进行 commit，则 ef 和 dapper 都会插入数据
        //如果需要测试 ef 和 dapper 是否共用1个事务，需要将 unit 中的 Commit 方法中对 dapper.Commit 的代码注释掉，才能测试“EF SaveChanges 之后不对事务 Commit也无法插入数据”。
        unit.Commit();
}

在Home/Index中调用该业务方法，运行一下首页进行测试。

可以发现结果与代码中注释的描述一致。

这个章节比较长，最后回顾一下本章节实现的内容：

1、引入 dapper，封装 dapper 上下文类

2、在工作单元和仓储中实现 dapper 上下文的使用，并实现：

             （1）使 dapper 上下文能够按需初始化

             （2）使 ef 和 dapper 仅在使用时才根据“事务标记”决定是否开启事务

             （3）使 ef 和 dapper 可以共用1个事务

下一章节将演示，我还没想好。

截止本章节，项目源码下载：点击下载（存在百度云盘中）