C# Dapper 简单实例

最新推荐文章于 2024-07-22 21:21:48 发布
最新推荐文章于 2024-07-22 21:21:48 发布
阅读量321 收藏
点赞数
文章标签： 人工智能 数据库

 

/// <summary>

 

/// 分页信息
/// </summary>
public class PageInfo<T>
    {
        /// <summary>
        /// 分页信息
        /// </summary>
        public PageInfo()
        {
        }
        /// <summary>
        /// 总页数
        /// </summary>
        public long TotalCount
        {
            get; set;
        }
        /// <summary>
        /// 
        /// </summary>
        public IEnumerable<T> Data
        {
            get; set;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="total"></param>
        /// <param name="data"></param>
        public PageInfo(long total, IEnumerable<T> data)
        {
            this.TotalCount = total;
            this.Data = data;
        }
    }

************* 

using DapperExtensions.Mapper;
using Statistics.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FlowStatistics
{
    public static class Mappings
    {
        public static void Initialize()
        {
            DapperExtensions.DapperExtensions.DefaultMapper = typeof(PluralizedAutoClassMapper<>);

            DapperExtensions.DapperExtensions.SetMappingAssemblies(new[]
            {
                typeof(Mappings).Assembly
            });
        }

        public class FlowCellMapper : ClassMapper<FlowCell>
        {
            public FlowCellMapper()
            {
                Table("jxc_flow_cell");
                //Map(fcel => fcel.id).Column("id");
                //Map(fcel => fcel.parent_id).Column("parent_id");
                //Map(fcel => fcel.create_time).Column("create_time");
                //Map(fcel => fcel.type_id).Column("type_id");
                Map(fcel => fcel.comId).Column("bloc_code");
                //Map(fcel => fcel.bloc_name).Column("bloc_name");
                //Map(fcel => fcel.cell_number).Column("cell_number");
                //Map(fcel => fcel.name).Column("name");
                //Map(fcel => fcel.flows).Column("flows");
                //Map(fcel => fcel.status).Column("status");
                //Map(fcel => fcel.del).Column("del");
                AutoMap();
            }
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Dapper;
using DapperExtensions;
using DapperExtensions.Sql;
using MySql.Data.MySqlClient;
using System.Data;
using Z.Dapper.Plus;

namespace FlowStatistics
{
    /// <summary>
    /// 数据客户端
    /// 参考：https://github.com/StackExchange/dapper-dot-net
    /// Predicates参考：https://github.com/tmsmith/Dapper-Extensions/wiki/Predicates
    /// https://github.com/zzzprojects/Dapper-Plus
    /// </summary>
    public class DbClient : IDisposable, IDbClient
    {
        string connStr = @"Data Source=.\sqlexpress;Initial Catalog=tempdb;Integrated Security=True;uid=sa;pwd=123456";      
        int commandTimeout = 30;
        /// <summary>
        /// 数据客户端
        /// </summary>
        /// <param name="connStr">数据库连接字符串</param>
        /// <param name="dbType">数据库类型</param>
        /// <param name="commandTimeout">操作超时,单位：秒</param>
        /// <param name="autoEditEntityTime">是否自动更实体对象的创建时间、更新时间</param>
        public DbClient(string connStr, int commandTimeout = 30)
        {
            if (string.IsNullOrWhiteSpace(connStr)) throw new NoNullAllowedException("数据库连接字符串不允许为空");
            this.connStr = connStr;
            this.commandTimeout = commandTimeout;
            DapperExtensions.DapperExtensions.SqlDialect = new MySqlDialect();
            Mappings.Initialize();
            //DapperExtensions.DapperExtensions.DefaultMapper = typeof(CustomPluralizedMapper<>);
        }
        /// <summary>
        /// 获取打开的连接
        /// </summary>
        /// <param name="mars">MSSql数据库下有效：如果为 true，则应用程序可以保留多活动结果集 (MARS)。 如果为 false，则应用程序必须处理或取消一个批处理中的所有结果集，然后才能对该连接执行任何其他批处理。</param>
        /// <returns></returns>
        public IDbConnection GetOpenConnection()
        {
            IDbConnection connection = null;
            string cs = connStr;
            connection = new MySqlConnection(cs);
            connection.Open();
            return connection;
        }

        #region Add

        /// <summary>
        /// 批量新增
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="entities">实体对象集</param>
        public void Add<T>(IEnumerable<T> entities) where T : class, new()
        {
            using (IDbConnection cnn = GetOpenConnection())
            {
                using (var trans = cnn.BeginTransaction())
                {
                    try
                    {
                        cnn.Insert(entities, trans, commandTimeout);
                    }
                    catch (DataException ex)
                    {
                        trans.Rollback();
                        throw ex;
                    }
                    trans.Commit();
                }
            }

            //using (IDbConnection cnn = GetOpenConnection())
            //{
            //    var trans = cnn.BeginTransaction();
            //    cnn.Execute(@"insert Member(Username, IsActive) values(@Username, @IsActive)", entities, transaction: trans);
            //    trans.Commit();
            //}
        }

        /// <summary>
        /// 新增
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="entity">实体对象</param>
        /// <returns>实体对象</returns>
        public T Add<T>(T entity) where T : class, new()
        {
            using (IDbConnection cnn = GetOpenConnection())
            {
                T res = null;
                using (var trans = cnn.BeginTransaction())
                {
                    try
                    {
                        int id = cnn.Insert(entity, trans, commandTimeout);
                        if (id > 0)
                        {
                            res = entity;
                        }
                    }
                    catch (DataException ex)
                    {
                        trans.Rollback();
                        throw ex;
                    }
                    trans.Commit();
                }
                return res;
            }
        }
       
        #endregion

        #region Update

        /// <summary>
        /// 更新
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="entity">实体对象</param>
        /// <returns>是否成功</returns>
        public bool Update<T>(T entity) where T : class, new()
        {
            using (IDbConnection cnn = GetOpenConnection())
            {
                bool res = false;
                using (var trans = cnn.BeginTransaction())
                {
                    try
                    {
                        res = cnn.Update(entity, trans, commandTimeout);
                    }
                    catch (DataException ex)
                    {
                        trans.Rollback();
                        throw ex;
                    }
                    trans.Commit();
                }
                return res;
            }
        }

        public bool Update<T>(IEnumerable<T> entities) where T : class, new()
        {
            using (IDbConnection cnn = GetOpenConnection())
            {
                bool res = false;
                using (var trans = cnn.BeginTransaction())
                {
                    try
                    {
                        trans.BulkUpdate(entities);
                        res = true;
                    }
                    catch (DataException ex)
                    {
                        trans.Rollback();
                        throw ex;
                    }
                    trans.Commit();
                }
                return res;
            }
        }

        #endregion

        #region Delete

        /// <summary>
        /// 删除
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="entity">实体对象</param>
        /// <returns>是否成功</returns>
        public bool Delete<T>(T entity) where T : class, new()
        {
            using (IDbConnection cnn = GetOpenConnection())
            {
                bool res = false;
                using (var trans = cnn.BeginTransaction())
                {
                    try
                    {
                        res = cnn.Delete(entity, trans, commandTimeout);
                    }
                    catch (DataException ex)
                    {
                        trans.Rollback();
                        throw ex;
                    }
                    trans.Commit();
                }
                return res;
            }
        }

        /// <summary>
        /// 条件删除
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="predicate">实体对象</param>
        /// <returns>是否成功</returns>
        public bool Delete<T>(object predicate) where T : class, new()
        {
            using (IDbConnection cnn = GetOpenConnection())
            {
                bool res = false;
                using (var trans = cnn.BeginTransaction())
                {
                    try
                    {
                        res = cnn.Delete(predicate, trans, commandTimeout);
                    }
                    catch (DataException ex)
                    {
                        trans.Rollback();
                        throw ex;
                    }
                    trans.Commit();
                }
                return res;
            }
        }

        #endregion

        #region Query/Get

        /// <summary>
        /// 查询单个结果
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="id">实体的Id属性值</param>
        /// <returns>查询结果</returns>
        public T Get<T>(object id) where T : class, new()
        {
            using (IDbConnection cnn = GetOpenConnection())
            {
                T res = null;
                try
                {
                    res = cnn.Get<T>(id, null, commandTimeout);
                }
                catch (DataException ex)
                {
                    throw ex;
                }
                return res;
            }
        }

        /// <summary>
        /// 查询结果集合
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="predicate">分页查询条件</param>
        /// <param name="sort">是否排序</param>
        /// <returns>查询结果</returns>
        public IEnumerable<T> Get<T>(object predicate = null, IList<ISort> sort = null) where T : class, new()
        {
            using (IDbConnection cnn = GetOpenConnection())
            {
                IEnumerable<T> res = null;
                try
                {
                    res = cnn.GetList<T>(predicate, sort, null, commandTimeout);
                }
                catch (DataException ex)
                {
                    throw ex;
                }
                return res;
            }
        }

        /// <summary>
        /// 查询结果分页
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="predicate">分页查询条件</param>
        /// <param name="sort">是否排序</param>
        /// <param name="pageIndex">分页索引</param>
        /// <param name="pageSize">分页大小</param>
        /// <returns>查询结果</returns>
        public PageInfo<T> Get<T>(object predicate, IList<ISort> sort, int pageIndex, int pageSize) where T : class, new()
        {
            if (sort == null) throw new ArgumentNullException("sort 不允许为null");
            if (pageIndex < 0) pageIndex = 0;
            using (IDbConnection cnn = GetOpenConnection())
            {
                PageInfo<T> pInfo = null;
                try
                {
                    int count = cnn.Count<T>(predicate, null, commandTimeout);
                    pInfo = new PageInfo<T>();
                    pInfo.TotalCount = count;
                    pInfo.Data = cnn.GetPage<T>(predicate, sort, pageIndex, pageSize, null, commandTimeout);
                }
                catch (DataException ex)
                {
                    throw ex;
                }
                return pInfo;
            }
        }

        #endregion

        #region IDisposable Support

        private bool disposedValue = false; // 要检测冗余调用

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    // TODO: 释放托管状态(托管对象)。
                }

                // TODO: 释放未托管的资源(未托管的对象)并在以下内容中替代终结器。
                // TODO: 将大型字段设置为 null。

                disposedValue = true;
            }
        }

        // TODO: 仅当以上 Dispose(bool disposing) 拥有用于释放未托管资源的代码时才替代终结器。
        // ~DbClient() {
        //   // 请勿更改此代码。将清理代码放入以上 Dispose(bool disposing) 中。
        //   Dispose(false);
        // }

        // 添加此代码以正确实现可处置模式。
        void IDisposable.Dispose()
        {
            // 请勿更改此代码。将清理代码放入以上 Dispose(bool disposing) 中。
            Dispose(true);
            // TODO: 如果在以上内容中替代了终结器，则取消注释以下行。
            // GC.SuppressFinalize(this);
        }

        #endregion
    }
}

public class FlowCell
    {
        public int Id { get; set; }
        public int type_id { get; set; }
        public string comId { get; set; }
        public string bloc_name { get; set; }
        public string cell_number { get; set; }
        public string name { get; set; }

        public int flows { get; set; }     

        public int status { get; set; }      

        public int del { get; set; }
    }

使用：

public void Statistics()
        {
            try
            {
                DbClient dbClient = new DbClient(mysqlConstr);
                var pg = new PredicateGroup { Operator = GroupOperator.Or, Predicates = new List<IPredicate>() };
                pg.Predicates.Add(Predicates.Field<FlowCell>(f => f.status, Operator.Eq, 1));
                pg.Predicates.Add(Predicates.Field<FlowCell>(f => f.del, Operator.Eq, 0));

                var flowCell = dbClient.Get<FlowCell>(4);

                IList<ISort> sorts = new List<ISort>();
                ISort sort = new Sort();
                sort.Ascending = false;
                sort.PropertyName = "name"; //如果有Map，则此次要填写Map对象的字段名称，而不是数据库表字段名称
                sorts.Add(sort);
                var flowCell2 = dbClient.Get<FlowCell>(pg, sorts);

                var flowCell3 = dbClient.Get<FlowCell>(pg, sorts, 0, 2);
            }
            catch (Exception ex)
            {

            }
        }

weixin_33842304
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c# Dapper事务
luxiaofeng1014的博客
11-03 725
1、报错信息： 如果分配给命令的连接位于本地挂起事务中，ExecuteNonQuery 要求命令拥有事务。命令的 Transaction 属性尚未初始化。 出现这种原因是在执行Execute语句时，没有把得到的IDbTransaction传入Execute方法中。如下代码，在执行第二个Execute时就报上述错误。 IDbTransaction transaction = dbConnection.BeginTransaction(); dbConnection.Execute(sql1,null
SQLite 数据库 C# Dapper 操作实例
Abelia的博客
06-15 1917
1. 概述 前面写过一篇文章《C# SQLite 数据库使用说明》，介绍的是 C# 语言用最原始的 ADO.net 方式操作 SQLite 数据库。可是这种方式很久没用过了，主要是因为 Dapper 和 PetaPoco 太好了用 本文参照 DarkThread 的文章，整理了一套 C# 使用 Dapper 操作 SQLite 数据库的实例，方便自己日后查询。 2. 前置条件 本程序依赖 ...
C#Dapper 帮助类
L_CSyLYH的博客
03-24 909
C#Dapper 帮助类
C# dapper 使用事务
你要明白，任何问题都不是孤立存在的，一定有人曾经遇到过，并且已经有更好的解决办法了，只是我还不知道。我不应该在黑暗中独自前行，去重新发明轮子，也许我的顿悟，只是别人的基本功！我应该要站在巨人的肩膀上，学习更成熟的经验和方法，然后再来解决这个问题
01-21 3661
public bool UpdatePhone(string 姓名, string 身份证号) { using (System.Data.IDbConnection conn = DapperHelper.CreateLocalConnection()) { if (string.IsNullOrEmpty(姓名) || 姓名 == "null") { .
C# Dapper 操作Oracle数据库
easyboot的专栏
08-30 1519
1.配置连接字符串 OracleConnectionString这个可用。3.Dapper数据库操作类。
C#中如何使用Dapper
喵叔
12-18 3964
Dapper是.NET下轻量级ORM，和Entity Framework或Nhibnate不同，它是半自动化的。Dapper它只有一个代码文件，并且完全开源。我们可以将它放在项目的任何位置来实现数据到对象的ORM操作，它具备体积小且速度快的特点。使用ORM的好处是增、删、改会很快，不用自己写sql语句，并且程序中大量的从数据库中读数据然后创建model,并为model字段赋值，这些ORM都可以替我们完成。ORM给开发带来便利的同时，性能也是一个不得不考虑的问题。一般ORM的性能和原生sql相比性能都差了不少
C#调用Dapper
weixin_43497445的博客
09-06 1264
安装Dapper NuGet包：在Visual Studio解决方案中，右键单击项目名称，选择“管理NuGet程序包”，然后在搜索框中输入“Dapper”进行搜索。选择Dapper并安装。引用Dapper命名空间：在使用Dapper之前，需要在代码文件中引用Dapper命名空间。配置数据库连接字符串：在应用程序的配置文件（app.config或web.config）中，需要配置数据库连接字符串。以上就是Dapper的使用介绍，它可以帮助.NET开发人员处理数据库操作，提高开发效率。
C#Dapper如何调用存储过程
AROMANTICS的专栏
02-28 712
Dapper不直接支持存储过程的调用，但它可以很好地与原生SQL查询结合使用，因此你可以通过执行原生SQL命令来调用存储过程。请注意，Dapper不会为存储过程生成参数名或参数值，所以你需要确保参数名和类型与存储过程中定义的相匹配。此外，如果存储过程有输出参数或返回值，你需要特别处理这些情况，因为它们不会自动映射到结果集中。总之，Dapper通过允许你执行原生SQL命令来提供对存储过程的支持，但你需要负责正确设置参数并处理返回的结果。如果你想获取存储过程返回的结果集，你可以使用。操作或使用其他方法（如。
【C#】Dapper使用Mysql实例，Dapper使用Mysql简单范例，DapperHelper
willgon的专栏
09-02 7367
 直接上代码，可以直接作为DapperHelper： using MySql.Data.MySqlClient; //自行网上下载引用MySql.Data.dll using System.Configuration; using System.Data; using Dapper;                //自行网上下载引用Dapper.dll using System.Collec...
c# Dapper,添加,修改,删除,查询,事务,存储过程,含数据库
11-20
Dapper以其简单易用、性能优异的特点深受开发者喜爱。在C#应用中，Dapper可以很好地与ADO.NET集成，为数据库的增删改查、事务处理以及存储过程的调用提供了强大的支持。 1. **Dapper的添加方法**： - `Execute`: ...
C# Dapper操作Demo示例
06-23
C# Dapper操作Demo示例 在.NET开发中，Dapper是一个轻量级、高性能的ORM（对象关系映射）工具，它由Stack Overflow的开发团队设计并维护。Dapper以其简洁的API和高效的性能而受到许多开发者的青睐。本示例将详细...
c#使用dapper连接SQL数据库
12-20
1. **安装Dapper**：要开始使用Dapper，你需要通过NuGet包管理器在你的C#项目中添加Dapper库。在Visual Studio中，右键点击项目，选择"管理NuGet程序包"，然后搜索"Dapper"并安装。 2. **建立数据库连接**：Dapper...
C#之dapper对SqlServer进行增删改查
02-28
总结来说，Dapper为C#开发者提供了一种简单且高效的SQL操作方式，特别适合在Winform应用中与SQL Server进行数据交互。通过理解Dapper的基本使用方法，开发者可以快速实现对数据库的CRUD操作，提高开发效率。在实际...
.net5 dapper封装操作数据库
07-26
例如，我们可以将DapperHelper实例注入到服务层，然后在需要的地方调用其方法来执行数据库操作。 `DapperExtHelper.cs`可能包含了一些Dapper的扩展方法，这些方法进一步封装了Dapper的基本操作，以适应特定项目的...
【深度学习】PyTorch框架(6)：GNN图神经网络理论和实践
MUKAMO的博客
07-19 986
本文深入探讨了神经网络在图结构数据处理中的应用，介绍了图的邻接矩阵和边列表表示方法，以及图卷积网络（GCN）和图注意力网络（GAT）的实现。实践表明，图信息对提升预测模型性能至关重要，GNNs在社交网络、生物信息学、交通优化和推荐系统等领域具有巨大潜力，未来在AI领域将扮演更重要角色。
基于语音识别的会议记录系统
qq_51688022的博客
07-18 1428
本文简要介绍了本科毕设“基于语音识别的会议记录系统”的开发思路与成果
2024年7月16日~2024年7月22日周报
最新发布
m0_53096519的博客
07-22 730
本周完成论文初稿、5000小实验以及数据训练方式初了解。
GPU算力：驱动现代计算的引擎
UnityBoy的博客
07-22 222
在当今的计算密集型应用中，GPU（图形处理单元）算力已成为推动科学计算、人工智能、数据分析等领域发展的关键因素。GPU最初设计用于处理复杂的图形和图像任务，但随着技术的进步，它们已经演变为通用并行计算的强有力工具。本文将探讨GPU算力的基本概念、重要性、应用场景以及如何充分利用GPU算力。
python训练模型报错：BrokenPipeError: [Errno 32] Broken pipe
Dxy1239310216的博客
07-18 514
如果问题持续存在，并且你的项目不是必须在 Windows 上运行，考虑在 Unix/Linux 系统上运行你的代码。确保在数据加载器中使用的任何自定义函数或类都是可序列化的，因为多进程需要能够在不同进程间传递它们。进行多进程数据加载时尤其常见，尤其是在 Windows 系统上，因为 Windows 对多进程的支持与 Unix/Linux 系统有所不同。有时候，错误可能是由其他部分的代码引起的，而不是直接由数据加载器引起。如果问题依然存在，你可能需要更详细地检查你的代码或寻求更专业的帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值