2. 程式人生 > 其它 >Dapper in .Net Core

Dapper in .Net Core

阿新 • • 發佈：2022-01-04

Dapper in .Net Core - 白雲任去留 - 部落格園 (cnblogs.com)

目錄

回到頂部

一、前言

　　關於什麼是Dapper（詳細入口），在此不做贅述；本文僅對Dapper在.Net Core中的使用作扼要說明，所陳程式碼以示例講解為主，乃拋磚引玉，開發者可根據自身需要進行擴充套件和調整；其中如有疏漏之處，望不吝斧正。

回到頂部

二、Dapper環境搭建

當前以.Net Core WebAPI或MVC專案為例，框架版本為.NET 5.0，相關NuGet包引用如下：

Install-Package Dapper

Install-Package Dapper.Contrib

Install-Package Dapper.SqlBuilder

Install-Package System.Data.SqlClient

其中Dapper.Contrib和Dapper.SqlBuilder為Dapper的擴充套件，當然，Dapper的擴充套件還有如Dapper.Rainbow等其他包，根據自身需要引用，對相關引用作下說明：

  • Dapper：不言而喻；
  • Dapper.Contrib：可使用物件進行資料表的增刪改查，免卻SQL語句的編寫；
  • Dapper.SqlBuilder：可以方便動態構建SQL語句，如Join、SELECT、Where、OrderBy等等；
  • System.Data.SqlClient：由於示例資料庫為Sql Server，如MySql則引用MySql.Data；


對於Dapper.Contrib實體配置選項，以Product類為例，作扼要說明如下：

[Table("Product")]
public class Product
{
    [Key]  
    public int Id { get; set; }
    public string Name{ get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public DateTime CreateTime { get; set; }
}

對於實體配置項，有如下幾個主要項：

  • Table：指定資料庫表名，可忽略；
  • Key：指定為自動增長主鍵；
  • ExplicitKey：指定非自動增長主鍵，如guid；
  • Computed：計算列屬性，Insert、Update操作將忽略此列；
  • Write：是否可寫入，true/false，如[Write(false)]，false時Insert、Update操作將忽略此列，比如可擴充套件區域性類作資料表額外查詢欄位使用；

對於資料表物件實體，可結合T4模板生成即可。

回到頂部

三、Dapper封裝

　　關於Dapper資料訪問，這裡參考Github上的某示例（入口：https://github.com/EloreTec/UnitOfWorkWithDapper），作修改調整封裝如下：

定義DapperDBContext類

public abstract class DapperDBContext : IContext
    {
        private IDbConnection _connection;
        private IDbTransaction _transaction;
        private int? _commandTimeout = null;
        private readonly DapperDBContextOptions _options;

        public bool IsTransactionStarted { get; private set; }

        protected abstract IDbConnection CreateConnection(string connectionString);

        protected DapperDBContext(IOptions<DapperDBContextOptions> optionsAccessor)
        {
            _options = optionsAccessor.Value;

            _connection = CreateConnection(_options.Configuration);
            _connection.Open();

            DebugPrint("Connection started.");
        }

        #region Transaction

        public void BeginTransaction()
        {
            if (IsTransactionStarted)
                throw new InvalidOperationException("Transaction is already started.");

            _transaction = _connection.BeginTransaction();
            IsTransactionStarted = true;

            DebugPrint("Transaction started.");
        }

        public void Commit()
        {
            if (!IsTransactionStarted)
                throw new InvalidOperationException("No transaction started.");

            _transaction.Commit();
            _transaction = null;

            IsTransactionStarted = false;

            DebugPrint("Transaction committed.");
        }

        public void Rollback()
        {
            if (!IsTransactionStarted)
                throw new InvalidOperationException("No transaction started.");

            _transaction.Rollback();
            _transaction.Dispose();
            _transaction = null;

            IsTransactionStarted = false;

            DebugPrint("Transaction rollbacked and disposed.");
        }

        #endregion Transaction

        #region Dapper.Contrib.Extensions

        public async Task<T> GetAsync<T>(int id) where T : class, new()
        {
            return await _connection.GetAsync<T>(id, _transaction, _commandTimeout);
        }

        public async Task<T> GetAsync<T>(string id) where T : class, new()
        {
            return await _connection.GetAsync<T>(id, _transaction, _commandTimeout);
        }

