Asp.net 面向介面可擴展框架之數據處理模塊及EntityFramework擴展和Dapper擴展(含乾貨)

介面數據處理模塊是什麼意思呢？實際上很簡單,就是使用面向介面的思想和方式來做數據處理。

還提到EntityFramework和Dapper,EntityFramework和Dapper是.net環境下推崇最高的兩種ORM工具。

1、EntityFramework是出自微軟根正苗紅的.net下的ORM工具,直接在Vs工具和Mvc框架中集成了,預設生成的項目就是使用EntityFramework的;微軟也一直都在維護更新升級,最新版本都到EF7了。也遷移到了最新的.net Core平臺了。

2、Dapper也是個厲害的角色。號稱.net下"無敵",速度最快

但是他們兩個開發方式完全不一樣,個人認為EntityFramework是基於領域模型的,Dapper是基於sql的

註:我以前沒用Dapper做過項目。之前一直討厭Dapper,對赤裸裸的sql有很大成見,原因一程式員去直接寫sql搞不好就會導致sql註入風險,原因二我認為程式員應該花精力琢磨邏輯如何寫,而不是和DBA比寫sql的功底

註:EntityFramework我也用的少,我主導的項目都是用我自己開發的ORM工具,維護別人的項目經常碰到EntityFramework生成複雜到不可理喻的sql,而且EntityFramework幾乎不能在一個項目中分庫分表讀寫分離操作(這個問題已經解決，後面會講到)

現在要做的就是讓ORM工具(含EntityFramework和Dapper)以面向介面的方式工作,"屏蔽"掉一些個性化的差異

一、面向介面數據處理模塊

面向介面數據處理模塊很簡單,就是一堆數據處理的介面,像數據倉儲介面。有了它們幾乎所有數據倉儲都不用再定義新介面了,主要的核心介面全部公佈如下:

    /// <summary>
    /// 實體泛型主鍵介面
    /// </summary>
    /// <typeparam name="TPrimaryKey"></typeparam>
    public interface IEntity<TPrimaryKey> : IEntity
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        TPrimaryKey Id { get; set; }
    }
    /// <summary>
    /// 實體介面
    /// </summary>
    public interface IEntity
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        object ObjId { get; }
    }

註:主鍵是泛型(TPrimaryKey),意味著支持任意類型的主鍵,而不是簡單粗暴的只支持int或者guid,當然也就支持複合主鍵了

    /// <summary>

    /// 泛型添加
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public interface IEntityAdd<in TEntity>
    {
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        object Add(TEntity obj);
    }

    /// <summary>
    /// 泛型刪除
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public interface IEntityDel<in TEntity>
    {
        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        bool Del(TEntity obj);
    }
}

    /// <summary>
    /// 按主鍵刪除
    /// </summary>
    /// <typeparam name="TPrimaryKey"></typeparam>
    public interface IEntityKeyDel<TPrimaryKey>
    {
        /// <summary>
        /// 按主鍵刪除
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        bool Del(TPrimaryKey key);
    }

    /// <summary>
    /// 泛型修改
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public interface IEntityUpdate<in TEntity>
    {
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        bool Update(TEntity obj);
    }

    /// <summary>
    /// 泛型獲取列表數據
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public interface IEntityList<TEntity>
    {
        /// <summary>
        /// 獲取所有數據
        /// </summary>
        /// <returns></returns>
        IEnumerable<TEntity> ListAll();
    }

    /// <summary>
    /// 獲取數據條數
    /// </summary>
    public interface ICount
    {
        /// <summary>
        /// 獲取數據條數
        /// </summary>
        /// <returns></returns>
        int Count();
    }

    /// <summary>
    /// 泛型查看
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public interface IEntityView<TEntity>
    {
        /// <summary>
        /// 查看
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        TEntity View(TEntity obj);
    }

    /// <summary>
    /// 泛型查主鍵看
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <typeparam name="TPrimaryKey"></typeparam>
    public interface IEntityKeyView<TEntity, TPrimaryKey>
        where TEntity : IEntity<TPrimaryKey>
    {
        /// <summary>
        /// 按主鍵獲取
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        TEntity View(TPrimaryKey key);
    }

    /// <summary>
    /// 數據操作倉儲介面
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <typeparam name="TPrimaryKey"></typeparam>
    public interface IRepository<TEntity, TPrimaryKey> : IEntityAdd<TEntity>, IEntityUpdate<TEntity>, IEntityDel<TEntity>, IEntityKeyDel<TPrimaryKey>
        , IEntityView<TEntity>, IEntityKeyView<TEntity, TPrimaryKey>
        , IEntityList<TEntity>, ICount
        where TEntity : IEntity<TPrimaryKey>
    {
    }

    /// <summary>
    /// 按條件獲取列表
    /// </summary>
    /// <typeparam name="TCondition"></typeparam>
    /// <typeparam name="T"></typeparam>
    public interface IEntityConditionList<T, in TCondition>
    {
        /// <summary>
        /// 按條件獲取列表
        /// </summary>
        /// <param name="condition"></param>
        /// <returns></returns>
        IEnumerable<T> List(TCondition condition);
    }

    /// <summary>
    /// 按條件獲取計數(統計)
    /// </summary>
    /// <typeparam name="TCondition"></typeparam>
    public interface IEntityConditionCount<in TCondition>
    {
        /// <summary>
        /// 按條件獲取計數(統計)
        /// </summary>
        /// <param name="condition"></param>
        /// <returns></returns>
        int Count(TCondition condition);
    }

    /// <summary>
    /// 按條件修改介面
    /// </summary>
    /// <typeparam name="TCondition"></typeparam>
    /// <typeparam name="TUpdateContract"></typeparam>
    public interface IEntityConditionUpdate<in TCondition, in TUpdateContract>
    {
        /// <summary>
        /// 按條件修改
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="contract"></param>
        /// <returns></returns>
        bool Update(TCondition condition, TUpdateContract contract);
    }

    /// <summary>
    /// 按條件刪除介面
    /// </summary>
    /// <typeparam name="TCondition"></typeparam>
    public interface IEntityConditionDel<in TCondition> 
    {
        /// <summary>
        /// 按條件刪除
        /// </summary>
        /// <param name="condition"></param>
        /// <returns></returns>
        bool Del(TCondition condition);
    }

