.NET Core学习——Dapper

最新推荐文章于 2024-07-29 14:55:26 发布
最新推荐文章于 2024-07-29 14:55:26 发布
阅读量2.8k 收藏 13
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Abbey_qi/article/details/104607741
版权

一、了解Dapper

我们都知道，ORM全称是，Object Relationship Mapper，即，对象关系映射。也就是可以用object来map我们的db，而且市面上的orm框架有很多，其中有一个框架叫做dapper，而且被称为the king of ORM。

　　市场上，也有一些其他的ORM，比如EF Core，NHibernate 、FreeSQL等等，来处理大数据访问及关系映射。既然官方推出了EF Core，说明其对框架的支持会很友好，为什么又会有那么多的ORM框架供我们使用呢？其实，每一个框架都有其适用的场景。如果你在小的项目中，使用Entity Framework、Entity Framework Core、NHibernate 来处理大数据访问及关系映射，未免有点杀鸡用牛刀。你又觉得ORM省时省力，这时Dapper 将是你不二的选择。其实，Entity Framework Core的性能并不是很高，当对性能有要求的时候，一般公司都会自己封装一套ORM。

为什么选择Dapper？

  1. 轻量。只有一个文件（SqlMapper.cs），编译完成之后只有120k(好象是变胖了)
  2. 速度快。Dapper的速度接近与IDataReader，取列表的数据超过了DataTable。
  3. 支持多种数据库。Dapper可以在所有Ado.net Providers下工作，包括sqlite, sqlce, firebird, oracle, MySQL, PostgreSQL and SQL Server
  4. 可以映射一对一，一对多，多对多等多种关系。
  5. 性能高。通过Emit反射IDataReader的序列队列，来快速的得到和产生对象，性能不错。
  6. 支持FrameWork2.0，3.0，3.5，4.0，4.5

 二、使用Dapper

在这里，我们在dotnet core下面使用Dapper操作MySQL。

首先，就先创建一个core webapi的项目，基于core3.1版本创建一个项目。

Dapper安装，使用NuGet来安装Dapper程序包

Install-Package Dapper -Version 2.0.30

Install-Package Dapper.Contrib -Version 2.0.30

使用NuGet安装MySQL.Data的程序包 

安装这些程序包之后，在appsettings.json文件中添加链接数据库的字符串：

"ConnectionStrings": {
    "DefaultConnection": "server=服务器;port=端口号;database=regatta{0};SslMode=None;uid=userName;pwd=passWord;Allow User Variables=true"
  }

然后，封装一个工具类，来获得我们的连接字符串，和管理连接池。

IDapperContext：

    /// <summary>
    /// Dapper上下文
    /// </summary>
    public interface IDapperContext : IDisposable
    {
        /// <summary>
        /// 数据库连接对象
        /// </summary>
        IDbConnection ReadConnection { get; }

        /// <summary>
        /// 数据库连接对象
        /// </summary>
        IDbConnection WriteConnection { get; }
    }

 DapperContext：

    public class DapperContext : IDapperContext
    {
        /// <summary>
        /// 读连接字符串
        /// </summary>
        private string _readConnectionString;

        /// <summary>
        /// 写连接字符串
        /// </summary>
        private string _writeConnectionString;

        private bool _useMiniProfiling;

        /// <summary>
        /// 读连接
        /// </summary>
        private IDbConnection _readConnection;

        /// <summary>
        /// 写连接
        /// </summary>
        private IDbConnection _wrteConnection;

        /// <summary>
        /// 配置
        /// </summary>
        private readonly AppSetting _appSetting;

        /// <summary>
        /// 构造函数注入IOptions
        /// </summary>
        /// <param name="appSetting"></param>
        public DapperContext(IOptions<AppSetting> appSetting)
        {
            _appSetting = appSetting.Value;
            _readConnectionString = _appSetting.ReadOnlyConnectionString;
            _writeConnectionString = _appSetting.SetConnectionString;
            _useMiniProfiling = _appSetting.UseMiniProfiling;
        }

        /// <summary>
        /// 连接字符串
        /// </summary>
        /// <param name="connectionString"></param>
        public DapperContext(string connectionString)
        {
            _readConnectionString = connectionString;
        }

        #region 读

        /// <summary>
        /// 获取连接
        /// </summary>
        public IDbConnection ReadConnection
        {
            get
            {
                if (_readConnection == null || _readConnection.State == ConnectionState.Closed)
                {
                    if (_useMiniProfiling)
                    {
                        _readConnection = new ProfiledDbConnection(new MySqlConnection(_readConnectionString), MiniProfiler.Current);
                    }
                    else
                    {
                        _readConnection = new MySqlConnection(_readConnectionString);
                    }
                }
                if (_readConnection.State != ConnectionState.Open)
                {
                    _readConnection.Open();
                }
                return _readConnection;
            }
        }

        /// <summary>
        /// 释放连接
        /// </summary>
        public void Dispose()
        {
            if (_readConnection != null && _readConnection.State == ConnectionState.Open)
                _readConnection.Close();
            if (_wrteConnection != null && _wrteConnection.State == ConnectionState.Open)
                _wrteConnection.Close();
        }

        #endregion 读

        #region 写

        /// <summary>
        /// 获取连接
        /// </summary>
        public IDbConnection WriteConnection
        {
            get
            {
                if (_wrteConnection == null || _wrteConnection.State == ConnectionState.Closed)
                {
                    if (_useMiniProfiling)
                    {
                        _wrteConnection = new ProfiledDbConnection(new MySqlConnection(_writeConnectionString), MiniProfiler.Current);
                    }
                    else
                    {
                        _wrteConnection = new MySqlConnection(_writeConnectionString);
                    }
                }
                if (_wrteConnection.State != ConnectionState.Open)
                {
                    _wrteConnection.Open();
                }
                return _wrteConnection;
            }
        }

        #endregion 写
    }

 创建一个仓储，用来存放数据库CRUD等操作