        public async Task<IEnumerable<T>> GetAllAsync<T>() where T : class, new()
        {
            return await _connection.GetAllAsync<T>();
        }

        public long Insert<T>(T model) where T : class, new()
        {
            return _connection.Insert<T>(model, _transaction, _commandTimeout);
        }

        public async Task<int> InsertAsync<T>(T model) where T : class, new()
        {
            return await _connection.InsertAsync<T>(model, _transaction, _commandTimeout);
        }
        public bool Update<T>(T model) where T : class, new()
        {
            return _connection.Update<T>(model, _transaction, _commandTimeout);
        }

        public async Task<bool> UpdateAsync<T>(T model) where T : class, new()
        {
            return await _connection.UpdateAsync<T>(model, _transaction, _commandTimeout);          
        }

        public async Task<Page<T>> PageAsync<T>(long pageIndex, long pageSize, string sql, object param = null)
        {
            DapperPage.BuildPageQueries((pageIndex - 1) * pageSize, pageSize, sql, out string sqlCount, out string sqlPage);

            var result = new Page<T>
            {
                CurrentPage = pageIndex,
                ItemsPerPage = pageSize,
                TotalItems = await _connection.ExecuteScalarAsync<long>(sqlCount, param)
            };
            result.TotalPages = result.TotalItems / pageSize;

            if ((result.TotalItems % pageSize) != 0)
                result.TotalPages++;

            result.Items = await _connection.QueryAsync<T>(sqlPage, param);
            return result;
        }
      

        #endregion


        #region Dapper Execute & Query
      

        public int ExecuteScalar(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return _connection.ExecuteScalar<int>(sql, param, _transaction, _commandTimeout, commandType);
        }

        public async Task<int> ExecuteScalarAsync(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return await _connection.ExecuteScalarAsync<int>(sql, param, _transaction, _commandTimeout, commandType);
        }
        public int Execute(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return _connection.Execute(sql, param, _transaction, _commandTimeout, commandType);
        }

        public async Task<int> ExecuteAsync(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return await _connection.ExecuteAsync(sql, param, _transaction, _commandTimeout, commandType);
        }

        public IEnumerable<T> Query<T>(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return _connection.Query<T>(sql, param, _transaction, true, _commandTimeout, commandType);
        }

        public async Task<IEnumerable<T>> QueryAsync<T>(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return await _connection.QueryAsync<T>(sql, param, _transaction, _commandTimeout, commandType);
        }

        public T QueryFirstOrDefault<T>(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return _connection.QueryFirstOrDefault<T>(sql, param, _transaction, _commandTimeout, commandType);
        }

        public async Task<T> QueryFirstOrDefaultAsync<T>(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return await _connection.QueryFirstOrDefaultAsync<T>(sql, param, _transaction, _commandTimeout, commandType);
        }
        public IEnumerable<TReturn> Query<TFirst, TSecond, TReturn>(string sql, Func<TFirst, TSecond, TReturn> map, object param = null, string splitOn = "Id", CommandType commandType = CommandType.Text)
        {
            return _connection.Query(sql, map, param, _transaction, true, splitOn, _commandTimeout, commandType);
        }

        public async Task<IEnumerable<TReturn>> QueryAsync<TFirst, TSecond, TReturn>(string sql, Func<TFirst, TSecond, TReturn> map, object param = null, string splitOn = "Id", CommandType commandType = CommandType.Text)
        {
            return await _connection.QueryAsync(sql, map, param, _transaction, true, splitOn, _commandTimeout, commandType);
        }

        public async Task<SqlMapper.GridReader> QueryMultipleAsync(string sql, object param = null, CommandType commandType = CommandType.Text)
        {
            return await _connection.QueryMultipleAsync(sql, param, _transaction, _commandTimeout, commandType);
        }

        #endregion Dapper Execute & Query

        public void Dispose()
        {
            if (IsTransactionStarted)
                Rollback();

            _connection.Close();
            _connection.Dispose();
            _connection = null;

            DebugPrint("Connection closed and disposed.");
        }

