DbDapperFactory.Core 0.1.0

DbDapperFactory

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

¿Qué es DbDapperFactory?

DbDapperFactory es un conjunto de librerías que facilita la integración de múltiples bases de datos en aplicaciones .NET usando Dapper como ORM ligero. Proporciona:

• 🏭 Factory de conexiones nombradas: Define múltiples conexiones a diferentes bases de datos y accede a ellas por nombre.
• 📦 Inyección de dependencias (DI): Integración nativa con Microsoft.Extensions.DependencyInjection.
• 🗄️ Soporte multi-proveedor: SqlServer, PostgreSQL, MySQL, SQLite, Oracle.
• 🔌 Simple y ligero: Minimal overhead, máximo control sobre las conexiones.

Instalación

Instala el paquete Core y el/los paquetes del proveedor que vayas a usar:

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

O desde NuGet Package Manager.

Uso Básico (DI + conexiones nombradas)

1. Configura en el startup

using DbDapperFactory;
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Registra la factory y define tus conexiones
builder.Services
    .AddDapperConnectionFactory()
    .AddSqlServer("Main", configuration.GetConnectionString("Main")!)
    .AddPostgres("Reporting", configuration.GetConnectionString("Reporting")!);

var app = builder.Build();

2. Inyecta y usa en tus servicios

using DbDapperFactory;
using Dapper;

public sealed class UsersRepository
{
    private readonly IDapperConnectionFactory _connections;

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

    // Obtener usuario por ID
    public async Task<User?> GetByIdAsync(Guid id)
    {
        using var conn = _connections.CreateConnection("Main");
        return await conn.QuerySingleOrDefaultAsync<User>(
            "select * from users where id = @id",
            new { id });
    }

    // Listar usuarios
    public async Task<List<User>> GetAllAsync()
    {
        using var conn = _connections.CreateConnection("Main");
        var users = await conn.QueryAsync<User>("select * from users");
        return users.ToList();
    }

    // Crear usuario
    public async Task<int> CreateAsync(User user)
    {
        using var conn = _connections.CreateConnection("Main");
        return await conn.ExecuteAsync(
            "insert into users (id, name, email) values (@id, @name, @email)",
            user);
    }
}

// Modelo
public class User
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

Ejemplos Avanzados

Múltiples bases de datos

// Configuración
services
    .AddDapperConnectionFactory()
    .AddSqlServer("Main", "Server=localhost;Database=MyApp;...")
    .AddPostgres("Analytics", "Host=localhost;Database=Analytics;...")
    .AddMySql("Legacy", "Server=localhost;Database=OldApp;...");

// Uso
public class ReportingService
{
    private readonly IDapperConnectionFactory _connections;

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

    public async Task<List<DailySales>> GetSalesFromAnalyticsAsync()
    {
        using var conn = _connections.CreateConnection("Analytics");
        return (await conn.QueryAsync<DailySales>(
            "select * from daily_sales where date >= @startDate",
            new { startDate = DateTime.Now.AddDays(-30) })).ToList();
    }

    public async Task<List<LegacyUser>> GetUsersFromLegacyAsync()
    {
        using var conn = _connections.CreateConnection("Legacy");
        return (await conn.QueryAsync<LegacyUser>(
            "select * from users")).ToList();
    }
}

Configuración personalizada por proveedor

// SQL Server con opciones
services
    .AddDapperConnectionFactory()
    .AddSqlServer(
        "Main",
        "Server=localhost;Database=MyApp;...",
        configure: conn =>
        {
            conn.ConnectionTimeout = 30;
        });

// PostgreSQL
services.AddPostgres(
    "Reporting",
    "Host=localhost;Database=Analytics;...");

// SQLite
services.AddSqlite(
    "Cache",
    "Data Source=cache.db;");

Notas Importantes

• ✅ La factory no abre la conexión automáticamente. Tú controlas cuándo llamar a Open()/OpenAsync().
• ✅ Cada llamada a CreateConnection(name) crea una instancia nueva de conexión.
• ✅ Usa using para asegurar que la conexión se cierre y disponga correctamente.
• ✅ Compatible con Dapper para queries, inserts, updates, deletes y procedimientos almacenados.

Características