IRepository：

    /// <summary>
    /// 数据库CRUD等操作
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IRepository<T> where T : class
    {
        /// <summary>
        /// 上下文
        /// </summary>
        IDapperContext Context { get; }

        /// <summary>
        /// 只读连接
        /// </summary>
        IDbConnection ReadConnection { get; }

        /// <summary>
        /// 读写连接
        /// </summary>
        IDbConnection WriteConnection { get; }

        /// <summary>
        /// 获取分页数据
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="criteria">查询设置</param>
        /// <param name="param"></param>
        /// <returns></returns>
        PageDataView<TEntity> GetPageData<TEntity>(PageCriteria criteria, object param = null) where TEntity : class;

        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="criteria"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        PageDataView<TEntity> GetAllData<TEntity>(PageCriteria criteria, object param = null) where TEntity : class;

        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        long Add(T entity, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 批量添加数据
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        long BatchAdd(IEnumerable<T> list, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        ///
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        bool Update(T entity, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 删除单条数据
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        bool Remove(T entity, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="list"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        bool BatchRemove(IEnumerable<T> list, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 根据主键获取数据
        /// </summary>
        /// <param name="key"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        T GetByKey(object key, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 获取所有数据
        /// </summary>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        IEnumerable<T> GetAll(IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 根据条件获取数据列表
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        IEnumerable<T> GetBy(object sql = null, object param = null, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        IEnumerable<dynamic> Query(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 多对象查询
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <param name="commandType"></param>
        /// <returns></returns>
        GridReader QueryMultiple(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null);

        /// <summary>
        /// 执行sql
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="transaction"></param>
        /// <param name="commandTimeout"></param>
        /// <returns></returns>
        int Excute(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null);

        /// <summary>
        /// 执行是否存在数据
        /// </summary>
        /// <param name="sqlStr">查询（例：SELECT COUNT(1)  FROM XXX ）</param>
        /// <returns></returns>
        bool Exists(string sqlStr, object param = null);
    }

Repository：

    public class Repository<T> : IRepository<T> where T : class
    {
        public Repository(IDapperContext context)
        {
            Context = context;
        }

        public IDapperContext Context { get; private set; }
        public IDbConnection ReadConnection => Context.ReadConnection;

        public IDbConnection WriteConnection => Context.WriteConnection;

        public PageDataView<TEntity> GetPageData<TEntity>(PageCriteria criteria, object param = null) where TEntity : class
        {
            var p = new DynamicParameters();
            string proName = "ProcGetPageData";
            p.Add("_tables", criteria.TableName);
            p.Add("_fields", criteria.Fields);
            p.Add("_where", criteria.Condition);
            p.Add("_pageIndex", criteria.CurrentPage);
            p.Add("_pageSize", criteria.PageSize);
            p.Add("_orderby", criteria.Sort);
            p.Add("_totalcount", dbType: DbType.Int32, direction: ParameterDirection.Output);
            p.Add("_pagecount", dbType: DbType.Int32, direction: ParameterDirection.Output);
            var pageData = new PageDataView<TEntity>();

            pageData.Items = ReadConnection.Query<TEntity>(proName, p, commandType: CommandType.StoredProcedure, commandTimeout: 300).ToList();
            pageData.TotalNum = p.Get<int>("_totalcount");
            pageData.TotalPageCount = p.Get<int>("_pagecount"); //Convert.ToInt32(Math.Ceiling(pageData.TotalNum * 1.0 / criteria.PageSize));
            pageData.CurrentPage = criteria.CurrentPage > pageData.TotalPageCount ? pageData.TotalPageCount : criteria.CurrentPage;

            return pageData;
        }

        public PageDataView<TEntity> GetAllData<TEntity>(PageCriteria criteria, object param = null) where TEntity : class
        {
            var p = new DynamicParameters();
            string proName = "ProcGetAllData";
            p.Add("_tables", criteria.TableName);
            p.Add("_fields", criteria.Fields);
            p.Add("_where", criteria.Condition);
            p.Add("_orderby", criteria.Sort);
            p.Add("_totalcount", dbType: DbType.Int32, direction: ParameterDirection.Output);
            var pageData = new PageDataView<TEntity>();
            pageData.Items = ReadConnection.Query<TEntity>(proName, p, commandType: CommandType.StoredProcedure, commandTimeout: 300).ToList();
            pageData.TotalNum = p.Get<int>("_totalcount");
            return pageData;
        }

        public long Add(T entity, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            if (entity == null)
            {
                throw new ArgumentNullException("entity", "Add to DB null entity");
            }
            var res = WriteConnection.Insert(entity, transaction: transaction, commandTimeout: commandTimeout);
            return res;
        }

        public long BatchAdd(IEnumerable<T> list, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            if (list == null)
            {
                throw new ArgumentNullException("list", "BatchAdd to DB null entity");
            }
            var res = WriteConnection.Insert(list, transaction: transaction, commandTimeout: commandTimeout);
            return res;
        }

        public virtual bool Update(T entity, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            if (entity == null)
            {
                throw new ArgumentNullException("entity", "Update in DB null entity");
            }
            return WriteConnection.Update(entity, transaction: transaction, commandTimeout: commandTimeout);
        }

        public virtual bool Remove(T entity, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            if (entity == null)
            {
                throw new ArgumentNullException("entity", "Remove in DB null entity");
            }
            return WriteConnection.Delete(entity, transaction: transaction, commandTimeout: commandTimeout);
        }

        public bool BatchRemove(IEnumerable<T> list, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            if (list == null)
            {
                throw new ArgumentNullException("list", "BatchAdd to DB null entity");
            }
            return WriteConnection.Delete(list, transaction: transaction, commandTimeout: commandTimeout);
        }

        public virtual T GetByKey(object queryId, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            if (queryId == null)
            {
                throw new ArgumentNullException("queryId");
            }
            return ReadConnection.Get<T>(queryId, transaction: transaction, commandTimeout: commandTimeout);
        }

        public virtual IEnumerable<T> GetAll(IDbTransaction transaction = null, int? commandTimeout = null)
        {
            return ReadConnection.GetAll<T>(transaction: transaction, commandTimeout: commandTimeout);
        }

        public virtual IEnumerable<T> GetBy(object sql = null, object param = null, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            return ReadConnection.Query<T>(sql.ToString(), param, commandTimeout: commandTimeout);
        }

        public IEnumerable<dynamic> Query(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            return ReadConnection.Query<dynamic>(sql, param);
        }

        public GridReader QueryMultiple(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
        {
            return ReadConnection.QueryMultiple(sql, param, transaction, commandTimeout, commandType);
        }

        public int Excute(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null)
        {
            return WriteConnection.Execute(sql, param, transaction: transaction);
        }

        public bool Exists(string sqlStr, object param = null)
        {
            return ReadConnection.Query<dynamic>(sqlStr, param).Count() > 0 ? true : false;
        }
    }

 利用工厂模式创建仓库

IFactoryRepository：

    /// <summary>
    /// 创建仓库接口
    /// </summary>
    public interface IFactoryRepository
    {
        /// <summary>
        /// 创建仓库
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="context"></param>
        /// <returns></returns>
        IRepository<T> CreateRepository<T>(IDapperContext context) where T : class;
    }

 FactoryRepository：

    /// <summary>
    /// 工厂
    /// </summary>
    public class FactoryRepository : IFactoryRepository
    {
        /// <summary>
        /// 创建Repository
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="context"></param>
        /// <returns></returns>
        public IRepository<T> CreateRepository<T>(IDapperContext context) where T : class
        {
            IRepository<T> repository = new Repository<T>(context);
            return repository;
        }
    }

相关文章：

**Dapper的基本使用 

NetCore+Dapper WebApi架构搭建（一）：基本框架

NetCore+Dapper WebApi架构搭建（二）：底层封装

NetCore+Dapper WebApi架构搭建（三）：添加实体和仓储

NetCore+Dapper WebApi架构搭建（四）：仓储的依赖注入

 

 

神经兮兮的小饼
关注
专栏目录
.netcore使用Dapper
cracker_black的博客
06-10 1035
1.安装Dapper包 在nuget包管理器中搜索Dapper或使用命令在程序包管理控制台执行 Install-Package Dapper 2.安装SqlClient 在nuget包管理器中搜索SqlClient或使用命令在程序包管理控制台执行 具体为：System.Data.SqlClient 3.引用命名空间 using System.Data; using System.Data.SqlClient; using Dapper; 4.使用 [Route("api/[controller]"
dapper mysql 预处理_.Net Core中Dapper的使用详解
weixin_34982726的博客
01-19 380
Dapper是一个轻量级ORM框架，在项目中如果对性能比较看中，Dapper是一个不错的选择。接下来我们就来看看如何在项目中使用Dapper.1.安装Dapper这里直接使用Nuget安装。安装完成之后，发现Nuget下已经有了Dapper。2.创建DapperHelper接下来创建一个DapperHelper帮助类，来进行读取数据库连接字符串，打开数据库等操作。代码：public class ...
Re0:在.NetCore 中Dapper的基本用法
aboya1989的博客
04-08 503
整理一下目前在用的Dapper 与FrameWork不同，NetCore数据库配置需要从appsettings.json中获取 刚接触的时候被这块坑了，自己手动建了个app.config。然后你懂的（笑哭） 读取配置文件： 1 public class AppSetting 2 { 3 private static readonly obje...
C#进阶-Dapper原理解析与使用教程
最新发布
cnzzs的博客
07-29 625
本文详细介绍了Dapper在C#中的使用方法，包括Dapper的基本概念、与其他持久层框架的比较、基本语法和高级语法的使用，并通过实例讲解了如何在项目中集成和使用Dapper。最后，总结了Dapper的优缺点及其在实际开发中的应用场景。一、Dapper介绍1. Dapper介绍Dapper是一个轻量级的ORM(对象关系映射...
.Net Core中Dapper的使用详解
weixin_30216561的博客
01-13 961
Dapper是一个轻量级ORM框架，在项目中如果对性能比较看中，Dapper是一个不错的选择。接下来我们就来看看如何在项目中使用Dapper. 1.安装Dapper 　　这里直接使用Nuget安装。 安装完成之后，发现Nuget下已经有了Dapper。 2.创建DapperHelper 　　接下来创建一个DapperHelper帮助类，来进行读取数据库连接字符串，打开数...
.netcore Dapper
qq_18932003的博客
10-13 260
Dapper原来还可以直接这样写SQL，很强大哦 摘要：网络上对Dapper的解释是这样的： Dapper是一个简单的.NET对象映射器，在速度方面具有"King of Micro ORM"的头衔，几乎与使用原始的ADO.NET数据读取器一样快。 ORM是一个对象关系映射器，它负责数据库和编程语言之间的映射。Dapper通过扩展IDbConnection阅读全文 posted @2021-01-28 00:11天天向上518阅读(283)评论(0)推荐(0)编辑 Dapper，Dappe...
.net core dapper CRUD例子（前段用bootstrap+ajax）.zip
07-24
.net core dapper CRUD例子（前段用bootstrap+ajax）使用开发工具: Visual Studio 2017 开发技术: .Net core MVC + Dapper
使用 Dapper 进行ASP.NET Core Web API 开发实践
caifox的博客
11-06 1154
Dapper相对来说，操作比较简单，容易上手，只需要引用一个库文件，而且对多种数据库支持都比较友好，如果希望更简单，还可以下载Dapper的扩展方法Dapper.SimpleCRUD进行更简洁的操作，到这里，你是否有一种跃跃欲试的感觉，赶紧行动起来吧！
Net Core中数据库事务隔离详解——以Dapper和Mysql为例
Dotnet Technology Blog
01-21 972
本节通过Dapper对MySql中事务的四种隔离级别下进行测试，并且指出事务之间的相互关系和问题以供大家参考。1、事务1隔离级别为时，可以读取其它任何事务隔离级别下未提交的数据2、事务1隔离级别为时，不可以读取其它事务未提交的数据，但是允许其它事务对数据表进行查询、添加、修改和删除;并且可以将其它事务增删改重新获取出来。3、事务1隔离级别为时，不可以读取其它事务未提交的数据，但是允许其它事务对数据表进行查询、添加、修改和删除;但是其它事务的增删改不影响事务1的查询结果4、事务1隔离级别为。
ASP.NET源码——[企业]商务维基网源码.zip
10-10
1. **ASP.NET架构**：ASP.NET基于.NET Framework，提供了一种模型-视图-控制器（MVC）架构，支持多种编程模型，如Web Forms、ASP.NET Core（跨平台）、SignalR等。在这个商务维基网源码中，我们可以看到如何利用ASP...
ASP.NET源码——[图片动画]视频分享平台程序.zip
10-18
1. **ASP.NET架构**：ASP.NET基于.NET Framework或.NET Core运行时，提供多种Web应用程序模型，如ASP.NET MVC、ASP.NET Web Forms、ASP.NET Core和ASP.NET SignalR等。在这个项目中，可能是使用MVC（Model-View-...
.NET Core使用Dapper操作MySQL
01-20
.NETCore使用Dapper操作MySQL数据库，.NETCore使用Dapper。目前官方没有出.NETCoreMySQL驱动，但是已经有第三方进行改动封装出.NETCoreMySQLConnector预览版。Dapper也已经出了.NETCore预览版。Dapperdotnet是一个轻量型的ORM，但是性能很强大。有了.NETCoreMySQLConnector我们可以直接使用ADO.NET操作数据库。 　　目前EFCore暂时不支持MySQL，本篇主要讲解使用Dapper操作MySQL。 　　第三方MySQLConnector:https://github.com/Sapient
dotnet-基于Dapper提供极简迅速强大的增删改查功能支持netcore
08-15
基于Dapper提供极简、迅速、强大的增删改查功能。支持.netcore
ASP.NET源码——[搜索链接]zhao53搜索引擎.zip
10-10
开发者可能使用ADO.NET、Entity Framework或Dapper等库来与SQL Server或其他数据库进行交互，执行索引更新和查询操作。 4. **索引构建**：搜索引擎会抓取互联网上的网页，提取内容并建立索引。这部分可能涉及线程...
在.NET数据库访问方面的Dapper类库介绍
weixin_34319999的博客
05-08 256
在开发带数据库的.NET系统中我使用过各种方式，包括直接使用ADO.NET、使用基于ADO.NET封装的各类工具（其中有自己封装的）、还有各类ORM类库，比如NHibernate、MyBatisNet、Linq to SQL、Entity Framwrok等，在上面的工具或类库中，MyBatisNet一段时间曾是我的最爱：由于它基于XML的配置可以灵活适应一些特殊的场景，不过有时候在面对中小型项目...
DotNetCore跨平台~Dapper的使用
weixin_34417200的博客
11-16 174
回到目录 Dapper作为小型ORM的代表作品被我们应用到了dotnet core的项目中，下面将把自己在项目中使用dapper进行curd操作的过程写一下，后期可能会遇到一些问题，大叔也会在这个系列之中进行完善，希望对各位学生有所帮助！ 一 安装nuget的dapper包包 二 在startup中注册dapper仓储，并现时注册数据库类型和数据库连接串，因为在mysql和sqlserv...
.NET轻量级ORM框架Dapper入门精通
跟着阿笨一起玩NET
05-11 1308
一、课程介绍 本次分享课程包含两个部分《.NET轻量级ORM框架Dapper修炼手册》和《.NET轻量级ORM框架Dapper葵花宝典》，阿笨将带领大家一起领略轻量级ORM框架Dapper的魅力。 本次分享课程适合人群范围： 一、《.NET轻量级ORM框架Dapper修炼手册》适合人群如下: 1、我是一个新手，主要工作面向的是MS SQL Server数据库，那么选择修炼手册一定没错。 ...
Dapper in .Net Core
weixin_55305220的博客
01-10 546
一、前言 　　关于什么是Dapper，在此不做赘述；本文仅对Dapper在.Net Core中的使用作扼要说明，所陈代码以示例讲解为主，乃抛砖引玉，开发者可根据自身需要进行扩展和调整；其中如有疏漏之处，望不吝斧正。 二、Dapper环境搭建 当前以.Net Core WebAPI或MVC项目为例，框架版本为.NET 5.0，相关NuGet包引用如下： Install-Package Dapper Install-Package Dapper.Contrib Install-Package Dap
.net core Dapper for MySql
weixin_34292287的博客
01-08 306
Dapper 语法比较简单，效率也比较快，速度接近IDataReader 甚至读取数据超过了DataTable，建议在实际项目可以结合EntityFramework Core 一起使用。 一、创建MySql Table  CREATE TABLE User ( Id int(11) NOT NULL AUTO_INCREMENT, Name varchar(255) DEFAU...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值