.NetCore中使用Dapper

Dapper是什么？

Dapper是開源的、輕量級，高性能的ORM（對象關系映射）。

Dapper的特點：

一、輕量：Dapper的GitHub地址：https://github.com/StackExchange/Dapper/tree/main/Dapper，它的核心代碼是SqlMapper.cs。代碼量不多，編輯后所占空間也比較小。

二、高性能：它通過Emit反射IDataReader的序列隊列，快速的映射出對象。

三、Dapper更傾向於面向SQL，支持多種數據庫。

 .NetCore中簡單封裝使用Dapper

1、引入Dapper和Dapper.Contrib

2、創建倉儲接口

public interface IRepository<T> where T:BaseEntity
    {
        T GetById(string id);
        IEnumerable<T> GetAll();
        IEnumerable<T> GetBySql(string sql, Dictionary<string, object> parameter, CommandType commandType);
        IEnumerable<T> GetByPaging(string sql, Dictionary<string, object> parameters, CommandType commandType);
       
        void Add(T entity);
        void Delete(T entity);
        void Update(T Entity);

    }

 

3、創建倉儲基類

   public class BaseRepository<T> : IRepository<T> where T : BaseEntity
    {
        private IDbConnection _connection;
        public BaseRepository(IConfiguration configuration)
        {
            this._connection = new MySqlConnection(configuration.GetConnectionString("ListingDb"));
        }

        public IEnumerable<T> GetAll()
        {
            var result = _connection.GetAll<T>();
            return result;
        }

        public T GetById(string id)
        {
            var result = _connection.Get<T>(id);
            return result;
        }

        public IEnumerable<T> GetByPaging(string sql, Dictionary<string, object> parameters, CommandType commandType)
        {
            //TODO query paging
            return null;
        }

        public IEnumerable<T> GetBySql(string sql, Dictionary<string, object> parameters, CommandType commandType)
        {
            var result = _connection.Query<T>(sql, parameters, commandType: commandType);
            return result;
        }

        public void Add(T entity)
        {
            _connection.Insert(entity, null);
        }
        public void Update(T entity)
        {
            _connection.Update(entity);
        }
        public void Delete(T entity)
        {
            _connection.Delete(entity);
        }
    }

4、在startup.cs中注入倉儲類

 

services.AddScoped(typeof(IRepository<>), typeof(BaseRepository<>));

5、定義具體業務類進行調用（略）

 

進階--實現Dapper+UnitOfWork

想了解UOW(UnitOfWork)可參照：https://martinfowler.com/eaaCatalog/unitOfWork.html

在【簡單封裝dapper】中，不難發現它主要是針對單個對象的操作。即使通過注入多個對象的倉儲進行統一處理統一事務的多表，但是還是缺少了事務的支持。就像之前寫的關於數據庫訪問的封裝（https://www.cnblogs.com/johnyong/p/14152891.html）一樣，需要將事務進行抽離，即做成單獨的工作單元，實現對對象狀態的跟蹤，實現事務。

以下是簡單的實現

1、定義IUnitOfWork接口

    public interface IUnitOfWork
    {
        Guid Id { get; }
        IDbConnection Connection { get; }
        IDbTransaction Transaction { get; }
        void Begin();
        void Commit();
        void Rollback(); 
    }

2、定義UnitOfWork

    public sealed class UnitOfWork : IUnitOfWork, IDisposable
    {
        private Guid _id = Guid.Empty;
        private IDbConnection _connection = null;
        private IDbTransaction _transaction = null;
        private bool _disposed = false;
 
        public UnitOfWork(IConfiguration configuration)
        {
            _id = new Guid();
            _connection = new MySqlConnection(configuration.GetConnectionString("SimpleTestConnection"));


        }


        public Guid Id
        {
            get { return _id; }
        }

        public IDbConnection Connection
        {
            get { return _connection; }
        }
        public IDbTransaction Transaction
        {
            get { return _transaction; }
        }

        public void Begin()
        {
            if (_connection.State != ConnectionState.Open)
            {
                _connection.Open();
            }
            _transaction = _connection.BeginTransaction();
        }

        public void Commit()
        {
            _transaction.Commit();
            Dispose();
        }

        public void Rollback()
        {
            _transaction.Rollback();
            Dispose();
        }


        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public void Dispose(bool disposing)
        {
            if (_disposed)
                return;

            if (disposing)
            {
                _transaction?.Dispose();
                _connection?.Dispose();
            }

            _transaction = null;
            _connection = null;
            _disposed = true;
        }
        ~UnitOfWork()
        {
            Dispose(false);
        }
    }

