DbDapperFactory 0.1.3

DbDapperFactory

Español | English

Factory y extensiones de DI para crear DbConnection nombradas y usarlas con Dapper.

Qué es este paquete

DbDapperFactory es un paquete para aplicaciones .NET que simplifica el registro y la creación de conexiones a múltiples bases de datos cuando trabajas con Dapper.

Sirve para:

• registrar varias conexiones por nombre
• asociar cada conexión a un provider específico
• resolver conexiones desde inyección de dependencias
• mantener un punto único para crear DbConnection

Actualmente el paquete incluye soporte para:

• SQL Server
• PostgreSQL
• MySQL
• SQLite
• Oracle

Paquete único

Los paquetes anteriores por provider fueron consolidados en un único paquete:

• DbDapperFactory.Core
• DbDapperFactory.SqlServer
• DbDapperFactory.Postgres
• DbDapperFactory.MySql
• DbDapperFactory.Sqlite
• DbDapperFactory.Oracle

Ahora todo se instala desde:

dotnet add package DbDapperFactory

Cuándo usarlo

Este paquete es útil cuando tu aplicación:

• consume una o varias bases de datos
• necesita separar conexiones por nombre, por ejemplo Main, Reporting, Legacy
• usa Dapper y quieres centralizar la creación de conexiones
• necesita cambiar entre providers sin reescribir toda la infraestructura de acceso a datos

API principal

IDapperConnectionFactory

La interfaz principal expone un único método:

public interface IDapperConnectionFactory
{
    DbConnection CreateConnection(string name);
}

Puntos importantes:

• CreateConnection(name) devuelve una conexión nueva cada vez
• la factory no abre la conexión automáticamente
• tú controlas cuándo llamar a Open() o OpenAsync()
• la conexión debe cerrarse y disponerse con using

Providers soportados

El enum actual es:

public enum DatabaseProvider
{
    SqlServer,
    Postgres,
    MySql,
    Sqlite,
    Oracle
}

Formas de registro disponibles

La librería soporta tres formas principales de registrar conexiones.

Opción 1: registro fluido por provider

Usa esta opción cuando quieres definir cada conexión explícitamente en código.

Importante: los métodos AddSqlServer, AddPostgres, AddMySql, AddSqlite y AddOracle viven en el namespace DbDapperFactory.Providers.

using DbDapperFactory;
using DbDapperFactory.Providers;
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddDapperConnectionFactory()
    .AddSqlServer("Main", builder.Configuration.GetConnectionString("Main")!)
    .AddPostgres("Reporting", builder.Configuration.GetConnectionString("Reporting")!)
    .AddMySql("Legacy", builder.Configuration.GetConnectionString("Legacy")!);

También puedes usar los demás providers:

builder.Services
    .AddDapperConnectionFactory()
    .AddSqlite("Cache", "Data Source=cache.db;")
    .AddOracle("ERP", "User Id=user;Password=pass;Data Source=MyOracleDb");

Opción 2: registro por nombre + DatabaseProvider

Usa esta opción cuando quieres leer las cadenas desde ConnectionStrings y solo indicar en código qué provider corresponde a cada nombre.

appsettings.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=localhost;Database=Documents;User Id=sa;Password=YourPassword;TrustServerCertificate=True",
    "PostgresConnection": "Host=localhost;Port=5432;Database=documents;Username=postgres;Password=secret;Search Path=public"
  }
}

Registro:

using DbDapperFactory;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();
var configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .Build();

services.AddProviderDapperConnectionFactory(
    configuration,
    ("DefaultConnection", DatabaseProvider.SqlServer),
    ("PostgresConnection", DatabaseProvider.Postgres));

La librería buscará cada cadena en ConnectionStrings:{Name} y creará la conexión adecuada según el DatabaseProvider indicado.

AddMultiDbConnectionFactory sigue existiendo como alias obsoleto, pero la API recomendada es AddProviderDapperConnectionFactory.

Opción 3: registro por sección de configuración

Usa esta opción cuando quieres declarar también el provider dentro de la configuración.

appsettings.json:

{
  "ConnectionStrings": {
    "MainDb": "Server=localhost;Database=AppDb;User Id=sa;Password=YourPassword;TrustServerCertificate=True",
    "ReportingDb": "Host=localhost;Port=5432;Database=reporting;Username=postgres;Password=secret"
  },
  "DbDapperFactory": {
    "Connections": [
      {
        "Name": "Main",
        "Provider": "SqlServer",
        "ConnectionStringName": "MainDb"
      },
      {
        "Name": "Reporting",
        "Provider": "Postgres",
        "ConnectionStringName": "ReportingDb"
      },
      {
        "Name": "Cache",
        "Provider": "Sqlite",
        "ConnectionString": "Data Source=cache.db;"
      }
    ]
  }
}

