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 ...
随机推荐
- 【原创】洛谷 LUOGU P3373 【模板】线段树2
P3373 [模板]线段树 2 题目描述 如题,已知一个数列,你需要进行下面两种操作: 1.将某区间每一个数加上x 2.将某区间每一个数乘上x 3.求出某区间每一个数的和 输入输出格式 输入格式: 第 ...
- Java学习笔记（持续更新ing）
1.在读入字符串时: str = sc.nextLine(); //读入一行 str = sc.next(); ...
- 【Android】【踩坑日记】RecyclerView获取子View的正确姿势
开发过程中发现RecyclerView.getChildAt(position)为空的情况,但是明明这个position却没有越界. 解决办法:用recycler.getLayoutManager() ...
- iOS中web app调试(mac)
原文 iOS中web app调试(mac).md 目录 一.真机联调配置 二.mac上Safari配置及真机联调 三.iOS模拟器使用 四.在iOS模拟器中安装app 近期公司vue项目开发,目的是一 ...
- 修改网卡缓存，解决Linux 网卡丢包严重问题
Linux 网卡丢包严重 生产中有一台linux设备并发比较大,droped包比较多,尤其是在跑游戏数据包的时候,存在严重的丢包现象,怀疑网卡性能不足,在更换设备前想能不有通过软件方法解决,通过网上一 ...
- Flutter移动电商实战 --（12）首页导航区域编写
1.导航单元素的编写 从外部看,导航是一个GridView部件,但是每一个导航又是一个上下关系的Column.小伙伴们都知道Flutter有多层嵌套的问题,如果我们都写在一个组件里,那势必造成嵌套严重 ...
- 【MyBatis】【SQL】没有最快，只有更快，从一千万条记录中删除八百万条仅用1分9秒
这次直接使用delete from emp where cdate<'2018-02-02',看看究竟会发生什么. Mapper里写好SQL: <?xml version="1. ...
- js 时间戳格式化日期格式
时间戳转换为日期,网上搜了好几个或多或少都有点问题,自己整理了一下,写了个方法 console.log(formatDate(1565280000000)) 输出: 2019-08-09 00:00: ...
- vacode查看已安装的插件
- LC 974. Subarray Sums Divisible by K
Given an array A of integers, return the number of (contiguous, non-empty) subarrays that have a sum ...