七色花基本權限系統（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個事務

 

下一章節將演示，我還沒想好。

 

截止本章節，項目源碼下載：點擊下載（存在百度雲盤中）