以上14個大介面涵蓋了數據處理中的添、刪、改、查各種情況(當然可能不全面還會增加),雖然都是虛的,當絕對是滿滿的乾貨(這14個介面是我好幾年逐步的總結)。

介面有什麼作用,介面就是規則就是標準就是契約

其一、基於介面開發出來的功能模塊可高度復用。

其二、依賴介面開發的項目低耦合,可以各自分工同時多線程並行進行

其三、調用介面的模塊可以方便的更換部分介面的實現,不會導致大範圍的連鎖反應,相當於可以給飛行中飛機換引擎

這裡要強調的是以上介面不只是操作資料庫,資料庫只是數據的一種形式,還可以是文件、遠程服務、Redis、nosql等。

以上都是"虛"的,來的實際例子使用這些介面

二、首先看一個Dapper(封裝後的)開發Mvc例子

1、Model

    /// <summary>
    /// 文章
    /// </summary>
    public class Article : IEntity<int>
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public int BodyId { get; set; }
        public int UserId { get; set; }

        #region IEntity<int>
        object IEntity.ObjId { get { return Id; } }
        #endregion
    }

2、View

@model IEnumerable<CMS.Models.Article>

@{
    ViewBag.Title = "Index";
}

<h2>Index</h2>

<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table>
    <tr>
        <th>
            @Html.DisplayNameFor(model => model.Title)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.BodyId)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.UserId)
        </th>
        <th></th>
    </tr>

@foreach (var item in Model) {
    <tr>
        <td>
            @Html.DisplayFor(modelItem => item.Title)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.BodyId)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.UserId)
        </td>
        <td>
            @Html.ActionLink("Edit", "Edit", new { id=item.Id }) |
            @Html.ActionLink("Details", "Details", new { id=item.Id }) |
            @Html.ActionLink("Delete", "Delete", new { id=item.Id })
        </td>
    </tr>
}

</table>

註:View是簡單了一點,就是Vs預設生成的,只是為了演示功能,大家不要將就著看吧

3、Controller

        #region DI配置
        [Dependency("IndexOperater")]
        public IEntityList<CMS.Models.Article> IndexOperater { get; set; }
        [Dependency("DetailOperater")]
        public IEntityKeyView<CMS.Models.Article, int> DetailOperater { get; set; }
        [Dependency("CreateOperater")]
        public IEntityAdd<CMS.Models.Article> CreateOperater { get; set; }
        [Dependency("EditOperater")]
        public IEntityUpdate<CMS.Models.Article> EditOperater { get; set; }
        [Dependency("DeleteOperater")]
        public IEntityKeyDel<int> DeleteOperater { get; set; }
        #endregion

        public ActionResult Index()
        {
            var operater = IndexOperater;
            IEnumerable<CMS.Models.Article> list = null;
            if (operater != null)
                list = operater.ListAll();
            return View(list ?? Enumerable.Empty<CMS.Models.Article>());
        }

是不是簡單到"不可理喻,一點都看不出Dapper痕跡,要的就是這個效果

註:DI沒看懂的請參看另一篇文章“Mvc擴展框架及DI”

4、看一下執行效果

不只是一個簡單的列表,所有的添、刪、改、查都實現了

5、有人不信是Dapper,那我調試給諸位看