Registro:

using DbDapperFactory;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDapperConnectionFactory(builder.Configuration);

La sección usada por defecto es DbDapperFactory.

Cada conexión puede resolver su cadena de estas formas:

• ConnectionString: cadena directa
• ConnectionStringName: nombre dentro de ConnectionStrings
• si omites ambas, intenta usar Name como clave dentro de ConnectionStrings

Ejemplo de uso con Dapper

using DbDapperFactory;
using Dapper;

public sealed class UsersRepository
{
    private readonly IDapperConnectionFactory _connections;

    public UsersRepository(IDapperConnectionFactory connections)
        => _connections = connections;

    public async Task<User?> GetByIdAsync(Guid id)
    {
        using var conn = _connections.CreateConnection("Main");
        await conn.OpenAsync();

        return await conn.QuerySingleOrDefaultAsync<User>(
            "select * from users where id = @id",
            new { id });
    }

    public async Task<List<User>> GetAllAsync()
    {
        using var conn = _connections.CreateConnection("Main");
        await conn.OpenAsync();

        var users = await conn.QueryAsync<User>("select * from users");
        return users.ToList();
    }

    public async Task<int> CreateAsync(User user)
    {
        using var conn = _connections.CreateConnection("Main");
        await conn.OpenAsync();

        return await conn.ExecuteAsync(
            "insert into users (id, name, email) values (@id, @name, @email)",
            user);
    }
}

public sealed class User
{
    public Guid Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
}

Ejemplo con múltiples bases de datos

using DbDapperFactory;
using DbDapperFactory.Providers;
using Dapper;

var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddDapperConnectionFactory()
    .AddSqlServer("Operational", builder.Configuration.GetConnectionString("Operational")!)
    .AddPostgres("Analytics", builder.Configuration.GetConnectionString("Analytics")!);

public sealed class ReportingService
{
    private readonly IDapperConnectionFactory _connections;

    public ReportingService(IDapperConnectionFactory connections)
        => _connections = connections;

    public async Task<IReadOnlyList<OrderSummary>> GetOperationalOrdersAsync()
    {
        using var conn = _connections.CreateConnection("Operational");
        await conn.OpenAsync();

        var rows = await conn.QueryAsync<OrderSummary>(
            "select top 10 Id, CustomerName, Total from dbo.Orders order by CreatedAt desc");

        return rows.AsList();
    }

    public async Task<IReadOnlyList<DailySales>> GetAnalyticsAsync()
    {
        using var conn = _connections.CreateConnection("Analytics");
        await conn.OpenAsync();

        var rows = await conn.QueryAsync<DailySales>(
            "select day, total from public.daily_sales order by day desc limit 10");

        return rows.AsList();
    }
}

Ejemplo rápido del paquete

Si quieres una referencia corta de para qué sirve el paquete, este es un caso típico:

using DbDapperFactory;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

var configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .Build();

var services = new ServiceCollection();

services.AddProviderDapperConnectionFactory(
    configuration,
    ("SqlDb", DatabaseProvider.SqlServer),
    ("PgDb", DatabaseProvider.Postgres));

var provider = services.BuildServiceProvider();
var factory = provider.GetRequiredService<IDapperConnectionFactory>();

using var sqlConnection = factory.CreateConnection("SqlDb");
using var pgConnection = factory.CreateConnection("PgDb");

Ese ejemplo muestra el objetivo del paquete: crear conexiones correctas por nombre y provider sin que tu código consumidor tenga que instanciar manualmente SqlConnection, NpgsqlConnection, MySqlConnection, SQLiteConnection u OracleConnection en distintos lugares.

Notas importantes

• CreateConnection(name) crea una instancia nueva cada vez.
• La factory no abre conexiones automáticamente.
• La librería funciona bien con Dapper, pero también puede usarse con ADO.NET puro.
• Si registras conexiones duplicadas por nombre en el builder fluido, la factory lanzará una excepción al resolverlas.
• Si usas AddProviderDapperConnectionFactory, cada nombre debe existir en ConnectionStrings.

Migración desde versiones anteriores

Si todavía estabas usando paquetes separados por provider, migra así:

1. Remueve los paquetes antiguos

dotnet remove package DbDapperFactory.Core
dotnet remove package DbDapperFactory.SqlServer
dotnet remove package DbDapperFactory.Postgres
dotnet remove package DbDapperFactory.MySql
dotnet remove package DbDapperFactory.Sqlite
dotnet remove package DbDapperFactory.Oracle

2. Instala el paquete único

dotnet add package DbDapperFactory

3. Ajusta los using si usas métodos por provider

using DbDapperFactory;
using DbDapperFactory.Providers;

👤 Autor

guevararogeljj

Licencia

Este proyecto está bajo licencia MIT.