.net core3.1使用Dapper访问oracle数据库

最新推荐文章于 2024-07-01 16:58:35 发布
最新推荐文章于 2024-07-01 16:58:35 发布
阅读量2.7k 收藏 13
点赞数 3
分类专栏： .net core 文章标签： .net oracle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shaojiayong/article/details/109210926
版权

前言

相信大家在选择ORM（对象关系映射器）框架的时候，都有自己的比较跟个人习惯，目前.net国内主流的ORM有Entity Framework (EF) 、NHibernate、Dapper、SqlSuger等等。在选择一个适合自己的ORM的时候，我会考虑到几个方面，社区活跃度、功能完善度、支持多种SQL、性能方面，而Dapper在速度方面拥有Micro-ORM之王的称号，社区活跃度也还不错，功能也比较完善，因此本文选择Dapper作为我们项目的ORM框架来访问oracle数据库，选择访问oracle数据库是因为网上有很多访问mssql，Mysql的了，这里就演示访问oracle的。

开始

创建Asp.Net Core API项目

这步参照我的文章《.net core3.1项目部署到linux的docker》

NuGet添加依赖项

在这里插入图片描述

TestAPI.csproj

  <ItemGroup>
    <PackageReference Include="Oracle.ManagedDataAccess.Core" Version="2.19.91" />
    <PackageReference Include="Dapper" Version="2.0.35" />
    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
  </ItemGroup>

添加连接类

appsettings.json文件

{
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Trace",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "OracleConnectionString": "data source=192.168.1.230:1521/xfdb;password=password;user id=test;Incr Pool Size=5;Decr Pool Size=2;"
  }
}

创建数据库连接类

用于管理我们的数据库连接字符串以及其他数据库的连接配置
ConnectionConfig.cs

    public class ConnectionConfig
    {
        public string ConnectionString { get; set; }
        public DbStoreType DbType { get; set; }
    }

    public enum DbStoreType
    {
        MySql = 0,
        SqlServer = 1,
        Sqlite = 2,
        Oracle = 3
    }

    public class DapperFactoryOptions
    {
        public IList<Action<ConnectionConfig>> DapperActions { get; } = new List<Action<ConnectionConfig>>();
    }

封装数据库操作类

