Dapper 基本使用 存储过程 QueryMultiple多个结果集

最新推荐文章于 2024-02-28 22:33:54 发布
最新推荐文章于 2024-02-28 22:33:54 发布
阅读量1.3w 收藏 10
点赞数
分类专栏： Dapper 文章标签： dapper添加 dapper修改 dapper事物 dapper批量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingcruel/article/details/52848950
版权

Dapper_w3cschool【异步，缓冲，事物，存储过程】
SQL Server 存储过程使用   （其中包括 Dapper调用存储过程 示例）

项目右键 Manage NuGet Packages for Solution

搜索Dapper -> Install 

Dapper Execute
Execute 是一种扩展方法，可以从IDbConnection类型的任何对象调用。它可以执行一次或多次命令并返回受影响的行数。此方法通常用于执行。
● 存储过程
● Insert语句
● Update 语句
● Delete 语句

返回“新增自增主键ID”，“统计个数”：ExecuteScalar<int>

_conn.ExecuteScalar<int>("insert into 表名 (name) vaule (@name);SELECT @@IDENTITY;", new { name="dage" });



存储过程示例
conn.Execute("", new { }, null, null, System.Data.CommandType.StoredProcedure);

多个结果集存储过程【proc_multiple_select】

CREATE PROCEDURE [dbo].[proc_multiple_select]
  @page int,
  @per_page int,
  @total int output,
  @page_count int output
AS
BEGIN
    declare @sql_total_string nvarchar(2000) 
	declare @skip int

	set @skip = (case when @page - 1 <= 0 then 0 else @page - 1 end) * @per_page

	select * from sys_department
	select * from sys_user

	set @sql_total_string = N'select @total = count(*) from sys_department'
	exec sp_executesql @sql_total_string,N'@total int out',@total output
	set @page_count = ceiling(@total * 1.0 / @per_page)
END

项目实战【增，删，改，查询1条，查询多条，存储过程，QueryMultiple多个结果集】

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;

namespace Dapper.Repository
{
    public class DapperDemo
    {
        public static string ConnectionString
        {
            get
            {
                string _connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString();
                return _connectionString;
            }
        }

        public SqlConnection OpenConnection()
        {
            SqlConnection connection = new SqlConnection(ConnectionString);
            connection.Open();
            return connection;
        }