6、有人說Dapper是基於sql的,你的sql在哪裡？look配置

      <container name="CMS">
        <register type="Fang.Mvc.Area, Fang.Mvc" name="CMS">
          <lifetime type="singleton" />
          <property name="Name" type="string" value="CMS"></property>
          <property name="DependencyContainer" type="string" value="Mvc.CMS"></property>
          <!--<property name="Path" type="string" value="CMS"></property>-->
          <property name="NameSpaces">
            <array>
              <value value="CMS.Web.Controllers" />
            </array>
          </property>
        </register>
        
        <register type="Fang.Data.IEntityList[[CMS.Models.Article, CMS.Models]], Fang.Interface"  mapTo="Fang.FangDapper.SqlListAll[[CMS.Models.Article, CMS.Models]], Fang.FangDapper" name="IndexOperater">
          <lifetime type="singleton" />
          <property name="Sql" type="string" value="SELECT [Id],[Title],[BodyId],[UserId] FROM [dbo].[Article] WITH(NOLOCK) ORDER BY [Id] DESC"></property>
          <property name="Config">
            <optional name="jinrong_log_ReadDb" type="Fang.ADO.ConnectionStringFactory, Fang.ADO" />
          </property>
        </register>

        <register type="Fang.Data.IEntityKeyView[[CMS.Models.Article, CMS.Models],int], Fang.Interface"  mapTo="Fang.FangDapper.SqlViewByKey[[CMS.Models.Article, CMS.Models],int], Fang.FangDapper" name="DetailOperater">
          <lifetime type="singleton" />
          <property name="Sql" type="string" value="SELECT [Id],[Title],[BodyId],[UserId] FROM [dbo].[Article] WITH(NOLOCK) WHERE [Id]=@id"></property>
          <property name="Config">
            <optional name="jinrong_log_ReadDb" type="Fang.ADO.ConnectionStringFactory, Fang.ADO" />
          </property>
        </register>

        <register type="Fang.Data.IEntityAdd[[CMS.Models.Article, CMS.Models]], Fang.Interface"  mapTo="Fang.FangDapper.SqlAdd[[CMS.Models.Article, CMS.Models]], Fang.FangDapper" name="CreateOperater">
          <lifetime type="singleton" />
          <property name="Sql" type="string" value="INSERT INTO [dbo].[Article]([Title],[BodyId],[UserId]) VALUES(@Title,@BodyId,@UserId)"></property>
          <property name="Config">
            <optional name="jinrong_log_WriteDb" type="Fang.ADO.ConnectionStringFactory, Fang.ADO" />
          </property>
        </register>

        <register type="Fang.Data.IEntityUpdate[[CMS.Models.Article, CMS.Models]], Fang.Interface"  mapTo="Fang.FangDapper.SqlUpdate[[CMS.Models.Article, CMS.Models]], Fang.FangDapper" name="EditOperater">
          <lifetime type="singleton" />
          <property name="Sql" type="string" value="UPDATE [dbo].[Article] SET [Title]=@Title,[BodyId]=@BodyId,[UserId]=@UserId WHERE [Id]=@id"></property>
          <property name="Config">
            <optional name="jinrong_log_WriteDb" type="Fang.ADO.ConnectionStringFactory, Fang.ADO" />
          </property>
        </register>

        <register type="Fang.Data.IEntityKeyDel[int], Fang.Interface"  mapTo="Fang.FangDapper.SqlDelByKey[[CMS.Models.Article, CMS.Models],int], Fang.FangDapper" name="DeleteOperater">
          <lifetime type="singleton" />
          <property name="Sql" type="string" value="DELETE [dbo].[Article] WHERE [Id]=@id"></property>
          <property name="Config">
            <optional name="jinrong_log_WriteDb" type="Fang.ADO.ConnectionStringFactory, Fang.ADO" />
          </property>
        </register>

        <!--資料庫讀-->
        <register type="Fang.ADO.ConnectionStringFactory, Fang.ADO" name="jinrong_log_ReadDb">
          <lifetime type="singleton" />
          <property name="Name" type="string" value="jinrong_log_ReadDb"></property>
        </register>
        <!--資料庫寫-->
        <register type="Fang.ADO.ConnectionStringFactory, Fang.ADO" name="jinrong_log_WriteDb">
          <lifetime type="singleton" />
          <property name="Name" type="string" value="jinrong_log_WriteDb"></property>
        </register>
        <!--容器自動初始化列表配置-->
        <register type="Fang.UnitOfWork.IUnitInit, Fang.Interface" mapTo="Fang.UnitOfWork.MutiUnitInit, Fang.Framework" name="ContainerInit">
          <lifetime type="singleton" />
          <property name="Objs">
            <array>
              <optional name="jinrong_log_ReadDb" type="Fang.ADO.ConnectionStringFactory, Fang.ADO" />
              <optional name="jinrong_log_WriteDb" type="Fang.ADO.ConnectionStringFactory, Fang.ADO" />
            </array>
          </property>
        </register>
      </container>

註:以上是Unity容器配置,不用Unity用其他容器也是可以的(只是配置格式稍有不同,不用配置文件用代碼註入也是可以的)

我看著還是挺漂亮的,實現Dapper擴展之後完全徹底顛覆了我對Dapper的印象,非常靈活、非常強大、非常簡單。

7、再把其他幾個視圖也簡單截圖賞析一下

三、以上功能再用EF實現一次

1、MVC都是一樣的,直接看執行效果圖