新建一个类，自行封装一些增删改查的方法
DapperClient.cs

    public class DapperClient
    {
        public ConnectionConfig CurrentConnectionConfig { get; set; }

        public DapperClient(IOptionsMonitor<ConnectionConfig> config)
        {
            CurrentConnectionConfig = config.CurrentValue;
        }

        public DapperClient(ConnectionConfig config) { CurrentConnectionConfig = config; }

        IDbConnection _connection = null;
        public IDbConnection Connection
        {
            get
            {
                switch (CurrentConnectionConfig.DbType)
                {
                    //case DbStoreType.MySql:
                    //    _connection = new MySql.Data.MySqlClient.MySqlConnection(CurrentConnectionConfig.ConnectionString);
                    //    break;
                    //case DbStoreType.Sqlite:
                    //    _connection = new SQLiteConnection(CurrentConnectionConfig.ConnectionString);
                    //    break;
                    //case DbStoreType.SqlServer:
                    //    _connection = new System.Data.SqlClient.SqlConnection(CurrentConnectionConfig.ConnectionString);
                    //    break;
                    case DbStoreType.Oracle:
                        _connection = new Oracle.ManagedDataAccess.Client.OracleConnection(CurrentConnectionConfig.ConnectionString);
                        break;
                    default:
                        throw new Exception("未指定数据库类型！");
                }
                return _connection;
            }
        }

        /// <summary>
        /// 执行SQL返回集合
        /// </summary>
        /// <param name="strSql">sql语句</param>
        /// <returns></returns>
        public virtual List<T> Query<T>(string strSql)
        {
            using (IDbConnection conn = Connection)
            {
                return conn.Query<T>(strSql, null).ToList();
            }
        }

        /// <summary>
        /// 执行SQL返回集合
        /// </summary>
        /// <param name="strSql">SQL语句</param>
        /// <param name="obj">参数model</param>
        /// <returns></returns>
        public virtual List<T> Query<T>(string strSql, object param)
        {
            using (IDbConnection conn = Connection)
            {
                return conn.Query<T>(strSql, param).ToList();
            }
        }

        /// <summary>
        /// 执行SQL返回一个对象
        /// </summary>
        /// <param name="strSql">SQL语句</param>
        /// <returns></returns>
        public virtual T QueryFirst<T>(string strSql)
        {
            using (IDbConnection conn = Connection)
            {
                return conn.Query<T>(strSql).FirstOrDefault<T>();
            }
        }

        /// <summary>
        /// 执行SQL返回一个对象
        /// </summary>
        /// <param name="strSql">SQL语句</param>
        /// <returns></returns>
        public virtual async Task<T> QueryFirstAsync<T>(string strSql)
        {
            using (IDbConnection conn = Connection)
            {
                var res = await conn.QueryAsync<T>(strSql);
                return res.FirstOrDefault<T>();
            }
        }

        /// <summary>
        /// 执行SQL返回一个对象
        /// </summary>
        /// <param name="strSql">SQL语句</param>
        /// <param name="obj">参数model</param>
        /// <returns></returns>
        public virtual T QueryFirst<T>(string strSql, object param)
        {
            using (IDbConnection conn = Connection)
            {
                return conn.Query<T>(strSql, param).FirstOrDefault<T>();
            }
        }

        /// <summary>
        /// 执行SQL
        /// </summary>
        /// <param name="strSql">SQL语句</param>
        /// <param name="param">参数</param>
        /// <returns>0成功，-1执行失败</returns>
        public virtual int Execute(string strSql, object param)
        {
            using (IDbConnection conn = Connection)
            {
                try
                {
                    return conn.Execute(strSql, param) > 0 ? 0 : -1;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }

        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="strProcedure">过程名</param>
        /// <returns></returns>
        public virtual int ExecuteStoredProcedure(string strProcedure)
        {
            using (IDbConnection conn = Connection)
            {
                try
                {
                    return conn.Execute(strProcedure, null, null, null, CommandType.StoredProcedure) == 0 ? 0 : -1;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }

        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="strProcedure">过程名</param>
        /// <param name="param">参数</param>
        /// <returns></returns>
        public virtual int ExecuteStoredProcedure(string strProcedure, object param)
        {
            using (IDbConnection conn = Connection)
            {
                try
                {
                    return conn.Execute(strProcedure, param, null, null, CommandType.StoredProcedure) == 0 ? 0 : -1;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }


    }

定义接口

新增一个接口类，这里就写了一个CreateClient方法
IDapperFactory.cs

	public interface IDapperFactory
	{
		DapperClient CreateClient(string name);
	}

实现接口
DefaultDapperFactory.cs

    public class DefaultDapperFactory : IDapperFactory
    {
        private readonly IServiceProvider _services;
        private readonly IOptionsMonitor<DapperFactoryOptions> _optionsMonitor;

        public DefaultDapperFactory(IServiceProvider services, IOptionsMonitor<DapperFactoryOptions> optionsMonitor)
        {
            _services = services ?? throw new ArgumentNullException(nameof(services));
            _optionsMonitor = optionsMonitor ?? throw new ArgumentNullException(nameof(optionsMonitor));
        }

        public DapperClient CreateClient(string name)
        {
            if (name == null)
                throw new ArgumentNullException(nameof(name));

            var client = new DapperClient(new ConnectionConfig { });

            var option = _optionsMonitor.Get(name).DapperActions.FirstOrDefault();
            if (option != null)
                option(client.CurrentConnectionConfig);
            else
                throw new ArgumentNullException(nameof(option));

            return client;
        }

    }

依赖注入

依赖注入入口

DapperFactoryCollectionExtensions.cs

    public static class DapperFactoryCollectionExtensions
    {
        public static IServiceCollection AddDapper(this IServiceCollection services)
        {
            if (services == null)
                throw new ArgumentNullException(nameof(services));

            services.AddLogging();
            services.AddOptions();

            services.AddSingleton<DefaultDapperFactory>();
            services.TryAddSingleton<IDapperFactory>(serviceProvider => serviceProvider.GetRequiredService<DefaultDapperFactory>());

            return services;
        }

        public static IDapperFactoryBuilder AddDapper(this IServiceCollection services, string name, Action<ConnectionConfig> configureClient)
        {
            if (services == null)
                throw new ArgumentNullException(nameof(services));

            if (name == null)
                throw new ArgumentNullException(nameof(name));

            if (configureClient == null)
                throw new ArgumentNullException(nameof(configureClient));

            AddDapper(services);

            var builder = new DefaultDapperFactoryBuilder(services, name);
            builder.ConfigureDapper(configureClient);
            return builder;
        }

        public static IDapperFactoryBuilder ConfigureDapper(this IDapperFactoryBuilder builder, Action<ConnectionConfig> configureClient)
        {
            if (builder == null)
                throw new ArgumentNullException(nameof(builder));

            if (configureClient == null)
                throw new ArgumentNullException(nameof(configureClient));

            builder.Services.Configure<DapperFactoryOptions>(builder.Name, options => options.DapperActions.Add(configureClient));

            return builder;
        }

    }

    public interface IDapperFactoryBuilder
    {
        string Name { get; }

        IServiceCollection Services { get; }
    }

    internal class DefaultDapperFactoryBuilder : IDapperFactoryBuilder
    {
        public DefaultDapperFactoryBuilder(IServiceCollection services, string name)
        {
            Services = services;
            Name = name;
        }

        public string Name { get; }

        public IServiceCollection Services { get; }
    }

如果要在控制器或仓储类中使用依赖项的话，我们必须配置或者说在Startup类的ConfigureServices方法中为我们的接口注册我们的依赖项类。

Startup.cs

        public void ConfigureServices(IServiceCollection services)
        {
            连接sqlserver
            //services.AddDapper("SqlDb", m =>
            //{
            //    m.ConnectionString = Configuration.GetConnectionString("DefaultConnection");
            //    m.DbType = DbStoreType.SqlServer;
            //});
            //连接Oracle
            services.AddDapper("OracleConnection", m =>
            {
                m.ConnectionString = Configuration.GetConnectionString("OracleConnectionString");
                m.DbType = DbStoreType.Oracle;
            });
            services.AddControllers();
        }

测试方法

写个简单的控制器，测试我们的封装的方法
UserController.cs

    [Route("api/[controller]")]
    [ApiController]
    public class UserController : ControllerBase
    {
        //private readonly DapperClient _SqlDB;
        private readonly DapperClient _OracleDB;
        public UserController(IDapperFactory dapperFactory)
        {
            _OracleDB = dapperFactory.CreateClient("OracleConnection");
            //_SqlDB = dapperFactory.CreateClient("SqlDb");
        }
        [HttpGet("getuser")]
        public string GetUser()
        {
            var testQuery = _OracleDB.Query<dynamic>(@"SELECT * FROM TEST_USER where ROWNUM<=5");
            //var result = _SqlDB.Query<dynamic>(@"select * from [UserInfo](nolock)");
            return JsonConvert.SerializeObject(testQuery);
        }

    }

运行截图在这里插入图片描述

Hello，Mr.S
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
.NET Core 使用scheduleMaster访问Oracle，各种采坑记录
weixin_44075727的博客
06-02 296
scheduleMaster
ASP.NET Core 中使用 Dapper 的 Oracle 存储过程输出参数
06-12
Oracle 数据库功能强大，在企业环境中使用广泛。在 ASP.NET Core 应用程序中使用 Oracle 存储过程时，处理输出参数可能具有挑战性。该源码将指导您完成使用 Dapper（适用于 . NET 的轻量级 ORM（对象关系映射器））解锁 Oracle 存储过程输出参数的过程。
C# oracle连接问题 Ora-28040
最新发布
Dongbo1123的博客
07-01 203
ORA-28040 oracle 10g
.NET Core中使用Dapper操作Oracle存储过程最佳实践
依乐祝的博客
04-30 665
.NET Core中使用Dapper操作Oracle存储过程最佳实践 为什么说是最佳实践呢？因为在实际开发中踩坑了，而且发现网上大多数文章给出的解决方法都不能很好地解决问题。尤其是在获取类型为OracleDbType.RefCursor，输出为：ParameterDirection.Output数据的时候。网上千篇一律的说写一个OracleDyna...
C# Dapper 操作Oracle数据库
easyboot的专栏
08-30 1610
1.配置连接字符串 OracleConnectionString这个可用。3.Dapper数据库操作类。
.net core3.1 dapper使用(Oracle链接字符串)
FengxcLf的博客
03-22 2315
历经的艰辛就不多少了(.net 新手 不喜勿喷 欢迎指点) 废话不多说了，直接上正题： 1.首先建一个类来管理数据库连接 public class DbFactory : IDbFactory { readonly IOptions _options; public DbFactory(IOptions options) { _options = options; } public DbConn...
Dapper连接Oracle
weixin_34220179的博客
06-21 980
Dapper连接Oracle去年写过了篇博客，名字叫：让dapper支持Oracle 网址：http://www.cnblogs.com/ushou/archive/2012/09/28/2706905.html有很多网友查看并评论，也引来很多网站转载，在这里深表歉意，因为去年搞的思路是错的，我有罪呀。其实Dapper原生是支持Oracle的，只是去年水平有限，或者说查阅的资料还不够多，所以“毁...
CleanArchitecture.NetCore:.Net Core 3.1和Dapper的Ejempplo de Clean Architecture
03-27
介绍待办事项：简单介绍您的项目。 让本节解释该项目背后的目标或动机。入门TODO：指导用户启动您的代码并在自己的系统上运行。 在本节中，您可以讨论： 安装过程软件依赖项最新发行API参考构建和测试待办事项：描述...
.NET Core Dapper操作mysql数据库的实现方法
01-20
如何在.NET Core中使用Dapper操作Mysql数据库呢，让我们跟随镜头(手动下翻)一看究竟。 配置篇 俗话说得好，欲要善其事必先利其器。首先，我们要引入MySql.Data 的Nuget包。有人可能出现了黑人脸，怎么引入。也罢，看...
【ASP.NET编程知识】.NET Core Dapper操作mysql数据库的实现方法.docx
05-14
本文介绍了如何在 .NET Core 中使用 Dapper 操作 Mysql 数据库的实现方法，包括安装 MySql.Data Nuget 包、配置 Mysql 连接字符串、创建 BaseRepository 类和使用 Dapper 操作 Mysql 数据库等。
.net5 dapper封装操作数据库
07-26
总结来说，这个项目展示了如何在.NET 5环境下，通过Dapper进行数据库操作的封装，利用`DapperHelper`和`DapperExtHelper`提供灵活的数据库访问功能，同时通过`ConnectionOption`管理数据库连接配置。这种封装方式有...
ASPNETCore3.1-AzureAppConfiguration-Dapper-SQL：实例化API REST的示例ASP.NET Core 3.1可以使用Dapper，SQL Server（试用版）和服务来进行Azure应用程序配置（可以简化Azure应用程序的配置）配置临时执行权限，以确保您的应用程序正常运行）
02-21
ASPNETCore3.1-AzureAppConfiguration-Dapper-SQL：实例化API REST的示例ASP.NET Core 3.1可以使用Dapper，SQL Server（试用版）和服务来进行Azure应用程序配置（可以简化Azure应用程序的配置）配置临时执行权限，以确保您的应用程序正常运行）
Dapper.Oracle:Oracle对Dapper Micro ORM的支持
05-22
精巧的Oracle Oracle对Dapper Micro ORM的支持。 介绍 如果要编写与数据库无关的代码，Dapper是一个很好的工具。 但是，有时您需要访问特定于提供程序的功能。 该程序集增加了对编写特定于OracleSQL的支持，该SQL支持Oracle托管提供程序在参数上使用的所有dbtype，支持在命令上设置各种属性（LOBFetchSize，ArrayBindCount，BindByName），以及在参数上设置CollectionType。 使用此程序包，您现在可以运行返回RefCursor的存储过程，或使用数组绑定计数来执行带有参数数组的sql语句。 受支持的Oracle特定属性 OracleParameter（托管和非托管） OracleDbType枚举（托管提供者使用的所有成员） CollectionType枚举 ParameterStatus（执行存储过程时的返
Dapper源码
10-09
Dapper-master源码，可以生成各个版本的 Dapper，4.0,4.5都可用
.Net如何优雅的使用Dapper访问oracle数据库
u014312720的博客
07-12 4057
1、引用Dapper 2、创建DapperFactory类 public class DapperFactory { public static readonly string connectionString = ConfigurationManager.AppSettings["connection_string"]; public static OracleConnection CrateOracleConnection() {
drapper oracle,.Net如何优雅的使用Dapper访问oracle数据库
weixin_34049168的博客
04-07 601
1、引用Dapper 2、创建DapperFactory类public class DapperFactory{public static readonly string connectionString = ConfigurationManager.AppSettings["connection_string"];public static OracleConnection CrateOracl...
.net core 3.1 Dapper性能王者的ORM框架
dawei.tu的博客
06-20 1072
.net core 3.1 Dapper性能王者的ORM框架 什么是dapper？ 官网地址：https://dapper-tutorial.net/ Dapper 是一个简单的 .NET 对象映射器，在速度方面拥有Micro ORM之王的称号，几乎与使用原始 ADO.NET 数据读取器一样快。ORM 是一个对象关系映射器，负责数据库和编程语言之间的映射。 Dapper 通过提供有用的扩展方法来查询数据库来扩展 IDbConnection。 直接上代码案列 首先环境是.net core 3.1 在nuget
C# .NET Core 连接Oracle数据库之使用Oracle.ManagedDataAccess.Core
Three_ST的博客
12-05 1146
使用C#读取Oracle数据库。
.NET CORE 使用Dapper.OracleCRUD简化数据库操作
刘联其的个人分享
05-23 1499
第一步:通过vs版本NuGet下载Dapper.OracleCRUD包 第二步：在Startup.cs下配置：SimpleDapperCRUD.SetDialect(SimpleDapperCRUD.Dialect.OracleSQL); 第三步：配置数据库连接字符串 第四步：开始使用 备注： 0、本NuGet包同样支持其他数据库类型：PGSQL,MYSQL,...
.NET Core 2.0 中使用 Dapper 替换 Identity 的数据库操作实战
"ASP.NET编程知识，.NET Core 2.0环境下使用Identity并改用Dapper进行数据存储的实例教程" 在.NET Core 2.0的开发中，开发者经常使用Identity框架来处理用户认证和授权。然而，官方文档推荐使用Entity Framework ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Hello，Mr.S

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值