ASP.NET Core中使用Dapper
⒈添加 NuGet 包
Install-Package Dapper
⒉封装数据库类型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks; namespace DapperDemo.Data
{
/// <summary>
/// 数据库类型
/// </summary>
public enum DbType
{
Access,
SqlServer,
Oracle,
MySql,
SqlLite
}
}
⒊封装数据库连接仓库
using Microsoft.Extensions.Configuration;
using MySql.Data.MySqlClient;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Threading.Tasks; namespace DapperDemo.Data
{
public class DbConnectionFactory
{
/// <summary>
/// 数据库连接字符串缓存
/// </summary>
private static ConcurrentDictionary<string, string> connStrDict = new ConcurrentDictionary<string, string>();
private static IConfiguration Configuration { get; }
private static string GetConnString(string dbKey)
{
string connString = string.Empty;
if (connStrDict.Keys.Contains(dbKey))
{
connString = connStrDict[dbKey];
}
else
{
connString = Configuration[$"ConnectionStrings:{dbKey}"];
connStrDict.TryAdd(dbKey, connString);
}
return connString;
} public static IDbConnection GetConnection(string dbKey, DbType dbType = DbType.SqlServer)
{
IDbConnection connObj = null;
switch (dbType)
{
case DbType.SqlServer:
connObj = new SqlConnection(GetConnString(dbKey));
break;
case DbType.MySql:
connObj = new MySqlConnection(GetConnString(dbKey));
break;
case DbType.Access:
//connObj = new OleDbConnection(GetConnString(dbKey));
break;
case DbType.SqlLite:
break;
case DbType.Oracle:
break;
} if (connObj.State != ConnectionState.Open)
{
connObj.Open();
} return connObj;
} /// <summary>
/// 获取数据连接
/// </summary>
/// <param name="connectionString"></param>
/// <param name="dbType"></param>
/// <returns></returns>
public static IDbConnection GetConnectionByConnString(string connString, DbType dbType = DbType.SqlServer)
{
IDbConnection connObj = null;
switch (dbType)
{
case DbType.SqlServer:
connObj = new SqlConnection(connString);
break;
case DbType.MySql:
connObj = new MySqlConnection(connString);
break;
case DbType.Access:
//connObj = new OleDbConnection(connString);
break;
case DbType.SqlLite:
break;
case DbType.Oracle:
break;
} if (connObj.State != ConnectionState.Open)
{
connObj.Open();
} return connObj;
}
}
}
⒋封装数据库常见方法
using Dapper;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Threading.Tasks; namespace DapperDemo.Data
{
public class DbRepository
{
private IDbConnection _connection { get; set; }
public string dbConnKey { get; set; }
public DbType dbType { get; set; } public DbRepository(string dbConnKey, DbType dbType = DbType.SqlServer)
{
this.dbConnKey = dbConnKey;
this.dbType = dbType;
} public DbRepository()
{ } public void Init(string dbConnKey, DbType dbType = DbType.SqlServer)
{
this.dbConnKey = dbConnKey;
this.dbType = dbType;
} #region 属性 /// <summary>
/// 获取数据库连接
/// </summary>
public IDbConnection Connection
{
get
{
if (_connection == null)
{
_connection = DbConnectionFactory.GetConnection(dbConnKey, dbType);
}
return _connection;
}
} /// <summary>
/// 事务对象
/// </summary>
public IDbTransaction dbTransaction { get; set; } #endregion #region 事务提交 /// <summary>
/// 事务开始
/// </summary>
/// <returns></returns>
public DbRepository BeginTrans()
{
dbTransaction = Connection.BeginTransaction();
return this;
} /// <summary>
/// 提交当前操作的结果
/// </summary>
public int Commit()
{
try
{
if (dbTransaction != null)
{
dbTransaction.Commit();
this.Close();
}
return ;
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException.InnerException is SqlException)
{
SqlException sqlEx = ex.InnerException.InnerException as SqlException;
}
throw;
}
finally
{
if (dbTransaction == null)
{
this.Close();
}
}
} /// <summary>
/// 把当前操作回滚成未提交状态
/// </summary>
public void Rollback()
{
this.dbTransaction.Rollback();
this.dbTransaction.Dispose();
this.Close();
} /// <summary>
/// 关闭连接 内存回收
/// </summary>
public void Close()
{
IDbConnection dbConnection = dbTransaction.Connection;
if (dbConnection != null && dbConnection.State != ConnectionState.Closed)
{
dbConnection.Close();
} } #endregion #region 实例方法 #region 查询 /// <summary>
/// 查询
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public T QueryFirst<T>(string sql, object param = null, bool buffered = true, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
if (dbTransaction == null)
{
using (var dbConn = Connection)
{
return dbConn.QueryFirstOrDefault<T>(sql, param, null, commandTimeout, commandType);
}
}
else
{
return dbTransaction.Connection.QueryFirstOrDefault<T>(sql, param, dbTransaction, commandTimeout, commandType);
} } /// <summary>
/// 查询(异步版本)
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public async Task<T> QueryFirstAsync<T>(string sql, object param = null, bool buffered = true, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
if (dbTransaction == null)
{
using (var dbConn = Connection)
{
return await dbConn.QueryFirstOrDefaultAsync<T>(sql, param, null, commandTimeout, commandType);
}
}
else
{
return await dbTransaction.Connection.QueryFirstOrDefaultAsync<T>(sql, param, dbTransaction, commandTimeout, commandType);
} } /// <summary>
/// 查询
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="buffered">是否缓冲</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public IEnumerable<T> Query<T>(string sql, object param = null, bool buffered = true, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
if (dbTransaction == null)
{
using (var dbConn = Connection)
{
return dbConn.Query<T>(sql, param, null, buffered, commandTimeout, commandType);
}
}
else
{
return dbTransaction.Connection.Query<T>(sql, param, dbTransaction, buffered, commandTimeout, commandType);
} } /// <summary>
/// 查询(异步版本)
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="buffered">是否缓冲</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public async Task<IEnumerable<T>> QueryAsync<T>(string sql, object param = null, bool buffered = true, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
if (dbTransaction == null)
{
using (var dbConn = Connection)
{
return await dbConn.QueryAsync<T>(sql, param, null, commandTimeout, commandType);
}
}
else
{
return await dbTransaction.Connection.QueryAsync<T>(sql, param, dbTransaction, commandTimeout, commandType);
} } /// <summary>
/// 查询返回 IDataReader
/// </summary>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public IDataReader ExecuteReader(string sql, object param = null, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
if (dbTransaction == null)
{
using (var dbConn = Connection)
{
return dbConn.ExecuteReader(sql, param, null, commandTimeout, commandType);
}
}
else
{
return dbTransaction.Connection.ExecuteReader(sql, param, dbTransaction, commandTimeout, commandType);
}
} /// <summary>
/// 查询单个返回值
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public T ExecuteScalar<T>(string sql, object param = null, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
if (dbTransaction == null)
{
using (var dbConn = Connection)
{
return dbConn.ExecuteScalar<T>(sql, param, null, commandTimeout, commandType);
}
}
else
{
return dbTransaction.Connection.ExecuteScalar<T>(sql, param, dbTransaction, commandTimeout, commandType);
} }
#endregion /// <summary>
/// 执行增删改sql
/// </summary>
/// <param name="sql">sql</param>
/// <param name="dbkey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public int ExecuteSql(string sql, object param = null, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
if (dbTransaction == null)
{
using (var dbConn = Connection)
{
return dbConn.Execute(sql, param, null, commandTimeout, commandType);
}
}
else
{
return dbTransaction.Connection.Execute(sql, param, dbTransaction);
}
} /// <summary>
/// 执行增删改sql(异步版本)
/// </summary>
/// <param name="sql">sql</param>
/// <param name="dbkey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public async Task<int> ExecuteSqlAsync(string sql, object param = null, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
if (dbTransaction == null)
{
using (var dbConn = Connection)
{
return await dbConn.ExecuteAsync(sql, param, null, commandTimeout, commandType);
}
}
else
{
await dbTransaction.Connection.ExecuteAsync(sql, param, dbTransaction);
return ;
}
} #endregion #region 静态方法 #region 查询
/// <summary>
/// 查询
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static T QueryFirst<T>(string sql, string dbConnKey, object param = null, DbType dbType = DbType.SqlServer, bool buffered = true, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbConnKey, dbType))
{
return dbConn.QueryFirstOrDefault<T>(sql, param, null, commandTimeout, commandType);
}
} /// <summary>
/// 查询(异步版本)
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static async Task<T> QueryFirstAsync<T>(string sql, string dbConnKey, object param = null, DbType dbType = DbType.SqlServer, bool buffered = true, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbConnKey, dbType))
{
return await dbConn.QueryFirstOrDefaultAsync<T>(sql, param, null, commandTimeout, commandType);
}
} /// <summary>
/// 查询
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="buffered">是否缓冲</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static IEnumerable<T> Query<T>(string sql, string dbConnKey, object param = null, DbType dbType = DbType.SqlServer, bool buffered = true, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbConnKey, dbType))
{
return dbConn.Query<T>(sql, param, null, buffered, commandTimeout, commandType);
}
} /// <summary>
/// 查询(异步版本)
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="buffered">是否缓冲</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static async Task<IEnumerable<T>> QueryAsync<T>(string sql, string dbConnKey, object param = null, DbType dbType = DbType.SqlServer, bool buffered = true, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbConnKey, dbType))
{
return await dbConn.QueryAsync<T>(sql, param, null, commandTimeout, commandType);
}
} /// <summary>
/// 查询返回 IDataReader
/// </summary>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static IDataReader ExecuteReader(string sql, string dbConnKey, object param = null, DbType dbType = DbType.SqlServer, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbConnKey, dbType))
{
return dbConn.ExecuteReader(sql, param, null, commandTimeout, commandType);
}
} /// <summary>
/// 查询单个返回值
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="sql">sql语句</param>
/// <param name="dbConnKey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static T ExecuteScalar<T>(string sql, string dbConnKey, object param = null, DbType dbType = DbType.SqlServer, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbConnKey, dbType))
{
return dbConn.ExecuteScalar<T>(sql, param, null, commandTimeout, commandType);
}
} #endregion #region 增删改 /// <summary>
/// 执行增删改sql
/// </summary>
/// <param name="sql">sql</param>
/// <param name="dbkey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static int Execute(string sql, string dbkey, object param = null, DbType dbType = DbType.SqlServer, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbkey, dbType))
{
return dbConn.Execute(sql, param, null, commandTimeout, commandType);
}
} /// <summary>
/// 执行增删改sql(异步版本)
/// </summary>
/// <param name="sql">sql</param>
/// <param name="dbkey">数据库连接</param>
/// <param name="param">sql查询参数</param>
/// <param name="commandTimeout">超时时间</param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static async Task<int> ExecuteAsync(string sql, string dbkey, object param = null, DbType dbType = DbType.SqlServer, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbkey, dbType))
{
return await dbConn.ExecuteAsync(sql, param, null, commandTimeout, commandType);
}
} /// <summary>
/// 执行 DynamicQuery.GetInsertQuery* 方法生成的Sql 返回标识值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="dbKey"></param>
/// <param name="param"></param>
/// <param name="commandTimeout"></param>
/// <param name="commandType"></param>
/// <returns></returns>
public static T ExecuteInsertSql<T>(string sql, string dbKey, object param = null, DbType dbType = DbType.SqlServer, int? commandTimeout = default(int?), CommandType? commandType = default(CommandType?))
{
using (var dbConn = DbConnectionFactory.GetConnection(dbKey, dbType))
{
return dbConn.QueryFirstOrDefault<T>(sql, param, null, commandTimeout, commandType);
}
} #endregion #endregion }
}
ASP.NET Core中使用Dapper的更多相关文章
- .NET Core中使用Dapper操作Oracle存储过程最佳实践
为什么说是最佳实践呢?因为在实际开发中踩坑了,而且发现网上大多数文章给出的解决方法都不能很好地解决问题.尤其是在获取类型为OracleDbType.RefCursor,输出为:ParameterDir ...
- NET Core中使用Dapper操作Oracle存储过程
.NET Core中使用Dapper操作Oracle存储过程最佳实践 为什么说是最佳实践呢?因为在实际开发中踩坑了,而且发现网上大多数文章给出的解决方法都不能很好地解决问题.尤其是在获取类型为Or ...
- 如何在ASP.NET Core中编写高效的控制器
通过遵循最佳实践,可以编写更好的控制器.所谓的"瘦"控制器(指代码更少.职责更少的控制器)更容易阅读和维护.而且,一旦你的控制器很瘦,可能就不需要对它们进行太多测试了.相反,你可 ...
- ASP.NET Core 中的那些认证中间件及一些重要知识点
前言 在读这篇文章之间,建议先看一下我的 ASP.NET Core 之 Identity 入门系列(一,二,三)奠定一下基础. 有关于 Authentication 的知识太广,所以本篇介绍几个在 A ...
- Asp.net Core中使用Session
前言 2017年就这么悄无声息的开始了,2017年对我来说又是特别重要的一年. 元旦放假在家写了个Asp.net Core验证码登录, 做demo的过程中遇到两个小问题,第一是在Asp.net Cor ...
- 在ASP.NET Core中使用百度在线编辑器UEditor
在ASP.NET Core中使用百度在线编辑器UEditor 0x00 起因 最近需要一个在线编辑器,之前听人说过百度的UEditor不错,去官网下了一个.不过服务端只有ASP.NET版的,如果是为了 ...
- ASP.NET Core中的依赖注入（1）：控制反转（IoC）
ASP.NET Core在启动以及后续针对每个请求的处理过程中的各个环节都需要相应的组件提供相应的服务,为了方便对这些组件进行定制,ASP.NET通过定义接口的方式对它们进行了"标准化&qu ...
- ASP.NET Core中的依赖注入（2）：依赖注入（DI）
IoC主要体现了这样一种设计思想:通过将一组通用流程的控制从应用转移到框架之中以实现对流程的复用,同时采用"好莱坞原则"是应用程序以被动的方式实现对流程的定制.我们可以采用若干设计 ...
- ASP.NET Core中的依赖注入（3）: 服务的注册与提供
在采用了依赖注入的应用中,我们总是直接利用DI容器直接获取所需的服务实例,换句话说,DI容器起到了一个服务提供者的角色,它能够根据我们提供的服务描述信息提供一个可用的服务对象.ASP.NET Core ...
随机推荐
- codeforces405D
Toy Sum CodeForces - 405D Little Chris is very keen on his toy blocks. His teacher, however, wants C ...
- reduce()之js与python
最近在自学python基础,发现很多js中的内置函数python中都存在,甚至比js更加简洁,下面说一下reduce()在js和python中的用法,做个对比便于记忆. reduce()简介: red ...
- PHP反序列化学习
在理解这个漏洞前,你需要先搞清楚php中serialize(),unserialize()这两个函数. 序列化serialize() 序列化说通俗点就是把一个对象变成可以传输的字符串,比如下面是一个对 ...
- nodejs豆瓣爬虫
从零开始nodejs系列文章,将介绍如何利Javascript做为服务端脚本,通过Nodejs框架web开发.Nodejs框架是基于V8的引擎,是目前速度最快的Javascript引擎.chrome浏 ...
- 1分钟快速制作漂亮的Html5本地记事本
大家好,以前给大家分享过一个五步骤制作精美的HTML5时钟的文章,点击回顾<五步教你制作漂亮精致的HTML时钟>,还有<一分钟教你如何实现唯美的文字描边>:今天给大家分享一个用 ...
- MySort(选做)
一.题目要求 注意:研究sort的其他功能,要能改的动代码,需要答辩 模拟实现Linux下Sort -t : -k 2的功能. 要有伪代码,产品代码,测试代码(注意测试用例的设计) 参考 Sort的实 ...
- 自动更新文件夹下所有DLL 至最新修改时间版本
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; usin ...
- [Java读书笔记] Effective Java(Third Edition) 第2章 创建和销毁对象
第 1 条:用静态工厂方法代替构造器 对于类而言,获取一个实例的方法,传统是提供一个共有的构造器. 类可以提供一个公有静态工厂方法(static factory method), 它只是一个返回类 ...
- PHP(面向对象)连接数据库,实现基本的增删改查
https://blog.csdn.net/qq_37674858/article/details/78921485 --------------------- 本文来自 周子青 的CSDN 博客 , ...
- 堡垒机直接调用RUN
两个脚本 Run.vbe 参考https://blog.csdn.net/skypeGNU/article/details/12708221 set ws=wscript.createobject ...