ABP .netCore 3.1 支持直接执行SQL语句 反射或者直接输出JSONString的格式

最新推荐文章于 2025-03-25 10:14:04 发布
最新推荐文章于 2025-03-25 10:14:04 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： .net Core C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Apeart/article/details/107637025
版权

直接上代码

using Abp.Dependency;
using Abp.EntityFrameworkCore;
using AutoCodePlan.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Reflection;
using System.Threading.Tasks;

namespace AutoCodePlan.Sql
{
    /// <summary>
    /// 
    /// </summary>
    public interface ISqlExecuter
    {
        /// <summary>
        /// 执行给定的命令
        /// </summary>
        /// <param name="sql">命令字符串</param>
        /// <returns>执行命令后由数据库返回的结果</returns>
        int Execute(string sql);

        /// <summary>
        /// 这个抛弃掉，是按照下标注入的
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        //Task<List<T>> SqlQuery<T>(string sql) where T : class, new();
        /// <summary>
        /// 根据SQL语句查询
        /// </summary>
        /// <param name="sql">sql语句</param>
        ///         /// <param name="islist">是否时集合</param>
        /// <returns></returns>
        Task<String> SqlQueryJsonString(string sql, bool islist = true);
        /// <summary>
        /// 通过反射获取SQL语句查询获取的单例
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <returns></returns>
        Task<T> SqlQueryReflex<T>(string sql) where T : class, new();

