C#Dapper 帮助类

最新推荐文章于 2024-08-19 19:00:00 发布
最新推荐文章于 2024-08-19 19:00:00 发布
阅读量981 收藏 3
点赞数
文章标签： c# sqlserver
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_CSyLYH/article/details/123709286
版权

连接类 引用

using System.Data;
using System.Data.SqlClient;
using Microsoft.Extensions.Configuration;

连接类代码

public class DbHelper
    {   
        private static IDbConnection dbConnection = null;
        public static IConfiguration Configuration { get; set; }
        private static DbHelper uniqueInstance;
        private static readonly object locker = new object();
        
        public DbHelper(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        /// <summary>
        /// 创建数据库连接
        /// </summary>
        /// <returns></returns>
        public static IDbConnection CreateConnection()
        {
            IDbConnection connection = null;
            connection = new SqlConnection(Configuration["Dbconn"]);
            return connection;
        }
        /// <summary>
        /// 创建数据库连接对象并打开链接
        /// </summary>
        /// <returns></returns>
        public static IDbConnection OpenCurrentDbConnection()
        {
            //判断是否连接
            if (dbConnection == null)
            {
                dbConnection = CreateConnection();
            }
            //判断连接状态
            if (dbConnection.State == ConnectionState.Closed)
            {
                dbConnection.Open();
            }
            return dbConnection;
        }
        /// <summary>
        /// 获取实例，这里为单例模式，保证只存在一个实例
        /// </summary>
        /// <returns></returns>
        public static DbHelper GetInstance(IConfiguration configuration)
        {
            // 双重锁定实现单例模式，在外层加个判空条件主要是为了减少加锁、释放锁的不必要的损耗
            if (uniqueInstance == null)
            {
                lock (locker)
                {
                    if (uniqueInstance == null)
                    {
                        uniqueInstance = new DbHelper(configuration);
                    }
                }
            }
            return uniqueInstance;
        }
    }

操作类 引用

using Dapper;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

操作类代码

public class DbContext 
    {
        private readonly IConfiguration configuration;

        public DbContext(IConfiguration configuration)
        {
            this.configuration = configuration;
        }

        // 获取开启数据库的连接
        private IDbConnection Db
        {
            get
            {
                DbHelper.GetInstance(configuration);//创建单一实例
                return DbHelper.OpenCurrentDbConnection();//打开连接
            }
        }
        /// <summary>
        /// 查询列表
        /// </summary>
        /// <param name="sql">查询的sql</param>
        /// <param name="param">替换参数</param>
        /// <returns></returns>
        public async Task<List<dynamic>> Query(string sql, object param = null)
        {
            return Db.Query<dynamic>(sql, param).ToList();
        }
        /// <summary>
        /// 查询列表
        /// </summary>
        /// <param name="sql">查询的sql</param>
        /// <param name="param">替换参数</param>
        /// <returns></returns>
        public async Task<List<T>> Query<T>(string sql, object param = null)
        {
            return (await Db.QueryAsync<T>(sql, param)).ToList();
        }
        /// <summary>
        /// 查询第一个数据
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public dynamic QueryFirst(string sql, object param)
        {
            return Db.QueryFirst<dynamic>(sql, param);
        }

        /// <summary>
        /// 查询第一个数据没有返回默认值
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public dynamic QueryFirstOrDefault(string sql, object param)
        {
            return Db.QueryFirstOrDefault<dynamic>(sql, param);
        }

        /// <summary>
        /// 查询单条数据
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public dynamic QuerySingle(string sql, object param)
        {
            return Db.QuerySingle<dynamic>(sql, param);
        }
        public async Task<T> QuerySingle<T>(string sql, object parame)
        {
            return await Db.QuerySingleAsync<T>(sql, parame);
        }

        /// <summary>
        /// 查询单条数据没有返回默认值
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public dynamic QuerySingleOrDefault(string sql, object param)
        {
            return Db.QuerySingleOrDefault<dynamic>(sql, param);
        }

        /// <summary>
        /// 增删改
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public int Execute(string sql, object param)
        {
            return Db.Execute(sql, param);
        }

        public Task<int> ExecuteAsync(string sql, object param)
        {
            return Db.ExecuteAsync(sql, param);
        }

        /// <summary>
        /// Reader获取数据
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public IDataReader ExecuteReader(string sql, object param)
        {
            return Db.ExecuteReader(sql, param);
        }

        /// <summary>
        /// Scalar获取数据
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public object ExecuteScalar(string sql, object param)
        {
            return Db.ExecuteScalar(sql, param);
        }

        /// <summary>
        /// Scalar获取数据
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public dynamic ExecuteScalarForT(string sql, object param)
        {
            return Db.ExecuteScalar<dynamic>(sql, param);
        }
        /// <summary>
        /// Scalar获取数据
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public dynamic ExecuteScalarAsync<T>(string sql, object param)
        {
            return Db.ExecuteScalarAsync<T>(sql, param);
        }
        /// <summary>
        /// 带参数的存储过程
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public List<dynamic> ExecutePro(string proc, object param)
        {
            List<dynamic> list = Db.Query<dynamic>(proc,
                param,
                null,
                true,
                null,
                CommandType.StoredProcedure).ToList();
            return list;
        }


        /// <summary>
        /// 事务1 - 全SQL
        /// </summary>
        /// <param name="sqlarr">salarr</param>
        /// <returns></returns>
        public int ExecuteTransaction(string[] sqlarr)
        {
            using (var transaction = Db.BeginTransaction())
            {
                try
                {
                    int result = 0;
                    foreach (var sql in sqlarr)
                    {
                        result += Db.Execute(sql, null, transaction);
                    }
                    transaction.Commit();
                    return result;
                }
                catch (Exception)
                {
                    transaction.Rollback();
                    return 0;
                }
            }
        }

        /// <summary>
        /// 事务2 - 声明参数
        /// </summary>
        /// <param name="dic">dic.add(sql,param)</param>
        /// <returns></returns>
        public async Task<int> ExecuteTransaction(Dictionary<string, object> dic)
        {
            using (var transaction = Db.BeginTransaction())
            {
                try
                {
                    int result = 0;
                    foreach (var sql in dic)
                    {
                        result += await Db.ExecuteAsync(sql.Key, sql.Value, transaction);
                    }
                    transaction.Commit();
                    return result;
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    return 0;
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TIn"></typeparam>
        /// <param name="model"></param>
        /// <param name="tableName"></param>
        /// <param name="hasAuto"></param>
        /// <returns></returns>
        public async Task<bool> InsertAsync<TIn>(TIn model, string tableName = "", bool hasAuto = false)
        {
            if (string.IsNullOrEmpty(tableName))
                tableName = model.GetType().Name;

            var sql = GetInserSql<TIn>(tableName, hasAuto);

            long row = await Db.ExecuteAsync(sql, model);
            return row > 0 ? true : false;
        }
        /// <summary>
        /// 执行插入脚本，并返回自动生成的ID
        /// </summary>
        /// <typeparam name="TType"></typeparam>
        /// <param name="tableName"></param>
        /// <param name="haveAuto"></param>
        /// <returns></returns>
        private static string GetInserSql<TType>(string tableName, bool haveAuto)
        {
            //  todo 未来针对类型，添加语句缓存
            var properties = typeof(TType).GetProperties();

            var sqlCols = new StringBuilder("INSERT INTO ");
            sqlCols.Append(tableName).Append(" (");

            var sqlValues = new StringBuilder(" VALUES (");
            var isStart = false;

            foreach (var propertyInfo in properties)
            {
                if (isStart)
                {
                    sqlCols.Append(",");
                    sqlValues.Append(",");
                }
                else
                    isStart = true;
                sqlCols.Append(propertyInfo.Name);
                sqlValues.Append("@").Append(propertyInfo.Name);
            }
            sqlCols.Append(")");
            sqlValues.Append(")");
            sqlCols.Append(sqlValues);

            //if (haveAuto)
            //    sqlCols.Append(";SELECT CAST(SCOPE_IDENTITY()  AS BIGINT) AS [Id];");
            return sqlCols.ToString();
        }
        /// <summary>
        /// 根据对象实体生成对应的更新脚本
        /// </summary>
        /// <returns></returns>
        public async Task<bool> UpdateAsync<TIn>(Expression<Func<TIn, object>> update, Expression<Func<TIn, bool>> where, object mo = null, string tableName = "")
        {
            if (string.IsNullOrEmpty(tableName))
            {
                tableName = typeof(TIn).Name;
            }
            var visitor = new SqlExpressionVisitor();

            var updateSql = GetVisitExpressSql(visitor, update, SqlVistorType.Update);
            var whereSql = GetVisitExpressSql(visitor, where, SqlVistorType.Where);
            var sql = string.Concat("UPDATE ", tableName, " SET ", updateSql, whereSql);

            var paras = GetExcuteParas(mo, visitor);
            var row = await Db.ExecuteAsync(sql, paras);
            return row > 0 ? true : false;
        }
        /// <summary>
        ///   处理where条件表达式，如果表达式为空，默认使用Id
        /// </summary>
        /// <param name="visitor"></param>
        /// <param name="exp"></param>
        /// <param name="visType"></param>
        private static string GetVisitExpressSql(SqlExpressionVisitor visitor, Expression exp, SqlVistorType visType)
        {
            if (visType == SqlVistorType.Update)
            {
                var updateFlag = new SqlVistorFlag(SqlVistorType.Update);
                visitor.Visit(exp, updateFlag);
                return updateFlag.Sql;
            }

            var whereFlag = new SqlVistorFlag(SqlVistorType.Where);
            visitor.Visit(exp, whereFlag);
            var sql = string.Concat(" WHERE ", whereFlag.Sql);


            return sql;
        }
        /// <summary>
        /// 获取常量与属性列表
        /// </summary>
        /// <param name="mo"></param>
        /// <param name="visitor"></param>
        /// <returns></returns>
        private static object GetExcuteParas(object mo, SqlExpressionVisitor visitor)
        {
            if (!visitor.Parameters.Any())
            {
                return mo;
            }
            var paras = new DynamicParameters(visitor.Parameters);
            if (mo == null || !visitor.Properties.Any())
            {
                return paras;
            }
            paras.AddDynamicParams(mo);
            return paras;
        }
TXDZ_L
关注
c# dapper帮助类
weixin_43474597的博客
02-26 711
DapperHelper Daaper帮助类 数据库 为 mysql 如果用sqlserver 直接把代码中的Mysql改成Sql即可 代码片. public class DapperHelper<T> { /// <summary> /// 数据库连接字符串 /// </summary> private static readonly string connectionString ="";
dapper帮助类
weixin_47142884的博客
07-07 682
using System; using System.Collections.Generic; using System.Configuration; using System.Data; using System.Data.Common; using System.Data.SqlClient; using System.Linq; using Dapper; namespace DAL { public class DapperHelper { /// /// 数据库连接字符串 /// privat
C# Dapper帮助类
技术分享博客
06-13 1347
C# dapper帮助类
C# Dapper 入门指南：轻量级 ORM 的魅力
最新发布
java专栏
08-19 687
你可以自定义类型转换。你可以自定义命令行为。db.Open();} }有时你需要使用自定义的连接字符串。db.Open();} }你可以添加日志记录来调试应用程序。db.Open();自定义错误处理可以提高用户体验。try {throw;} } }Dapper 默认使用连接池。
dapper帮助类(全异步编程)
10-16
ConnectionString为正常的连接字符串，放在xml里或者程序内都可以，dapper是最快速的轻量级ORM之一，百用不厌 支持批量插入、批量修改
C#Dapper类
05-17
Dapper类是一个开源的数据库操作类,使用这个类会人你的程序的数据访问方式更加简单
Dapper 帮助类
qq_34811513的博客
01-30 231
【代码】Dapper 帮助类。
c# dapper 帮助类
07-18
### 回答1： c是英文字母表中的第三个字母。它的发音类似于“西”。在中文中，c并没有独立的发音，通常与其他字母一起组成拼音。 在数学和科学领域，c通常用来表示光速（speed of light），这个值约为每秒299,792,...
【Dapper封装类】
08-16
Dapper封装类，对dapper的增删查改和存储过程进行封装
dapper mysql通用类_C#操作MySql数据库帮助类（Dapper,T-Sql）
weixin_36035585的博客
01-26 130
usingSystem.Text;usingMySql.Data.MySqlClient;usingSystem.Data;usingDapper;usingSystem.Reflection;namespaceDbHelper{public classMySqlHelper{private string connectionStr = "server=localhost;database=fxy...
Dapper工具类
03-06
Dapper工具类，简单封装增删改成查，支持事务（BeginTran AddCommand ExecuteTran）
.net MVC dapper 帮助类
小欧
08-21 517
using System; using System.Collections.Generic; using System.Configuration; using System.Data; using System.Data.SqlClient; using System.Linq; using System.Reflection; using Dapper; namespace BaseDa...
C#-Dapper分页帮助类
weixin_40436005的博客
08-04 54
登录后复制 using Dapper; using System.Collections.Generic; using System.Data; using System.Text; namespace DBDapper { /// <summary> /// 分页帮助类 /// &...
自己 简单封装的 dapper help 类
new Girl的博客
04-04 2316
using Dapper; using Microsoft.Extensions.Configuration; using System; using System.Collections.Generic; using System.Data; using System.Data.SqlClient; using System.Linq; using ToneCommon.CommonMet...
C#封装一个DapperHelper
一个专注于技术研究创新的程序员
03-06 655
C#封装一个DapperHelper。
Dapper，DapperHelper帮助类常用的CURD帮助类简单封装
qq_18932003的博客
08-30 1119
部分函数，只要用来Mysql的操作，如果需要存储过程等请自行稍作修改为缺省值的通用方式，代码完全个人手敲已经测试验证ok 已经使用在项目中，有点开心！代码还可以进一步去优化，如封装为泛型委托的形式 using Microsoft.Extensions.Configuration; using System; using System.Collections.Generic; using System.Text; namespace ZRF.ESB.Common.Helper { using
C#调用Dapper
weixin_43497445的博客
09-06 1400
安装Dapper NuGet包：在Visual Studio解决方案中，右键单击项目名称，选择“管理NuGet程序包”，然后在搜索框中输入“Dapper”进行搜索。选择Dapper并安装。引用Dapper命名空间：在使用Dapper之前，需要在代码文件中引用Dapper命名空间。配置数据库连接字符串：在应用程序的配置文件（app.config或web.config）中，需要配置数据库连接字符串。以上就是Dapper的使用介绍，它可以帮助.NET开发人员处理数据库操作，提高开发效率。
DapperHelper 帮助类
weixin_33794672的博客
11-17 2294
using System; using System.Collections.Generic; using System.Configuration; using System.Data; using System.Data.Common; using System.Data.SqlClient; using System.Linq; using Dapper; namespace DAL { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值