        private void DebugPrint(string message)
        {
#if DEBUG
            Debug.Print(">>> UnitOfWorkWithDapper - Thread {0}: {1}", Thread.CurrentThread.ManagedThreadId, message);
#endif
        }
    }
View Code

以上程式碼涵蓋了Dapper訪問資料庫的基本操作，分同步和非同步，其中大部分不作贅述，著重說下分頁部分；

非同步分頁構建（PageAsync）

分頁這裡為方便呼叫，只需傳入要查詢的Sql語句（如：SELECT * FROM Table，必須帶Order BY）、頁索引、頁大小即可；

至於具體如何構建的，這裡參照某小型ORM工具PetaPoco，抽取相關程式碼如下，有興趣的同學也可以自行改造：

public class Page<T>
    {
        /// <summary>
        /// The current page number contained in this page of result set 
        /// </summary>
        public long CurrentPage { get; set; }

        /// <summary>
        /// The total number of pages in the full result set
        /// </summary>
        public long TotalPages { get; set; }

        /// <summary>
        /// The total number of records in the full result set
        /// </summary>
        public long TotalItems { get; set; }

        /// <summary>
        /// The number of items per page
        /// </summary>
        public long ItemsPerPage { get; set; }

        /// <summary>
        /// The actual records on this page
        /// </summary>
        public IEnumerable<T> Items { get; set; }
        //public List<T> Items { get; set; }
    }
    public class DapperPage
    {
        public static void BuildPageQueries(long skip, long take, string sql, out string sqlCount, out string sqlPage)
        {
            // Split the SQL
            if (!PagingHelper.SplitSQL(sql, out PagingHelper.SQLParts parts))
                throw new Exception("Unable to parse SQL statement for paged query");

            sqlPage = BuildPageSql.BuildPageQuery(skip, take, parts);
            sqlCount = parts.sqlCount;
        }
    }

    static class BuildPageSql
    {
        public static string BuildPageQuery(long skip, long take, PagingHelper.SQLParts parts)
        {
            parts.sqlSelectRemoved = PagingHelper.rxOrderBy.Replace(parts.sqlSelectRemoved, "", 1);
            if (PagingHelper.rxDistinct.IsMatch(parts.sqlSelectRemoved))
            {
                parts.sqlSelectRemoved = "peta_inner.* FROM (SELECT " + parts.sqlSelectRemoved + ") peta_inner";
            }
            var sqlPage = string.Format("SELECT * FROM (SELECT ROW_NUMBER() OVER ({0}) peta_rn, {1}) peta_paged WHERE peta_rn>{2} AND peta_rn<={3}",
                                    parts.sqlOrderBy ?? "ORDER BY (SELECT NULL)", parts.sqlSelectRemoved, skip, skip + take);
            //args = args.Concat(new object[] { skip, skip + take }).ToArray();

            return sqlPage;
        }

        //SqlServer 2012及以上
        public static string BuildPageQuery2(long skip, long take, PagingHelper.SQLParts parts)
        {
            parts.sqlSelectRemoved = PagingHelper.rxOrderBy.Replace(parts.sqlSelectRemoved, "", 1);
            if (PagingHelper.rxDistinct.IsMatch(parts.sqlSelectRemoved))
            {
                parts.sqlSelectRemoved = "peta_inner.* FROM (SELECT " + parts.sqlSelectRemoved + ") peta_inner";
            }    

            var sqlOrderBy = parts.sqlOrderBy ?? "ORDER BY (SELECT NULL)";
            var sqlPage = $"SELECT {parts.sqlSelectRemoved} {sqlOrderBy} OFFSET {skip} ROWS FETCH NEXT {take} ROWS ONLY";
            return sqlPage;
        }
    }

    static class PagingHelper
    {
        public struct SQLParts
        {
            public string sql;
            public string sqlCount;
            public string sqlSelectRemoved;
            public string sqlOrderBy;
        }