        /// <summary>
        /// 通过反射获取SQL语句查询的列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <returns></returns>
        Task<List<T>> SqlQueryReflexList<T>(string sql) where T : class, new();
    }
    /// <summary>
    /// 
    /// </summary>
    public class SqlExecuter : ISqlExecuter, ITransientDependency
    {
        private IDbContextProvider<AutoCodePlanDbContext> _dbContextProvider = null;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dbContextProvider"></param>
        public SqlExecuter(IDbContextProvider<AutoCodePlanDbContext> dbContextProvider)
        {
            _dbContextProvider = dbContextProvider;//IocManager.Instance.Resolve<IDbContextProvider<OADbContext>>();
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public int Execute(string sql)
        {
            var result = 0;
            var dbt = _dbContextProvider.GetDbContext();
            var db = dbt.Database;
            using (var command = db.GetDbConnection().CreateCommand())
            {
                //var _t = new T();
                command.CommandText = sql;
                db.OpenConnection();
                result = command.ExecuteNonQuery();
            }
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <returns></returns>
        //public async Task<List<T>> SqlQuery<T>(string sql) where T : class, new()
        //{
        //    return await Task.Run(() =>
        //    {
        //        //var db = _dbContextProvider.GetDbContext().Database;
        //        var dbt = _dbContextProvider.GetDbContext();

        //        var db = dbt.Database;
        //        using (var command = db.GetDbConnection().CreateCommand())
        //        {
        //            command.CommandText = sql;
        //            db.OpenConnection();
        //            var result = new List<T>();
        //            using (var dr = command.ExecuteReader())
        //            {
        //                var properties = typeof(T).GetProperties().ToList();
        //                while (dr.Read())
        //                {
        //                    var obj = new T();
        //                    foreach (var property in properties)
        //                    {
        //                        //获取该字段明的列序号，从0开始
        //                        var id = dr.GetOrdinal(property.Name.ToLower());
        //                        if (!dr.IsDBNull(id))
        //                        {
        //                            if (dr.GetValue(id) != DBNull.Value)
        //                            {
        //                                property.SetValue(obj, dr.GetValue(id));
        //                            }
        //                        }
        //                    }

        //                    result.Add(obj);
        //                }
        //            }
        //            //db.CloseConnection();//用完后要关闭?
        //            return result;
        //        }


        //    });
        //}

        /// <summary>
        /// 单个数据形式的查询反馈
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <returns></returns>
        public async Task<T> SqlQueryReflex<T>(string sql) where T : class, new()
        {
            return await Task.Run(() =>
            {
                //var db = _dbContextProvider.GetDbContext().Database;
                var dbt = _dbContextProvider.GetDbContext();

                var db = dbt.Database;
                using (var command = db.GetDbConnection().CreateCommand())
                {
                    var _t = new T();
                    command.CommandText = sql;
                    db.OpenConnection();
                    //var result = new List<T>();
                    using (var dr = command.ExecuteReader())
                    {
                        //var properties = typeof(T).GetProperties().ToList();
                        while (dr.Read())
                        {
                            //var _t = new T();
                            _t = (T)GetValue(dr, _t);
                            //return _t;
                            break;
                        }
                    }
                    //db.CloseConnection();//用完后要关闭?
                    //return null;
                    return _t;
                }
            });
        }

        /// <summary>
        /// 集合类型的查询反馈
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <returns></returns>
        public async Task<List<T>> SqlQueryReflexList<T>(string sql) where T : class, new()
        {
            return await Task.Run(() =>
            {
                var dbt = _dbContextProvider.GetDbContext();
                var db = dbt.Database;
                using (var command = db.GetDbConnection().CreateCommand())
                {
                    command.CommandText = sql;
                    db.OpenConnection();

                    var list = new List<T>();
                    T _t = new T();

                    //PropertyInfo[] infos = typeof(T).GetType().GetProperties();

                    DataRowCollection rowList;
                    using (var dr = command.ExecuteReader())
                    {
                        rowList = dr.GetSchemaTable().Rows;
                        //只反射一次
                        Type type = _t.GetType();
                        var infos = type.GetProperties();
                        while (dr.Read())
                        {
                            _t = new T();
                            _t = (T)GetValue(dr, infos, rowList, _t);
                            list.Add(_t);
                        }
                    }
                    db.CloseConnection();
                    return list;
                }


            });
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="islist"></param>
        /// <returns></returns>
        public async Task<String> SqlQueryJsonString(string sql, bool islist = true)
        {
            return await Task.Run(() =>
            {
                //var db = _dbContextProvider.GetDbContext().Database;
                var dbt = _dbContextProvider.GetDbContext();

                var db = dbt.Database;
                using (var command = db.GetDbConnection().CreateCommand())
                {
                    command.CommandText = sql;
                    db.OpenConnection();
                    var resultString = String.Empty;
                    //var result = new List<T>();
                    using (var dr = command.ExecuteReader())
                    {
                        resultString = ToJson(dr, !islist);
                    }
                    db.CloseConnection();//用完后要关闭?
                    return resultString;
                }


            });
        }


        /// <summary>
        /// 转JsonString
        /// </summary>
        /// <param name="dataReader"></param>
        /// <param name="onlyone"></param>
        /// <returns></returns>
        private string ToJson(DbDataReader dataReader, bool onlyone = false)
        {
            System.Text.StringBuilder jsonString = new System.Text.StringBuilder();
            if (!onlyone)
            {
                jsonString.Append("[");
            }
            while (dataReader.Read())
            {
                jsonString.Append("{");
                for (int i = 0; i < dataReader.FieldCount; i++)
                {
                    Type type = dataReader.GetFieldType(i);

                    string strKey = dataReader.GetName(i);
                    string strValue = dataReader[i].ToString();
                    jsonString.Append("\"x_" + strKey + "\":");
                    //strValue = String.Format(strValue, type);
                    if (type == typeof(String))
                    {
                        if (dataReader[i] == DBNull.Value)
                        {
                            jsonString.Append("null");
                            if (i <= dataReader.FieldCount - 1)
                            {
                                jsonString.Append(",");
                            }
                        }
                        else
                        {
                            if (strValue != "null")
                            {
                                jsonString.Append(JsonSerializer<string>(strValue));
                            }
                            else
                            {
                                jsonString.Append("null");
                            }
                            if (i <= dataReader.FieldCount - 1)
                            {
                                jsonString.Append(",");
                            }
                        }
                    }
                    else if (type == typeof(Boolean))
                    {
                        if (dataReader[i] == DBNull.Value)
                        {
                            jsonString.Append("false");
                        }
                        else
                        {
                            jsonString.Append(strValue.ToLower());
                        }
                        if (i <= dataReader.FieldCount - 1)
                        {
                            jsonString.Append(",");
                        }
                    }
                    else if (type == typeof(DateTime))
                    {
                        if (dataReader[i] == DBNull.Value)
                        {
                            //jsonString.Append("null");
                            jsonString.Append("\"");
                            jsonString.Append(string.Format("\\/Date({0}+0800)\\/", (DateTime.Parse("2000-01-01").ToUniversalTime() - DateTime.Parse("1970-01-01")).TotalMilliseconds));
                            jsonString.Append("\"");
                        }
                        else
                        {
                            jsonString.Append("\"");
                            jsonString.Append(string.Format("\\/Date({0}+0800)\\/", (DateTime.Parse(strValue).ToUniversalTime() - DateTime.Parse("1970-01-01")).TotalMilliseconds));
                            jsonString.Append("\"");
                        }
                        if (i <= dataReader.FieldCount - 1)
                        {
                            jsonString.Append(",");
                        }
                    }
                    //不需要加""的
                    else
                    {


                        if (!String.IsNullOrEmpty(strValue))
                        {
                            jsonString.Append("" + strValue + "");
                        }
                        else
                        {
                            if (type == typeof(Int32) || type == typeof(Int64) || type == typeof(Int16) || type == typeof(Decimal))
                            {
                                jsonString.Append("0");
                            }
                            else
                            {
                                jsonString.Append("" + strValue + "");
                            }
                        }

                        if (i <= dataReader.FieldCount - 1)
                        {
                            jsonString.Append(",");
                        }
                    }
                }
                if (dataReader.FieldCount > 0)
                {
                    jsonString.Remove(jsonString.Length - 1, 1);
                }
                jsonString.Append("},");
                if (onlyone)
                {
                    break;
                }
            }
            if (jsonString.Length > 1)
            {
                jsonString.Remove(jsonString.Length - 1, 1);
            }
            if (!onlyone)
            {
                jsonString.Append("]");
            }
            return jsonString.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        private string JsonSerializer<T>(T t)
        {
            System.Runtime.Serialization.Json.DataContractJsonSerializer ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            ser.WriteObject(ms, t);
            string jsonString = System.Text.Encoding.UTF8.GetString(ms.ToArray());
            ms.Close();
            return jsonString;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        private T JsonDeserialize<T>(string jsonString)
        {
            System.Runtime.Serialization.Json.DataContractJsonSerializer ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
            System.IO.MemoryStream ms = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonString));
            T obj = (T)ser.ReadObject(ms);
            return obj;
        }


        private bool HasColumn(DataTable table, string columnName)
        {
            foreach (DataRow item in table.Rows)
            {
                //if(item.ItemArray[0].ToString() == columnName){
                //    return true;
                //}
                if (item["ColumnName"].ToString() == columnName)
                {
                    return true;
                }
            }
            return false;
        }
        private object GetValue(DbDataReader reader, object obj)
        {
            Type type = obj.GetType();
            for (var k = 0; k < type.GetProperties().Length; k++)
            {
                var item = type.GetProperties()[k];
                //if (item.Name.Length > 2 && HasColumn(reader.GetSchemaTable(), item.Name.Substring(2)))
                //{
                //    if (reader[item.Name.Substring(2)] != DBNull.Value)
                //    {
                //        item.SetValue(obj, reader[item.Name.Substring(2)], null);
                //    }
                //}
                if (item.Name.Length >= 2 && HasColumn(reader.GetSchemaTable(), item.Name))
                {
                    if (reader[item.Name] != DBNull.Value)
                    {
                        item.SetValue(obj, reader[item.Name], null);
                    }
                }
            }
            return obj;
        }
        private bool HasColumn(DataRowCollection rowList, string columnName)
        {
            foreach (DataRow item in rowList)
            {
                if (item["ColumnName"].ToString() == columnName)
                {
                    return true;
                }
                //if (item.ItemArray[0].ToString().ToLower() == columnName.ToLower())
                //{
                //    return true;
                //}
            }
            return false;
        }
        private object GetValue(DbDataReader reader, PropertyInfo[] infos, DataRowCollection rowList, object obj)
        {
            //for (var k = 0; k < reader.FieldCount; k++)
            //{
            //    Debug.WriteLine("key:"+reader.GetName(k)+",val:"+reader.GetValue(k));
            //}
            //return GetValue(reader,obj);
            foreach (var item in infos)
            {

                //Debug.WriteLine("==============="+item.Name+"=================");
                //Debug.WriteLine("+"+reader["Id"]+"+"+reader["id"]);

                if (item.Name.Length >= 2 && HasColumn(rowList, item.Name))
                {
                    if (reader[item.Name] != DBNull.Value)
                    {
                        item.SetValue(obj, reader[item.Name], null);
                    }
                    //else if (reader[item.Name.ToLower()] != DBNull.Value) {
                    //    item.SetValue(obj, reader[item.Name.ToLower()], null);
                    //}
                }
            }
            return obj;
        }

    }
}

 

基于.NetCore和ABP.VNext的项目实战一：abp cli 搭建项目
yigu4011的博客
05-14 711
学习了阿星Plus的博客项目，自己也试着搭建自己的博客。ABP和ABP.VNext的主要区别在于核心库的精简、对领域驱动设计(DDD)的关注、以及使用的技术栈。1、ABP VNext的核心库相比ABP更加精简，它将原有许多组件从核心库中抽离成独立的组件，这使得开发者可以更灵活地选择需要的功能。这种设计使得ABP VNext更加模块化，但也意味着管理的独立项目数量增加。2、ABP VNext更加关注领域驱动设计，引入了聚合根、实体、值对象等概念，并提供了仓储模式和领域服务等基础设施。
基于.NetCore和ABP.VNext的项目实战八：使用Redis缓存数据
yigu4011的博客
06-07 451
在Mag.Blog.Application层的AuthorizeService.cs中注入IAuthorizeCacheService，将查询到的数据添加到缓存当中。扩展方法，可以同时处理获取和添加缓存的操作，当缓存存在时，直接返回，不存在时，添加缓存，在。在对应的AppSettings.cs里面读取配置的Redis字符串。层的MagBlogConsts类下定义的缓存过期时间策略常量。的时候，不指定过期时间，那么我们的缓存就不会过期。中配置我们的缓存过期时间，当。层的模块类中添加依赖缓存模块。
.Net core下直接执行SQL语句并生成DataTable的实现方法
01-02
.net core可以执行SQL语句，但是只能生成强类型的返回结果。例如var blogs = context.Blogs.FromSql(“SELECT * FROM dbo.Blogs”).ToList()。而不允许返回DataSet、DataTable等弱类型。可能由于这个原因没有实现在.net core中DataTable，然而DataTable还是可能会用到的。我们这里就有一个数据仓库的需求，允许用户自行编写类似SQL语句，然后执行，以表格展示。因为语句是千变万化的，因此我也不知道用户的语句输出的是啥，更无法以类型来定义，因此只能采用DataTable方式。 之前.net frame
ASP.NET Core 3.1系列（18）——EFCore中执行原生SQL语句
HerryDong的博客
12-06 4031
前一篇博客介绍了中常见的一些查询操作，使用或结合实体类的操作相当方便。但在某些特殊情况下，我们仍旧需要使用原生来获取数据。好在EFCore中提供了完整的方法支持原生，下面开始介绍。与之前一样，还是使用和数据表，它们是一对多的关系，为表中的外键。表数据如下所示：表数据如下所示：代码如下： 代码如下： 代码如下： 3、执行原生SQL查询操作 3.1、FromSqlInterpolated 如果是针对单表的查询操作，可以使用方法，但是该方法有以下局限性：下面将查询查询表中且的记录，代码如下： 运行结果如下所示：
对比.NET Core 和.NET Framework
最新发布
Gene Z.的博客
03-25 480
. NET Core和. NET Framework是微软开发的两个重要的. NET平台框架，它们存在以下主要区别：
.net core 执行SQL语句返回数据
陈熙之的博客
08-13 1225
private readonly BaseContext _context; public BuyService(BaseContext context) : base(context) { _context = context; } var conn = _context.Database.GetDbConnection(); conn.Open(); using (var command = c.
在Abp中执行sql语句
zhanglong_longlong的专栏
07-30 1976
http://www.8023me.com/blog/detail/4 最近使用ABP(ASP.NET Boilerplate)做项目，有些查询(或存储过程)直接使用sql语句会更方便一点。 定义一个接口 在Core项目中定义一个接口，如：ISqlExecuter public interface ISqlExecuter { /// <summary> /// 执行给定的命令 /// </summary&gt.
基于.NetCore和ABP.VNext的项目实战七：全局异常处理并日志记录
yigu4011的博客
06-04 443
中判断当前请求状态，当状态不是200，获取到状态码枚举的Key值用来当作错误信息返回，最后也执行。F5运行项目，调用 .../HelloWorld/Exception，查看日志文件。ABP框架已经默认为我们实现了全局的异常模块，这里我们自定义全局异常模块，先在。配置log4net，然后我们直接返回IHostBuilder对象，便于在。出现异常，也要能够记录日志，这里采用。的Filter，他需要实现我们的。方法，返回我们自定义的模型。方法，当没有异常发生时，在。，这样才会执行新建的中间件。
基于.NetCore和ABP.VNext的项目实战三：EFCore访问数据库和CodeFirst方式数据迁移
yigu4011的博客
05-21 397
本篇主要使用Entity Framework Core完成对数据库的访问，以及使用Code-First的方式进行数据迁移，自动创建表结构。Nuget安装数据库迁移工具在Mag.Blog.EntityFrameworkCore项目中添加我们的数据访问上下文对象MagBlogDbContext，继承自。然后重写方法新建静态扩展类和扩展方法，用来配置实体。在.Domain层创建配置文件访问类appsettings.json中的设置值appsettings.json文件修改连接字符串。
在ABP中通过EF直接执行原生Sql的解决方案
killcwd的专栏
07-21 4443
一般情况下，使用EF中的查询语法和方法语法可以帮助我们完成绝大部分业务，但是也有特殊的情况需要直接执行Sql语句。比如，我们的业务过于复杂繁琐，或是有些业务使用EF操作时比较复杂，但是使用Sql时会很简单等等。 今天做项目的时候，就由于使用EF来处理逻辑时格外棘手，最终选择了直接执行Sql语句，下面说说具体的业务。 一共关系到三张表，分别是Operators(运营商表)，Orders(订单表)
ABP中使用执行Sql语句
sinat_29009169的博客
05-08 6047
由于EFCore现在并不支持直接执行sql语句，没有SqlQuery这个函数可以执行。 在ABP中执行Sql语句有三种方式1.ExecuteSqlCommand2.FromSql3.使用RawSqlCommand、RelationalDataReader、DbDataReader进行读取 1.使用ExecuteSqlCommand执行sql语句，返回改变的行数量 /// &...
ABP执行原生sql
kalvin_y_liu的博客
08-18 1017
代码】ABP执行原生sql。
ABP 使用SQL语句 执行 SQL 语句
Martin 的博客
02-19 948
ABP 使用SQL语句 执行 SQL 语句 需要安装的nuget包，看看文档，大概就是这样 xx.Application： xx.Core：
.NET Core Dapper(ORM) 执行sql语句和事物(Transaction)
weixin_42098295的博客
03-23 1365
Dapper 是一个简单的.NET ORM（对象关系映射器）工具，它提供了轻量级的方法来处理数据库操作。与其他ORM工具相比，Dapper的目标是提供快速、简单且非侵入式的数据库访问。Action是.Net中的委托，在委托方法中执行Dapper的具体操作，并且使用传入的连接和事物。
ef core输出sql语句(abp vnext)
mansai的专栏
07-14 1908
参考文档 https://docs.microsoft.com/zh-cn/ef/core/logging-events-diagnostics/simple-logging protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) => optionsBuilder //输出到控制台 .LogTo(System.Console.WriteLine, new
C# abp中EfCore执行原生sql和事务操作
Code Scenic Area
04-26 1033
Entity Framework Core 原生sql join关联查询 事务操作 仓储链接被释放
(精华)2020年8月22日 ABP vNext Poem相关数据库表的Sql语句
热门推荐
时光隧道
08-21 49万+
public static void Proccess() { int port = 2018; string host = "127.0.0.1"; IPAddress ip = IPAddress.Parse(host); IPEndPoint ipe = new IPEndPoint(ip, port); Socket sSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, Pr
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贴代码科技-致力于开发更加适用的应用

要不请我喝杯咖啡！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值