        /// <summary>
        /// 添加
        /// </summary>
        /// <returns></returns>
        public bool Add()
        {
            int row = 0;
            ED_Data model = new ED_Data();
            model.TableName = "123";
            model.DataKey = "123";
            model.FieldName = "123";
            model.Value = "123";
            model.Reference = "123";
            model.Branch = 1;
            model.InActive = false;
            model.Updated = DateTime.Now;

            string query = "INSERT INTO ED_Data(TableName,DataKey,FieldName,Value,Reference,Branch,InActive,Updated) VALUES (@TableName,@DataKey,@FieldName,@Value,@Reference,@Branch,@InActive,@Updated)";
            using (IDbConnection conn = OpenConnection())
            {
                row = conn.Execute(query, model);
            }
            if (row > 0)
                return true;
            else
                return false;
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <returns></returns>
        public int Update()
        {
            int row = 0;
            ED_Data model = new ED_Data();
            model.TableName = "123";
            model.DataKey = "123";
            model.Updated = DateTime.Now;
            using (IDbConnection conn = OpenConnection())
            {
                const string query = "UPDATE ED_Data SET DataKey=@DataKey,Updated=@Updated WHERE TableName=@TableName";
                row = conn.Execute(query, model);
            }
            return row;
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public int Delete()
        {
            int row = 0;
            ED_Data model = new ED_Data();
            model.TableName = "123";
            using (IDbConnection conn = OpenConnection())
            {
                const string query = "DELETE FROM ED_Data WHERE TableName=@TableName";
                row = conn.Execute(query, model);
            }
            return row;
        }

        /// <summary>
        /// 查询一条数据
        /// </summary>
        /// <param name="columnCatId"></param>
        /// <returns>ED_Data</returns>
        public ED_Data GetModel(string TableName)
        {
            using (IDbConnection conn = OpenConnection())
            {
                const string query = "SELECT * FROM ED_Data WHERE TableName = @TableName";
                return conn.Query<ED_Data>(query, new { tableName = TableName }).SingleOrDefault<ED_Data>();
            }
        }

        /// <summary>
        /// 查询list集合
        /// </summary>
        /// <returns>List</returns>
        public List<ED_Data> GetED_DataList()
        {
            using (IDbConnection conn = OpenConnection())
            {
                const string query = "SELECT * FROM ED_Data";
                return conn.Query<ED_Data>(query, null).ToList();
            }
        }

        /// <summary>
        /// 查询list集合【多个结果集】
        /// </summary>
        /// <returns>List</returns>
        public List<DepartmentDto> GetED_DataList()
        {
            using (IDbConnection conn = OpenConnection())
            {
                const string sql = "select * from sys_department;select count(*) department_code from sys_department;";
                var multiple = conn.QueryMultiple(sql);
                List<DepartmentDto> list = multiple.Read<DepartmentDto>().ToList();
                var total = multiple.Read<DepartmentDto>().FirstOrDefault().department_code;
                return list;
            }
        }

        /// <summary>
        /// 查询list集合【多个结果集】【存储过程】
        /// </summary>
        /// <returns>List</returns>
        public List<DepartmentDto> GetDepartmentList()
        {
            DynamicParameters para = new DynamicParameters();
            para.Add("@page", page.page);
            para.Add("@per_page", page.per_page);
            para.Add("@total", 0, DbType.Int32, ParameterDirection.Output);
            para.Add("@page_count", 0, DbType.Int32, ParameterDirection.Output);

            using (IDbConnection conn = OpenConnection())
            {
                var multiple = conn.QueryMultiple("proc_multiple_select", para, commandType: CommandType.StoredProcedure);
                List<DepartmentDto> list = multiple.Read<DepartmentDto>().ToList();
                List<UserDto> listUser = multiple.Read<UserDto>().ToList();
                total = para.Get<int>("@total");
                pageCount = para.Get<int>("@page_count");
                return list;
            }
        }

        /// <summary>
        /// 事务处理
        /// 删除
        /// </summary>
        /// <param name="cat"></param>
        /// <returns></returns>
        public int DeleteColumnCatAndColumn(ED_Data cat)
        {
            try
            {
                using (IDbConnection conn = OpenConnection())
                {
                    string delete1 = "DELETE FROM ED_Data WHERE TableName=@TableName";
                    string delete2 = "DELETE FROM ED_Data WHERE TableName=@TableName";

                    IDbTransaction transaction = conn.BeginTransaction();
                    int row = conn.Execute(delete1, new { TableName = cat.TableName }, transaction, null, null);
                    row += conn.Execute(delete2, new { TableName = cat.TableName }, transaction, null, null);
                    transaction.Commit();
                    return row;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        
        /// <summary>
        /// 执行存储过程
        /// </summary>
        public void ExecuteStoredProcedure()
        {
            try
            {
                DynamicParameters para = new DynamicParameters();
                para.Add("@param1", 1);
                para.Add("@param2", 2);

                using (IDbConnection conn = OpenConnection())
                {
                    int row = conn.Execute("存储过程名称", para, null, null, CommandType.StoredProcedure);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 新增，返回主键ID值【存储过程】
        /// </summary>
        public int Create(CreateBroadcastRequest data)
        {
            int code = 0;
            DynamicParameters para = new DynamicParameters();
            para.Add("@broadcast_code", 0, DbType.Int32, ParameterDirection.Output);
            para.Add("@contents", data.contents);
            _conn.Execute("存储过程名称", para, commandType: CommandType.StoredProcedure);
            code = para.Get<int>("@broadcast_code");
            return code;
        }

        /// <summary>
        /// 批量添加
        /// </summary>
        public void InsertBatch()
        {
            try
            {
                string sqlStr = "INSERT INTO ED_Data(TableName,DataKey,FieldName,Value,Reference,Branch,InActive,Updated) VALUES (@TableName,@DataKey,@FieldName,@Value,@Reference,@Branch,@InActive,@Updated)";
                using (IDbConnection conn = OpenConnection())
                {
                    conn.Execute(sqlStr, new[] 
                    {
                        new { TableName = "user1", DataKey = "a", FieldName = "name", Value = "000001", Reference = "", Branch = "", InActive = "", Updated = DateTime.Now },
                        new { TableName = "user2", DataKey = "b", FieldName = "age", Value = "000002", Reference = "", Branch= "", InActive = "", Updated = DateTime.Now },
                        new { TableName = "user3", DataKey = "c", FieldName = "phone", Value = "000003", Reference= "", Branch= "", InActive= "", Updated= DateTime.Now },
                    }, null, null, null);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
    }
}

*

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;

namespace Dapper.Repository
{
    public class ED_Data
    {
        public string TableName { get; set; }

        public string DataKey { get; set; }

        public string FieldName { get; set; }

        public string Value { get; set; }

        public string Reference { get; set; }

        public int Branch { get; set; }

        public bool InActive { get; set; }

        public DateTime Updated { get; set; }
    }
}

Base基类

using Dapper.CoreLibrary;
using Dapper.Entity;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Transactions;

namespace Dapper.Repository
{
    public abstract class RepositoryBase<T> : DbConnectionFactory, IRepositoryBase<T> where T : IEntityBase<T>
    {
        public RepositoryBase(IDbConnection db) : base(db) { }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public virtual int Add(T model)
        {
            int result = 0;
            try
            {
                var ps = model.GetType().GetProperties();
                List<string> @colms = new List<string>();
                List<string> @params = new List<string>();
                foreach (var p in ps)
                {
                    if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)) && !p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                    {
                        @colms.Add(string.Format("[{0}]", p.Name));
                        @params.Add(string.Format("@{0}", p.Name));
                    }
                }
                var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2}); SELECT @@IDENTITY;", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                result = _conn.ExecuteScalar<int>(sql, model);
            }
            catch (Exception ex)
            {
                throw;
            }
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="listModel"></param>
        public virtual void Add(List<T> listModel)
        {
            try
            {
                using (var scope = new TransactionScope())
                {
                    listModel.ForEach(model =>
                    {
                        var ps = model.GetType().GetProperties();
                        List<string> @colms = new List<string>();
                        List<string> @params = new List<string>();
                        foreach (var p in ps)
                        {
                            if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)) && !p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                            {
                                @colms.Add(string.Format("[{0}]", p.Name));
                                @params.Add(string.Format("@{0}", p.Name));
                            }
                        }
                        var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2}); SELECT @@IDENTITY;", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                        _conn.ExecuteScalar<int>(sql, model);
                    });
                    scope.Complete();
                }
            }
            catch (Exception ex)
            {
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public virtual int AddWithGuid(T model)
        {
            int result = 0;
            try
            {
                var ps = model.GetType().GetProperties();
                List<string> @colms = new List<string>();
                List<string> @params = new List<string>();
                foreach (var p in ps)
                {
                    if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                    {
                        @colms.Add(string.Format("[{0}]", p.Name));
                        @params.Add(string.Format("@{0}", p.Name));
                    }
                }
                var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2});", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                result = _conn.Execute(sql, model);
            }
            catch (Exception ex)
            {
                throw;
            }
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        public virtual void Update(T model)
        {
            PropertyInfo pkInfo = null;
            var ps = model.GetType().GetProperties();
            List<string> @params = new List<string>();
            foreach (var p in ps)
            {
                if (p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                {
                    continue;
                }
                if (p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)))
                {
                    pkInfo = p;
                }
                else
                {
                    @params.Add(string.Format("[{0}]=@{0}", p.Name));
                }
            }
            var sql = string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = @{2}", typeof(T).Name, string.Join(", ", @params), pkInfo.Name);
            _conn.Execute(sql, model);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="listModel"></param>
        public virtual void Update(List<T> listModel)
        {
            using (var scope = new TransactionScope())
            {
                listModel.ForEach(model =>
                {
                    PropertyInfo pkInfo = null;
                    var ps = model.GetType().GetProperties();
                    List<string> @params = new List<string>();
                    foreach (var p in ps)
                    {
                        if (p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                        {
                            continue;
                        }
                        if (p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)))
                        {
                            pkInfo = p;
                        }
                        else
                        {
                            @params.Add(string.Format("[{0}] = @{0}", p.Name));
                        }
                    }
                    var sql = string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = @{2}", typeof(T).Name, string.Join(", ", @params), pkInfo.Name);
                    _conn.Execute(sql, model);
                });
                scope.Complete();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="primaryValue">主键ID</param>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public virtual T GetModel(string primaryValue, string tableName = "")
        {
            try
            {
                string primaryWhere = string.Empty;
                var ps = typeof(T).GetProperties();
                if (string.IsNullOrEmpty(tableName))
                {
                    tableName = typeof(T).Name;
                }
                var primary = ps.Single(p => p.CustomAttributes.FirstOrDefault(c => c.AttributeType == typeof(PrimaryKeyAttribute)) != null);

                primaryWhere = (string.Format("[{0}] = @primarykey", primary.Name));

                var sql = string.Format("SELECT * FROM [{0}] WHERE {1}", tableName, primaryWhere);

                return _conn.Query<T>(sql, new { primarykey = primaryValue }).FirstOrDefault();
            }
            catch (Exception)
            {

                throw;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strWhere">where条件</param>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public virtual T GetModelQuery(string strWhere, string tableName = "")
        {
            try
            {
                var sql = string.Format("SELECT * FROM [{0}] WHERE {1}", tableName, strWhere);
                return _conn.Query<T>(sql, new { where = strWhere }).FirstOrDefault();
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 根据主键删除
        /// </summary>
        /// <param name="primaryValue"></param>
        public virtual void Delete(string primaryValue)
        {
            try
            {
                string primaryWhere = string.Empty;
                var ps = typeof(T).GetProperties();
                var primary = ps.Single(p => p.CustomAttributes.FirstOrDefault(c => c.AttributeType == typeof(PrimaryKeyAttribute)) != null);
                var sql = string.Format("DELETE FROM [{0}] WHERE {1} = @primarykey", typeof(T).Name, primary.Name);
                _conn.Execute(sql, new { primarykey = primaryValue });
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strWhere"></param>
        public void DeleteStrWhere(string strWhere)
        {
            try
            {
                var sql = string.Format("DELETE FROM [{0}] WHERE {1}", typeof(T).Name, strWhere);
                _conn.Execute(sql);
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strWhere"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public virtual List<T> GetList(string strWhere, string tableName = "")
        {
            try
            {
                if (string.IsNullOrEmpty(tableName))
                    tableName = typeof(T).Name;
                var sql = string.Format("SELECT * FROM [{0}] " + (strWhere == "" ? "" : " WHERE " + " {1} "), tableName, strWhere);
                return _conn.Query<T>(sql).ToList();
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public virtual PagerListResult<List<T>> GetPageList(PagerRequestParam param)
        {
            PagerListResult<List<T>> result = null;
            List<T> list = new List<T>();
            int pageTotal = 1;
            int recordTotal = 0;
            int startIndex = 1;
            int endIndex = param.PageSize;
            try
            {
                if (param.PageIndex - 1 > 0)
                {
                    startIndex = (param.PageIndex - 1 <= 0 ? 1 : param.PageIndex - 1) * param.PageSize + 1;
                    endIndex = param.PageIndex * param.PageSize;
                }

                if (string.IsNullOrEmpty(param.TableName))
                    param.TableName = typeof(T).Name;
                StringBuilder strSql = new StringBuilder();
                strSql.Append("SELECT * FROM ( ");
                strSql.Append(" SELECT ROW_NUMBER() OVER (");
                if (!string.IsNullOrEmpty(param.OrderBy))
                {
                    strSql.Append("ORDER BY T." + param.OrderBy);
                }
                else
                {
                    strSql.Append("ORDER BY T.ID DESC");
                }
                strSql.Append(")AS Row, T.*  FROM " + param.TableName + " T ");
                if (!string.IsNullOrEmpty(param.StrWhere))
                {
                    strSql.Append(" WHERE " + param.StrWhere);
                }
                strSql.Append(" ) TT");
                strSql.AppendFormat(" WHERE TT.Row BETWEEN {0} AND {1}", startIndex, endIndex);

                list = _conn.Query<T>(strSql.ToString(), param.StrWhere).ToList();
                if (list.Count > 0)
                {
                    recordTotal = this.GetRecordCount(param.StrWhere, param.TableName);
                    pageTotal = PagerRequestParam.Tool.PageTotal(param);
                }
                result = new PagerListResult<List<T>>(list, pageTotal, recordTotal);
            }
            catch (Exception ex)
            {
                result = new PagerListResult<List<T>>(ex);
            }
            return result;
        }

        /// <summary>
        /// 事务处理
        /// Demo
        /// </summary>
        /// <returns></returns>
        public int DeleteTransaction()
        {
            try
            {
                const string delete1 = "DELETE FROM ED_Data WHERE TableName=@TableName";
                const string delete2 = "DELETE FROM ED_Data WHERE TableName=@TableName";

                IDbTransaction transaction = _conn.BeginTransaction();
                int row = _conn.Execute(delete1, new { TableName = "user" }, transaction, null, null);
                row += _conn.Execute(delete2, new { TableName = "customer" }, transaction, null, null);
                transaction.Commit();
                return row;
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 获取记录数count()统计
        /// </summary>
        /// <param name="strWhere">Where条件</param>
        /// <returns></returns>
        public virtual int GetRecordCount(string strWhere, string tableName = "")
        {
            int count = 0;
            try
            {
                if (string.IsNullOrEmpty(tableName))
                    tableName = typeof(T).Name;
                StringBuilder strSql = new StringBuilder();
                strSql.Append("SELECT COUNT(1) FROM " + tableName);
                if (!string.IsNullOrEmpty(strWhere))
                {
                    strSql.Append(" WHERE " + strWhere);
                }
                count = _conn.ExecuteScalar<int>(strSql.ToString());
            }
            catch (Exception)
            {

                throw;
            }
            return count;
        }
    }
}

 

KingCruel
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
dapper的调用各种存储过程的方法
02-15
dapper的调用各种存储过程的方法的帮助类文档，可通过该文档了解并学会使用Dapper，并且调用Dapper
使用Dapper处理多个结果集和多重映射的教程
04-11
如何使用dapper在单个数据库调用中从数据库读取多个结果集
C#Dapper如何调用存储过程
AROMANTICS的专栏
02-28 524
Dapper不直接支持存储过程的调用，但它可以很好地与原生SQL查询结合使用，因此你可以通过执行原生SQL命令来调用存储过程。请注意，Dapper不会为存储过程生成参数名或参数值，所以你需要确保参数名和类型与存储过程中定义的相匹配。此外，如果存储过程有输出参数或返回值，你需要特别处理这些情况，因为它们不会自动映射到结果集中。总之，Dapper通过允许你执行原生SQL命令来提供对存储过程的支持，但你需要负责正确设置参数并处理返回的结果。如果你想获取存储过程返回的结果集，你可以使用。操作或使用其他方法（如。
Dapper ORM
weixin_30411239的博客
03-04 208
参考地址：https://www.cnblogs.com/lunawzh/p/6607116.html 1、连接语句 var conn = new SqlConnection(ConfigurationManager.ConnectionStrings["SqlDiagnosticsDb"].ConnectionString); 使用dapper不需要考虑conn是否连接，在执...
drapper oracle,在Oracle中使用Dapper QueryMultiple
weixin_29268331的博客
04-07 302
OP可能早就解决了这个问题,但是在撰写本文时,这个问题只有一个答案,并没有真正解决使用Dapper的QueryMultiple()方法与Oracle的问题.由于@ Kamolas81正确地陈述,通过使用官方示例中的语法,确实会得到ORA-00933：sql命令没有正确结束的错误消息.我花了一段时间来搜索关于如何使用Oracle的QueryMultiple()的一些文档,但我很惊讶,没有一个地方有一...
轻量级ORM框架Dapper应用四：使用Dapper返回多个结果集
csdnsunyf的专栏
10-19 470
使用Dapper的QueryMultiple方法可以一次执行多条SQL语句，返回多个结果集，代码如下 using System; using System.Collections.Generic; using System.Linq; using System.Text; usin...
Dapper官方教程翻译8：Dapper方法之QueryMultiple（转）
weixin_30527143的博客
06-08 293
Dapper官方教程翻译8：Dapper方法之QueryMultiple 2019年02月28日 10:42:22Day_and_Night_2017阅读数：120 QueryMultiple方法描述 QueryMultiple方法也是一个扩展方法，可以被IDbConnection对象调用，可以执行查询语句，并且映射到结果。可以实现多条...
Dapper官方教程翻译8：Dapper方法之QueryMultiple
『程序员·小李』的博客
02-28 1454
QueryMultiple方法描述 QueryMultiple方法也是一个扩展方法，可以被IDbConnection对象调用，可以执行查询语句，并且映射到结果。可以实现多条查询语句一起查询，并且使用强类型读取结果集。 QueryMultiple方法可使用的参数 Name Description sql 查询语句 param 参数 transac...
【C#/.NET】Dapper使用QueryMultipleAsync执行多条SQL
XuYuDong_的博客
06-09 516
通过使用Dapper的QueryMultipleAsync一次性查询多个结果，减少了与数据库服务器的请求次数。减少了代码量。
Dapper在Oracle中QueryMultiple无效的解决方法.
sword_happy的博客
03-14 726
Dapper在Oracle中QueryMultiple无效的解决方法. 项目版本: .Net4.5.2, Dapper=>1.60.6, Oracle.ManagedDataAccess=>19.6.0,Oracle==>12C 问题: 在Dapper中使用QueryMultiple,只能查询单SQL,如果是多条SQL,那么会提示SQL语句异常; 分析: Dapper对M...
Dapper存储过程连续查询多个表
07-20
Dapper存储过程连续查询多个表
如何使用Dapper处理多个结果集与多重映射实例教程
12-25
在本文中，我们将介绍如何使用DAPPER从单个数据库调用中读取数据库中的多个结果集。我们将看看我们可能希望这样做的场景，以及如何使用它的Query和QueryMultiple方法更简洁地实现这一点。 当我们谈论以数据为中心的...
Dapper处理多个结果集与多重映射实例
世界既不黑也不白，而是一道精致的灰。
08-09 621
一个恒星对应多个行星。
由Dapper QueryMultiple 返回数据的问题得出==》Dapper QueryMultiple并不会帮我们识别多个返回值的顺序...
weixin_33797791的博客
02-26 198
异常汇总：http://www.cnblogs.com/dunitian/p/4523006.html#dapper 今天帮群友整理Dapper基础教程的时候手脚快了点，然后遇到了一个小问题，Dapper QueryMultiple 返回数据的问题 多个返回值用QueryMultiple ，这个大家都知道，如果不清楚的看下下面的文档： 这个是官方文档： Multiple Resul...
Dapper QueryMultiple 多结果集 遍历
墨荷清香
06-16 8227
这段代码展示了如何遍历使用Dapper的QueryMultiple方法得到的多查询结果的结果集 得出这段代码的探索过程相当纠结。
[Dapper].NET/C#中使用Dapper时如何获取存储过程返回的多个结果集？
weixin_40029679的博客
04-30 376
Dapper中是否有方法获取从存储过程中返回的多个结果集，如果有，应该使用Dapper的哪个或者哪些方法来实现呢？
Dapper官方文档(五)【方法之QuerySingle,QuerySingleOrDefault,QueryMultiple】
极客神殿
09-01 1290
QuerySingle 描述 QuerySingle是一个可以从IDbConnection类型的任意对象调用的扩展方法，它可以执行查询并映射第一个结果，如果序列中没有元素则会引发异常。 结果可以映射到： 匿名类型 强类型 参数 下表显示了QuerySingle方法的不同参数。 名称 描述 sql 要执行的查询。 param 查询参数（默认为null）。 transaction 需要使用的事务（默认为null）。 commandTimeout 命令执行超时时间（默认为null）
Dapper入门
mwcxz的博客
11-17 6167
dapper如门
基于matlab实现实现了基于项目的协同过滤代码，MATLAB实现.rar
最新发布
05-04
基于matlab实现实现了基于项目的协同过滤代码，MATLAB实现.rar
C#的Dapper如何调用存储过程
06-03
使用Dapper调用存储过程可以通过以下步骤实现： 1. 创建一个存储过程 首先，需要在数据库中创建一个存储过程。例如，创建一个名为“GetUsers”的存储过程，该存储过程返回用户表中的所有用户记录。以下是创建该存储过程的示例SQL语句： CREATE PROCEDURE GetUsers AS BEGIN SELECT * FROM Users END 2. 定义一个模型类 定义一个模型类，该类的属性与存储过程返回的结果集中的列相对应。例如，在这个例子中，我们可以定义一个名为“User”的类，该类包含用户表中的所有列： public class User { public int UserId { get; set; } public string UserName { get; set; } public string Email { get; set; } public string Password { get; set; } } 3. 调用存储过程 使用Dapper调用存储过程可以通过以下代码实现： using (var connection = new SqlConnection("connectionString")) { var users = connection.Query<User>("GetUsers", commandType: CommandType.StoredProcedure); } 在上面的代码中，我们首先创建一个SqlConnection对象，该对象表示与数据库的连接。然后，我们调用Query方法，该方法使用存储过程名称作为第一个参数，并使用commandType参数指定命令类型为StoredProcedure。Query方法返回一个IEnumerable<User>对象，该对象包含存储过程返回的所有用户记录。 注意：在调用存储过程时，可以将参数传递给存储过程。可以使用匿名类型或DynamicParameters对象来传递参数。例如： var parameters = new DynamicParameters(); parameters.Add("@UserId", 1); var user = connection.QueryFirstOrDefault<User>("GetUserById", parameters, commandType: CommandType.StoredProcedure); 在上面的代码中，我们首先创建一个DynamicParameters对象，并使用Add方法向该对象添加一个名为“UserId”的参数。然后，我们调用QueryFirstOrDefault方法，该方法使用存储过程名称作为第一个参数，DynamicParameters对象作为第二个参数，并使用commandType参数指定命令类型为StoredProcedure。QueryFirstOrDefault方法返回一个User对象，该对象包含存储过程返回的第一个用户记录。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值