        public static bool SplitSQL(string sql, out SQLParts parts)
        {
            parts.sql = sql;
            parts.sqlSelectRemoved = null;
            parts.sqlCount = null;
            parts.sqlOrderBy = null;

            // Extract the columns from "SELECT <whatever> FROM"
            var m = rxColumns.Match(sql);
            if (!m.Success)
                return false;

            // Save column list and replace with COUNT(*)
            Group g = m.Groups[1];
            parts.sqlSelectRemoved = sql.Substring(g.Index);

            if (rxDistinct.IsMatch(parts.sqlSelectRemoved))
                parts.sqlCount = sql.Substring(0, g.Index) + "COUNT(" + m.Groups[1].ToString().Trim() + ") " + sql.Substring(g.Index + g.Length);
            else
                parts.sqlCount = sql.Substring(0, g.Index) + "COUNT(*) " + sql.Substring(g.Index + g.Length);


            // Look for the last "ORDER BY <whatever>" clause not part of a ROW_NUMBER expression
            m = rxOrderBy.Match(parts.sqlCount);
            if (!m.Success)
            {
                parts.sqlOrderBy = null;
            }
            else
            {
                g = m.Groups[0];
                parts.sqlOrderBy = g.ToString();
                parts.sqlCount = parts.sqlCount.Substring(0, g.Index) + parts.sqlCount.Substring(g.Index + g.Length);
            }

            return true;
        }

