当前位置：
  1. 首页
  2. 市民
  3. 正文

一、前言

上一篇【】我们已经有了架构的轮廓，现在我们就在这个轮廓里面造轮子。项目要想开始，肯定先得确定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文档：

二、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的运用，我们才能够对他进行定制化的优化。

  

上一篇 1960属牛的多大，属牛的取名字宜用字
下一篇 属狗的嫁给属羊的好吗，男属羊的和什么属相最配

相关文章