3、修改BaseRepository

    public class BaseRepository<T> : IRepository<T> where T : BaseEntity
    {
        private IUnitOfWork _unitOfWork;
        public BaseRepository(IUnitOfWork unitOfWork)
        {
            this._unitOfWork = unitOfWork;
        }
       
        public IEnumerable<T> GetAll()
        {
            var result = _unitOfWork.Connection.GetAll<T>();
            return result;
        }

        public T GetById(string id)
        {
            var result = _unitOfWork.Connection.Get<T>(id);
            return result;
        }

        public IEnumerable<T> GetByPaging(string sql, Dictionary<string, object> parameters, CommandType commandType)
        {
            //TODO query paging
            return null; 
        }

        public IEnumerable<T> GetBySql(string sql, Dictionary<string, object> parameters, CommandType commandType)
        {
            var result = _unitOfWork.Connection.Query<T>(sql, parameters, commandType: commandType);
            return result;
        }

        public void Add(T entity)
        {
            _unitOfWork.Connection.Insert(entity,null);
        }
        public void Update(T entity)
        {
            _unitOfWork.Connection.Update(entity);
        }
        public void Delete(T entity)
        {
            _unitOfWork.Connection.Delete(entity);
        }
    }

 

4、定義事務特性，用於實現aop(需要引入AspectCore.DynamicProxy)

    public class SystemTransactionAttribute : AbstractInterceptorAttribute
    {
        IUnitOfWork _unitOfWork { get; set; }

        public async override Task Invoke(AspectContext context, AspectDelegate next)
        {
            try
            {
                _unitOfWork = context.ServiceProvider.GetService(typeof(IUnitOfWork)) as IUnitOfWork;
                _unitOfWork.Begin();
                await next(context);
                _unitOfWork.Commit();
            }
            catch (Exception ex )
            {
                _unitOfWork.Rollback();
                throw new Exception("SystemTransaction error",ex);
            }
        }
    }

 

5、注入服務

在startup.cs注入UnitOfWork

            services.AddScoped<IUnitOfWork, UnitOfWork>();
            services.AddScoped(typeof(IRepository<>), typeof(BaseRepository<>));

 

修改Program.cs

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                }).UseDynamicProxy();
    }

 

6、測試示例代碼

    public class ListingService: IListingService
    {
        private IRepository<Listing> _listingRepository;
        private IRepository<ListingDetail> _listingDetailRepository;

        public ListingService(IRepository<Listing> listingRepository,IRepository<ListingDetail> listingDetailRepository)
        {
            this._listingRepository = listingRepository;
            this._listingDetailRepository = listingDetailRepository;
        }
        [SystemTransaction]
        public void AddListing(ListingContract contract)
        { 
            var listing = new Listing()
            {
                Id = ObjectId.GenerateNewId().ToString(), 
                Price = contract.Price,
                Quantity = contract.Quantity,
                Title=contract.Title,
                Remark="john_yong test"
            };
            _listingRepository.Add(listing);
            foreach (var item in contract.DetailList)
            {
                var listingDetail = new ListingDetail()
                {
                    Id ="",//設置Id為空拋出異常 //ObjectId.GenerateNewId().ToString(),
                    ListingId = listing.Id,
                    Quantity = item.Quantity,
                    SKU = item.SKU,
                };
                _listingDetailRepository.Add(listingDetail);
            } 
            
        }
    }

 

注：

使用dapper.Contrib，默認數據庫表明為實體名稱的復數形式，我們可以使用[Table]特性進行聲明表名稱。

Dapper.Contrib.Extensions擴展而言：自增主鍵用[Key]標志（默認為自增主鍵）,非自增主鍵必須用[ExplicitKey]標志，否則即使我們給Id指定值再進行插入數據表，最終Id還是為空。

 

 

--------------------

本文地址： https://www.cnblogs.com/johnyong/p/14433155.html