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

最新推荐文章于 2023-04-26 17:43:29 发布
最新推荐文章于 2023-04-26 17:43:29 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： .net Core C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Apeart/article/details/107637025
版权
.net Core 同时被 2 个专栏收录
13 篇文章 0 订阅
订阅专栏
C#
13 篇文章 0 订阅
订阅专栏

直接上代码

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;
        }

    }
}

 

PasteSpider
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
ABP中使用执行Sql语句
sinat_29009169的博客
05-08 5809
由于EFCore现在并不支持直接执行sql语句，没有SqlQuery这个函数可以执行。 在ABP中执行Sql语句有三种方式1.ExecuteSqlCommand2.FromSql3.使用RawSqlCommand、RelationalDataReader、DbDataReader进行读取 1.使用ExecuteSqlCommand执行sql语句，返回改变的行数量 /// &...
.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
在ABP中通过EF直接执行原生Sql的解决方案
killcwd的专栏
07-21 4335
一般情况下，使用EF中的查询语法和方法语法可以帮助我们完成绝大部分业务，但是也有特殊的情况需要直接执行Sql语句。比如，我们的业务过于复杂繁琐，或是有些业务使用EF操作时比较复杂，但是使用Sql时会很简单等等。 今天做项目的时候，就由于使用EF来处理逻辑时格外棘手，最终选择了直接执行Sql语句，下面说说具体的业务。 一共关系到三张表，分别是Operators(运营商表)，Orders(订单表)
在Abp中执行sql语句
zhanglong_longlong的专栏
07-30 1810
http://www.8023me.com/blog/detail/4 最近使用ABP(ASP.NET Boilerplate)做项目，有些查询(或存储过程)直接使用sql语句会更方便一点。 定义一个接口 在Core项目中定义一个接口，如：ISqlExecuter public interface ISqlExecuter { /// <summary> /// 执行给定的命令 /// </summary&gt.
Abp.Aliyun:专门为 ABP vNext 框架开发的阿里云 SDK 模块
05-06
Abp.Aliyun 专门为 ABP vNext 框架开发的阿里云 SDK 模块。 一、简要介绍 EasyAbp.Abp.Aliyun 库是针对于阿里云 API 进行了二次封装模块，与 ABP vNext 框架深度集成。 二、基本配置 开发人员根据自身项目情况，选择...
Lsw.Abp.AspNetCore.Mvc.UI.Theme.Stisla:ABP vnext Mvc UI 主题
07-23
Lsw.Abp.AspNetCore.Mvc.UI.Theme.Stisla abp框架mvc ui主题包，使用bootstrap，所以兼容abp标签助手。 入门 使用 abp CLI 创建一个新项目 abp new BookStore 将Lsw.Abp.AspNetCore.Mvc.UI.Theme.Stisla nuget 包...
Abp.Captcha:基于ABP vNext的人机验证模块
03-27
**Abp.Captcha 模块详解** `Abp.Captcha` 是一个专为 ABP vNext 框架设计的验证码模块，旨在增强应用程序的安全性，防止自动化脚本或恶意机器人进行非法操作。该模块提供了两种不同的验证码类型：滑杆验证和竖锯...
Abp.AspNetCore.Mvc.UI.Theme.AdminLTE:基于AdminLTE的ABP主题模块
05-02
Abp.AspNetCore.Mvc.UI.Theme.AdminLTE 基于的主题模块如何使用安装nuget包网路专案： Install-Package Abp.AspNetCore.Mvc.UI.Theme.AdminLTE 替换主题模块取决于网路专案： ...[ DependsOn ( ... // typeof...
MyABPTest_.netcore_ABP示例_abp_
09-30
标题中的"MyABPTest_.netcore_ABP示例_abp_"表明这是一个基于.NET Core的ABP框架实践项目，旨在展示如何使用ABP框架构建一个实际的应用程序。"MyABPTest"可能是这个示例项目的名称，意味着我们将探索如何创建和配置...
ABP执行原生sql
kalvin_y_liu的博客
08-18 848
代码】ABP执行原生sql。
ABP 使用SQL语句 执行 SQL 语句
Martin 的博客
02-19 865
ABP 使用SQL语句 执行 SQL 语句 需要安装的nuget包，看看文档，大概就是这样 xx.Application： xx.Core：
.net core 执行SQL语句返回数据
陈熙之的博客
08-13 1140
private readonly BaseContext _context; public BuyService(BaseContext context) : base(context) { _context = context; } var conn = _context.Database.GetDbConnection(); conn.Open(); using (var command = c.
C# abp中EfCore执行原生sql和事务操作
Code Scenic Area
04-26 651
Entity Framework Core 原生sql join关联查询 事务操作 仓储链接被释放
ABP框架 将EntityFrameworkCore生成的SQL语句输出到控制台
weixin_34248705的博客
02-26 815
首先 在 EntityFrameworkCore中安装Microsoft.Extensions.Logging.Console nuget install Microsoft.Extensions.Logging.Console按照官方文档 使用UseLoggerFactory 方法 (地址：https://docs.microsoft.com/zh-cn/ef/core/miscell...
2.初识Abp(Postgresql)
我就是那个帕吉
03-15 1335
Abp Core 将默认的MSSQL数据库切换为PostgreSql数据库
ABP框架 sql语句（转载）
weixin_30737363的博客
01-09 530
ABP.Core实现SQL语句仓储，支持EF.Core兼容的数据库 来源：https://blog.csdn.net/qq_28699537/article/details/80522680?tdsourcetag=s_pcqq_aiomsg 2018年05月31日 13:22:22余业勤阅读数：82 ISqlRepository.cs代码...
ef core输出sql语句(abp vnext)
mansai的专栏
07-14 1609
参考文档 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
.net core ADO.net 操作数据库---查询
橙-极纪元-cplvfx-JJY.Cheng
07-13 1037
第一步：数据库链接字符串 项目根目录appsettings.json 添加一行 "ConStr": "Data Source=.;database=ceshi;uid=sa;pwd=sa", 完整代码 { "ConStr": "Data Source=.;database=ceshi;uid=sa;pwd=sa", "Logging": { "LogLevel": { "Default": "Information", "Microsoft": "W.
has been blocked by CORS policy: Request header field abp.tenantid is not allowed by Access-Control-Allow-Headers in preflight response.
最新发布
07-27
这个错误是由于CORS策略导致的。CORS（跨域资源共享）是一种浏览器安全机制，用于限制跨域请求。当你的前端应用从一个域名（例如localhost:8080）向另一个域名（例如localhost:3004）发起请求时，浏览器会发送一个预检请求（preflight request）来检查服务器是否允许跨域请求。预检请求会包含一些自定义的请求头字段，比如你提到的abp.tenantid。 根据你提供的引用内容，你可以解决这个问题的方法是在后端的响应头中设置允许前端请求时带有的字段值。你可以在Access-Control-Allow-Headers字段中添加abp.tenantid，以及其他你需要允许的自定义请求头字段。例如： Access-Control-Allow-Headers: Content-Type, Access-Token, Appid, Secret, Authorization, abp.tenantid 这样，当浏览器发送预检请求时，服务器会返回允许的请求头字段列表，从而解决CORS策略导致的问题。 #### 引用[.reference_title] - *1* *2* [has been blocked by CORS policy: Request header field aaa is not allowed by Access-Control-Allow-Hea](https://blog.csdn.net/hbysj/article/details/103301845)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [has been blocked by CORS policy: Request header field secret is not allowed by Access-Control-Allow-](https://blog.csdn.net/MFWSCQ/article/details/109337834)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值