        public static Regex rxColumns = new Regex(@"\A\s*SELECT\s+((?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|.)*?)(?<!,\s+)\bFROM\b", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
        public static Regex rxOrderBy = new Regex(@"\bORDER\s+BY\s+(?!.*?(?:\)|\s+)AS\s)(?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|[\w\(\)\.])+(?:\s+(?:ASC|DESC))?(?:\s*,\s*(?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|[\w\(\)\.])+(?:\s+(?:ASC|DESC))?)*", RegexOptions.RightToLeft | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
        public static Regex rxDistinct = new Regex(@"\ADISTINCT\s", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
    }

對於構建分頁語句，分別示例BuildPageQuery和BuildPageQuery2，前者為通過ROW_NUMBER進行分頁（針對SqlServer2005、2008），後者通過OFFSET、FETCH分頁（針對SqlServer2012及以上版本），相關輔助操作類一覽便知，如果使用MySql資料庫，可酌情自行封裝；

至於Where查詢的進一步封裝，有興趣的也可兌Dapper lamada查詢進行擴充套件。

定義工作單元與事務

View Code

定義資料倉儲

View Code

根據自身需要進行調整或擴充套件，一般藉助T4模板生成

資料庫連線

通過Ioptions模式讀取配置檔案appsettings中連線字串

public class MyDBContext : DapperDBContext
    {
        public MyDBContext(IOptions<DapperDBContextOptions> optionsAccessor) : base(optionsAccessor)
        {
        }

        protected override IDbConnection CreateConnection(string connectionString)
        {
            IDbConnection conn = new SqlConnection(connectionString);
            return conn;
        }
    }
回到頂部

四、Dapper使用

Startup.cs注入並讀取資料庫連線字串

{
  "SQLConnString": "Data Source=(local);Initial Catalog=database;Persist Security Info=True;User ID=sa;Password=123456;MultipleActiveResultSets=True;",  
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}
services.AddDapperDBContext<MyDBContext>(options =>
            {
                options.Configuration = Configuration["SQLConnString"];
            });

簡單示例WebAPI或Net Core MVC下的呼叫示例：

View Code View Code

相關推薦

Dapper in .Net Core

Dapper in .Net Core - 白雲任去留 - 部落格園 (cnblogs.com) 目錄 一、前言 二、Dapper環境搭建

What's the replacement for fuslogvw in .net core 2?

What\'s the replacement for fuslogvw in .net core 2? When encountering problems with resolving DLLs and assemblies in general with .Net fuslogvw gave you the ability to log the binding attempts so yo

Introducing diagnostics improvements in .NET Core 3.0（轉發）

原文: https://devblogs.microsoft.com/dotnet/introducing-diagnostics-improvements-in-net-core-3-0/ In .NET Core 3.0, we are introducing a suite of tools that utilize new features in the .NET runtime th

.Net Core in Docker極簡入門（上篇）

目錄前言開始環境準備Docker基礎概念Docker基礎命令Docker命令實踐構建Docker映象Dockerfilebulid & run

.net core dapper 從 select from int (...) 到 Table-Valued Parameters

背景 通過select from in語句進行資料庫查詢，其實是比較常見的， 但是此類查詢語句in中能夠接收的列表數量是有限的，如SQL Server 2008 R2這個上限是2100。而且in語句查詢效率較低。

GraphQl in ASP.NET Core

GraphQl in ASP.NET Core https://graphql.cn/ https://graphql-dotnet.github.io/docs/getting-started/arguments/

記一次使用Asp.Net Core WebApi 5.0+Dapper+Mysql+Redis+Docker的開發過程

前言 我可能有三年沒怎麼碰C#了，目前的工作是在全職搞前端，最近有時間抽空看了一下Asp.net Core，Core版本號都到了5.0了，也越來越好用了，下面將記錄一下這幾天以來使用Asp.Net Core WebApi+Dapper+Mysql+

在.NetCore(C#)中使用ODP.NET Core+Dapper操作Oracle資料庫

前言 雖然一直在說“去IOE化”，但是在國企和政府，Oracle的歷史包袱實在太重了，甚至很多業務邏輯都是寫在Oracle的各種儲存過程裡面實現的……

如何在Asp.Net Core中整合ABP Dapper

　　在實際的專案中，除了整合ABP框架的EntityFrameworkCore以外，在有些特定的場景下不可避免地會使用一些SQL查詢語句，一方面是由於現在的EntityFrameworkCore2.X有些問題沒有解決，另外一方面是基於效能方面的考慮

ASP.NET Core 2.1 中非同步使用Dapper總結

1、安裝Dapper 通過Nuget安裝Dapper,直接搜尋dapper,安裝包名就叫Dapper,就安裝這一個就行。

Use Attributes & Middleware in ASP.NET Core for Logging, Telemetry, and Anything Else (轉發)

原文： https://michaelscodingspot.com/attributes-and-middleware-in-asp-net-core/ Use Attributes & Middleware in ASP.NET Core for Logging, Telemetry, and Anything Else

.Net Core下使用Dapper的方法

目錄一、前言二、Dapper環境搭建三、Dapper封裝定義DapperDBContext類非同步分頁構建（PageAsync）定義工作單元與事務定義資料倉儲連線四、Dapper使用一、前言

.net core 基於Dapper 的分庫分表開源框架（core-data）

一、前言 分享基於Dapper 的分庫分表開源框架core-data的強大功能，更好的提高開發過程中的效率；在資料庫的資料日積月累的積累下，業務資料庫中的單表資料想必也越來越大，大到百萬、千萬、甚至上億級別的資料，這

第二章：建立你的第一個應用程式(ASP.NET Core in Action)

本章要點 建立第一個ASP.NET Core web應用程式 執行應用程式 瞭解應用程式的元件  讀完第1章後，您應該對ASP.NET Core應用程式的工作原理以及何時使用它們有了大致的瞭解。您還應該設定了一個開發環境，可以用來開

第4章 使用 Razor Pages 建立網站（ASP.NET Core in Action, 2nd Edition）

本章重點 RazorPages和模型檢視-控制器（MVC）設計模式簡介 在ASP.NET Core中使用RazorPages

【譯】單頁面應用與ASP.NET Core 3.0

原文連結 隨著Angular,React,Vue以及其他一些前端技術的成熟，Web開發在過去的幾年中已經發生了很大的改變，從建立Web頁面轉向建立應用程式，同時從在服務端渲染標記，轉向直接在瀏覽器中渲染。大部分情況下，這使得

【譯】Pulumi：.NET Core雲架構

原文連結 本月伊始，Pulumi宣佈在他們支援的語言中新增了.NET Core。Pulumi是一個開源工具，支援在多個雲供應商上以程式碼的形式建立，開發並管理基礎架構，類似於HashiCorp Terraform。

ASP.NET Core的幾種託管方式

Kestrel Kestrel 是一個跨平臺的適用於 ASP.NET Core 的 Web 伺服器,預設包括在 ASP.NET Core 專案模板中。

.net core 3.0 Signalr - 03 使用MessagePack壓縮傳輸內容

MessagePack基礎介紹 Signalr預設使用的是json形式傳遞資料，但是signalr提供了靈活的擴充套件，支援MessagePack形式序列化資料，以增加效能降低網路傳輸的效果，極大的提高響應速度。

.net core 3.0 Signalr - 04 使用Redis做底板來支援橫向擴充套件

在實際的系統中，可能需要多臺機器部署;然而，Signalr的連線資訊是跟站點走的，舉個例子推送系統部署了A、B兩個伺服器，張三訪問A伺服器，李四訪問B伺服器，當張三通過A伺服器向李四推送的時候，A伺服器上是找不到李