ORM之Dapper运用
一、前言
上一篇【分层架构设计】我们已经有了架构的轮廓，现在我们就在这个轮廓里面造轮子。项目要想开始，肯定先得确定ORM框架，目前市面上的ORM框架有很多，对于.net人员来说很容易就想到以ADO.NET为基础所发展出来的ORM框架EntityFramework。不得不说EntityFramework是一个功能很强大的ORM框架，到现在最新的EF分别是EF6（.Net Framework）和EF Core（.Net Core）两个版本。
但是这里我使用的另一个叫Dapper的ORM框架，原因是因为EF太重了，而Dapper是一个轻量级开源的ORM类，他是通过扩展IDbConnection提供一些有用的扩展方法去查询您的数据库，所以Ado.Net支持的数据库，他都可以支持。在速度方面具有“King of Micro ORM”的头衔，几乎与使用原始的ADO.NET数据读取器一样快。第一次使用了他之后，就深深的喜欢上他了。
github地址：https://github.com/StackExchange/Dapper
Dapper文档：https://dapper-tutorial.net/dapper
二、Dapper实现
2.1、Dapper的方法
从Dapper文档中，我们知道，Dapper支持一下的方法：
Execute：执行一次或多次命令并返回受影响的行数，包括存储过程
Query：执行查询，返回类型为t的数据(返回数据为集合)
QueryFirst：执行查询并映射第一个结果，如果没有就为null
QueryFirstOrDefault：行查询并映射第一个结果，如果序列不包含任何元素，则可以映射默认值
QuerySingle：行查询并映射第一个结果，如果序列中没有一个元素，则抛出异常
QuerySingleOrDefault：执行查询并映射第一个结果，如果序列为空则映射默认值;如果序列中有多个元素，则此方法抛出异常
QueryMultiple：在同一命令中执行多个查询并映射结果
Dapper还提供了上面方法相同功能的异步方法，同时每个方法也支持多种形式的传参。
2.2、Dapper的使用
在前面的项目中，我们在 “04-DataLayer”文件下面添加类库“PFT.Snail.DataAccess”。PFT.Snail.DataAccess主要是 用来完成Dapper方法的使用。
在PFT.Snail.DataAccess项目下面创建文件“DapperSqlDB.cs”，代码如下：
public class DapperSqlDB
{
/// <summary>
/// 连接字符串
/// </summary>
public string ConnectionString { get; set; }
/// <summary>
/// 数据库连接时间
/// </summary>
private int _commondTimeout { get { return 1200; } } public DapperSqlDB()
{
}
public DapperSqlDB(string connectionString)
{
ConnectionString = connectionString;
} #region 查询 /// <summary>
/// 查询列表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public List<T> Query<T>(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return conn.Query<T>(sql, param, commandTimeout: _commondTimeout).ToList();
}
} /// <summary>
/// 异步查询列表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public async Task<IEnumerable<T>> QueryAsync<T>(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return await conn.QueryAsync<T>(sql, param, commandTimeout: _commondTimeout);
}
} /// <summary>
/// 查询列表第一条数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public T QueryFirstOrDefault<T>(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return conn.QueryFirstOrDefault<T>(sql, param, commandTimeout: _commondTimeout);
}
} /// <summary>
/// 异步查询列表第一条数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public async Task<T> QueryFirstOrDefaultAsync<T>(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return await conn.QueryFirstOrDefaultAsync<T>(sql, param, commandTimeout: _commondTimeout);
}
} /// <summary>
/// 查询选择单个值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public T ExecuteScalar<T>(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return conn.ExecuteScalar<T>(sql, param, commandTimeout: _commondTimeout);
}
} /// <summary>
/// 异步查询选择单个值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public async Task<T> ExecuteScalarAsync<T>(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return await conn.ExecuteScalarAsync<T>(sql, param, commandTimeout: _commondTimeout);
}
} /*调用方式
* var multi=DBSqlHelper.QueryMultiple("",null);
* var invoice = multi.Read<Invoice>().First();
* var invoiceItems = multi.Read<InvoiceItem>().ToList();
*/
/// <summary>
/// 执行多个查询并映射结果
/// </summary>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public GridReader QueryMultiple(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return conn.QueryMultiple(sql, param, commandTimeout: _commondTimeout);
} } /* 调用方式
* await DBSqlHelper.QueryMultipleAsync(sql, para, async (reader) =>
* {
* rs.A= (await reader.ReadFirstAsync<SingleValue<decimal>>()).Value;
* rs.B= (await reader.ReadFirstAsync<SingleValue<decimal>>()).Value;
* ...
* });
*/
/// <summary>
/// 异步执行多个查询并映射结果
/// </summary>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <param name="readerCallback"></param>
/// <returns></returns>
public async Task QueryMultipleAsync(string sql, object param, Action<GridReader> readerCallback)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
using (var reader = await conn.QueryMultipleAsync(sql, param, commandTimeout: _commondTimeout))
{
if (readerCallback != null)
{
readerCallback(reader);
}
} }
} #endregion #region 执行sql /// <summary>
/// 执行sql语句
/// </summary>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public int Execute(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return conn.Execute(sql, param, commandTimeout: _commondTimeout);
}
} /// <summary>
/// 异步执行sql语句
/// </summary>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public async Task<int> ExecuteAsync(string sql, object param)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return await conn.ExecuteAsync(sql, param, commandTimeout: _commondTimeout);
}
} /// <summary>
/// 执行sql语句（主要指存储过程）
/// </summary>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public int Execute(string sql, object param, CommandType type)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return conn.Execute(sql, param, commandTimeout: _commondTimeout, commandType: type);
}
} /// <summary>
/// 异步执行sql语句（主要指存储过程）
/// </summary>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public async Task<int> ExecuteAsync(string sql, object param, CommandType type)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
return await conn.ExecuteAsync(sql, param, commandTimeout: _commondTimeout, commandType: type);
}
}
#endregion }
同时Nuget添加System.Data.SqlClient和Dapper的引用。
上面已经实现了数据的增删改查操作，但是再使用过程就会发现，没有事务机制和分页功能。
添加事务功能
在PFT.Snail.DataAccess中添加接口“ITransaction.cs”
public interface ITransaction
{
List<T> Query<T>(string sql, object param);
T QueryFirstOrDefault<T>(string sql, object param);
T ExecuteScalar<T>(string sql, object param);
int Execute(string sql, object param); }
在“DapperSqlDB.cs”添加事务对象
#region 事务方法
/// <summary>
/// 事务执行方法对象
/// </summary>
private class Transaction : IDisposable, ITransaction
{
private IDbConnection conn = null;
private IDbTransaction tran = null;
public Transaction(IDbConnection conn, IDbTransaction tran)
{
this.conn = conn;
this.tran = tran;
}
List<T> ITransaction.Query<T>(string sql, object param)
{
return conn.Query<T>(sql, param, tran).ToList();
}
T ITransaction.QueryFirstOrDefault<T>(string sql, object param)
{
return conn.QueryFirstOrDefault<T>(sql, param, tran);
}
T ITransaction.ExecuteScalar<T>(string sql, object param)
{
return conn.ExecuteScalar<T>(sql, param, tran);
}
int ITransaction.Execute(string sql, object param)
{
return conn.Execute(sql, param, tran);
}
void IDisposable.Dispose()
{
if (this.tran != null)
{
this.tran.Dispose();
}
if (this.conn != null)
{
this.conn.Dispose();
}
}
}
#endregion
添加事务方法
/*调用方式
* DBSqlHelper.ExecuteTransaction((trans) =>
* {
* trans.Execute(sqlinsertct, selectedClass);
* trans.Execute(sqlinsertict, selectedClass);
* });
*/
/// <summary>
/// 事务方法
/// </summary>
/// <param name="tranAction"></param>
/// <param name="level"></param>
/// <param name="newConnectionString"></param>
public void ExecuteTransaction(Action<ITransaction> tranAction, IsolationLevel? level = null, string newConnectionString = null)
{
using (IDbConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
IDbTransaction tran = null;
if (level == null)
{
tran = conn.BeginTransaction();
}
else
{
tran = conn.BeginTransaction(level.Value);
}
using (Transaction tranHelper = new Transaction(conn, tran))
{
try
{
tranAction(tranHelper);
tran.Commit();
}
catch
{
tran.Rollback();
throw;
}
}
}
}
添加分页功能
在“PFT.Snail.Dto”中添加“Common”文件夹，下面在添加“PageResponse.cs”
/// <summary>
/// 通用分页返回
/// </summary>
/// <typeparam name="T"></typeparam>
public class PageResponse<T>
{
/// <summary>
/// 总条数
/// </summary>
public long TotalCount { get; set; } /// <summary>
/// 返回
/// </summary>
public List<T> Items { get; set; } /// <summary>
/// 当前页
/// </summary>
public long PageIndex { get; set; } /// <summary>
/// 每页条数
/// </summary>
public long PageSize { get; set; } /// <summary>
/// 总页数
/// </summary>
public long TotalPages { get; set; } /// <summary>
/// 返回筛选集合
/// </summary>
public Dictionary<string, List<string>> ResultFilter = new Dictionary<string, List<string>>(); }
在“DapperSqlDB.cs”添加分页功能
/// <summary>
/// Sqlserver 分页查询（只支持Sqlserver2012以上数据库）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="page"></param>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public PageResponse<T> QueryPageSql<T>(PageRequest page, string sql, object param)
{
var pageResult = new PageResponse<T>();
pageResult.PageIndex = page.PageIndex; var queryNumSql = new StringBuilder($"SELECT COUNT(1) FROM ({sql}) AS maptable");
pageResult.TotalCount = ExecuteScalar<int>(queryNumSql.ToString(), param);
if (pageResult.TotalCount == 0)
{
return pageResult;
} var pageMinCount = (page.PageIndex - 1) * page.PageSize + 1;
if (pageResult.TotalCount < pageMinCount)
{
page.PageIndex = (int)((pageResult.TotalCount - 1) / page.PageSize) + 1;
} var querySql = new StringBuilder($@"SELECT maptable.* FROM ({sql}) AS maptable ");
if (!string.IsNullOrWhiteSpace(page.SortBy))
{
querySql.AppendLine(page.GetOrderBySql());
}
querySql.AppendLine($" OFFSET {(page.PageIndex - 1) * page.PageSize} ROWS FETCH NEXT {page.PageSize} ROWS ONLY;"); pageResult.Items = Query<T>(querySql.ToString(), param);
return pageResult;
}
分页的代码只支持SQl2012以上的版本，如果是一下的版本，可以自己重构代码。
到现在才算把Dapper框架的运用方法全部实现了。
三、总结
虽然实现了Dapper框架的运用方法，但是在真实的项目中，运用这样的方法或多或少有很多不便。同时在架构的设计来说，也不是太合理，因为Repository依赖DapperSqlDB的具体实现，需要抽象出接口。既然存在所说的问题，那为什么不直接写出最终方法呢？这是因为必须弄清楚Dapper的运用，我们才能够对他进行定制化的优化。
ORM之Dapper运用的更多相关文章
- .NET轻量级ORM框架Dapper入门精通
一.课程介绍 本次分享课程包含两个部分<.NET轻量级ORM框架Dapper修炼手册>和<.NET轻量级ORM框架Dapper葵花宝典>,阿笨将带领大家一起领略轻量级ORM框架 ...
- .NET轻量级ORM组件Dapper葵花宝典
一.摘要 为什么取名叫<葵花宝典>? 从行走江湖的世界角度来讲您可以理解为一本"武功秘籍",站在我们IT编程的世界角度应该叫"开发宝典". 如果您在 ...
- .NET轻量级ORM组件Dapper修炼手册
一.摘要 1.1.为什么叫本次的分享课叫<修炼手册>? 阿笨希望本次的分享课中涉及覆盖的一些小技巧.小技能给您带来一些帮助.希望您在日后工作中把它作为一本实际技能手册进行储备,以备不时之需 ...
- ORM之Dapper
ORM之Dapper 一.下载安装: nuget 搜索dapper安装 二.使用: 三.优缺点: 优点: 1.开源.轻量.单文件(代码就一个SqlMapper.cs文件,编译后就40K的一个很小的Dl ...
- c# 国内外ORM 框架 dapper efcore sqlsugar freesql hisql sqlserver数据常规插入测试性能对比
c# 国内外ORM 框架 dapper efcore sqlsugar freesql hisql sqlserver数据常规插入测试性能对比对比 在6.22 号发布了 c# sqlsugar,his ...
- 轻型的ORM类Dapper
Dapper是一个轻型的ORM类.代码就一个SqlMapper.cs文件,主要是IDbConnection的扩展方法,编译后就40K的一个很小的dll.官方站点http://code.google.c ...
- 轻量型ORM框架Dapper的使用
在真实的项目开发中,可能有些人比较喜欢写SQL语句,但是对于EF这种ORM框架比较排斥,那么轻量型的Dapper就是一个不错的选择,即让你写sql语句了,有进行了关系对象映射.其实对于EF吧,我说下我 ...
- 对.net orm工具Dapper在多数据库方面的优化
Dapper是近2年异军突起的新ORM工具,它有ado.net般的高性能又有反射映射实体的灵活性,非常适合喜欢原生sql的程序员使用,而且它源码很小,十分轻便.我写本博客的目的不是为了介绍Dapper ...
- .NET 轻量级 ORM 框架 - Dapper 介绍
Dapper简单介绍: Dapper is a single file you can drop in to your project that will extend your IDbConnect ...
- 基于轻量级ORM框架Dapper的扩展说明
这里简单的介绍一下本人基于Dapper作的一些简单的扩展,供大家参考. 为何要使用这款框架,相信大家看到下面排名就清楚了 其实在各大网站上,我们大概都会看到这样的一个对比效果图,在超过500次poco ...
随机推荐
- Java基础的一些知识点（一）：接口interface
1.接口的含义 接口可以理解成统一的协议, 而接口中的属性也属于协议中的内容.但是接口的属性都是公共的,静态的,最终的. 接口的成员特点: 1.成员变量只能是常量,默认修饰符 public stati ...
- Go包管理工具dep
dep是一个golang依赖管理工具,需要在Go 1.7及更高的版本中使用. 1. 安装 安装dep工具的方式有很多种,如果是mac电脑的话,只需要如下命令: brew install dep 对于L ...
- ccf 201903-5 317号子任务（60分）
看到这题,第一印象,用dijkstra算法求n次单源最短路,时间复杂度O(n^3),超时30分妥妥的. 于是用优先队列优化,O(n*mlogm),快很多,但依然30. 那么不妨换一种思路,题目要求的是 ...
- 算法与数据结构基础 - 排序(Sort)
排序基础 排序方法分两大类,一类是比较排序,快速排序(Quick Sort).归并排序(Merge Sort).插入排序(Insertion Sort).选择排序(Selection Sort).希尔 ...
- powerdesign进军(一)--安装破解
目录 资源下载地址 安装powerdesign 破解powerdesign 汉化 总结 IT行业不管是web开发还是客户端开发都需要数据库,因为现在是数据时代能够拥有强大的数据就是行业的王者.目前一些 ...
- 【POJ - 3255】Roadblocks（次短路 Dijkstra算法）
Roadblocks 直接翻译了 Descriptions Bessie搬到了一个新的农场,有时候他会回去看他的老朋友.但是他不想很快的回去,他喜欢欣赏沿途的风景,所以他会选择次短路,因为她知道一定有 ...
- java并发系列 - 第29天：高并发中常见的限流方式
这是java高并发系列第29篇. 环境:jdk1.8. 本文内容 介绍常见的限流算法 通过控制最大并发数来进行限流 通过漏桶算法来进行限流 通过令牌桶算法来进行限流 限流工具类RateLimiter ...
- 记录 Java 的 BlockingQueue 中的一些坑
最近学习了 BlockingQueue,发现 java 的 BlockingQueue 并不是每一个实现都按照 BlockingQueue 的语意来的,其中有不少坑. 直接上代码吧: 1.关于Prio ...
- 记录一则LOCAL_LISTENER的问题
有网友反映,他在一套Oracle的测试环境中配置有两个监听,分别监听不同端口. 目前想把环境上的一套数据库同时注册到这两个监听,他将数据库参数local_listener和tnsname.ora文件配 ...
- 初探Electron，从入门到实践
本文由葡萄城技术团队于博客园原创并首发 转载请注明出处:葡萄城官网,葡萄城为开发者提供专业的开发工具.解决方案和服务,赋能开发者. 在开始之前,我想您一定会有这样的困惑:标题里的Electron ...