Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern 1.0.1

Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern

Implementación del patrón Repository para SQL Server en aplicaciones .NET basada en Dapper. Este paquete proporciona una implementación concreta de las interfaces definidas en Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern.Abstractions.

Instalación

Package Manager

Install-Package Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern

.NET CLI

dotnet add package Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern

Características principales

• Implementación completa del patrón Repository: Implementa la interfaz IRepo<TEntity> para proporcionar acceso a datos
• Basado en Dapper: Utiliza Dapper para un acceso a datos de alto rendimiento
• Operaciones CRUD: Implementación completa de operaciones Crear, Leer, Actualizar y Eliminar
• Mapeo automático y manual: Soporte para mapeo automático de Dapper y mapeo personalizado
• Operaciones con DTO: Implementación de métodos para trabajar directamente con DTOs
• Convenciones de nomenclatura: Uso inteligente de nombres para procedimientos almacenados
• Filtrado de parámetros: Elimina automáticamente parámetros no válidos para evitar errores
• Extensiones para IoC: Métodos de extensión para facilitar el registro en contenedores de IoC
• Soporte para múltiples esquemas: Permite organizar procedimientos por esquemas de base de datos

Implementación principal

Este paquete proporciona la clase Repo<TEntity> que implementa la interfaz IRepo<TEntity> definida en el paquete de abstracciones:

public class Repo<TEntity> : IRepo<TEntity> where TEntity : class
{
    private readonly ISqlDataAccess sql;
    private readonly string schema;
    private readonly string Prefix_SP;
    private readonly string TableName;
    
    public Repo(ISqlDataAccess sql, Enum? _schema = null)
    {
        this.sql = sql;
        this.db = sql;
        TableName = typeof(TEntity).Name.Replace("Entity", "").Replace("Dto", "");
        schema = _schema?.ToString() ?? "dbo";
        schema += ".";
        Prefix_SP = schema + TableName;
    }
    
    // Implementación de todos los métodos definidos en IRepo<TEntity>
    // ...
}

Registro en el contenedor de IoC

El paquete proporciona métodos de extensión para facilitar el registro de las implementaciones en contenedores de IoC:

public static class RepoDependecyInjection
{
    // Registra el repositorio como Singleton (para datos que rara vez cambian)
    public static IServiceCollection AddRepoSingleton<TEntity>(
        this IServiceCollection Service, 
        Enum? Schema = null
    ) where TEntity : class
    {
        Service.AddSingleton<IRepo<TEntity>>(sp => 
            new Repo<TEntity>(sp.GetRequiredService<ISqlDataAccess>(), Schema));
        return Service;
    }
    
    // Registra el repositorio como Scoped (para la mayoría de los casos)
    public static IServiceCollection AddRepoScoped<TEntity>(
        this IServiceCollection Service, 
        Enum? Schema = null
    ) where TEntity : class
    {
        Service.AddScoped<IRepo<TEntity>>(sp => 
            new Repo<TEntity>(sp.GetRequiredService<ISqlDataAccess>(), Schema));
        return Service;
    }
    
    // Registra el repositorio como Transient (para casos especiales)
    public static IServiceCollection AddRepoTransient<TEntity>(
        this IServiceCollection Service, 
        Enum? Schema = null
    ) where TEntity : class
    {
        Service.AddTransient<IRepo<TEntity>>(sp => 
            new Repo<TEntity>(sp.GetRequiredService<ISqlDataAccess>(), Schema));
        return Service;
    }
}

Configuración y uso

1. Definir enumeración de esquemas

Primero, define una enumeración para representar tus esquemas de base de datos:

public enum EsquemaDB
{
    dbo,
    Ventas,
    Inventario,
    RRHH,
    Contabilidad
}

2. Registrar repositorios en Program.cs

var builder = WebApplication.CreateBuilder(args);

// Registrar los servicios necesarios
builder.Services.AddScoped<ISqlDataAccess, SqlDataAccess>();

// Registrar repositorios con esquema predeterminado (dbo)
builder.Services.AddRepoScoped<ProductoEntity>();
builder.Services.AddRepoScoped<ClienteEntity>();
builder.Services.AddRepoSingleton<ConfiguracionEntity>();

// Registrar repositorios con esquemas personalizados
builder.Services.AddRepoScoped<InventarioEntity>(EsquemaDB.Inventario);
builder.Services.AddRepoScoped<VentaEntity>(EsquemaDB.Ventas);
builder.Services.AddRepoScoped<EmpleadoEntity>(EsquemaDB.RRHH);

// Registrar repositorios con ámbito Transient (nuevas instancias cada vez)
builder.Services.AddRepoTransient<LogEntity>();

var app = builder.Build();
// Resto de la configuración...

3. Uso en servicios

public class ProductoService
{
    private readonly IRepo<ProductoEntity> _productoRepo;
    
    public ProductoService(IRepo<ProductoEntity> productoRepo)
    {
        _productoRepo = productoRepo;
    }
    
    public async Task<IEnumerable<ProductoDto>> ObtenerProductosActivos()
    {
        return await _productoRepo.ObtenerDto<ProductoDto>(
            new { Activo = true }
        );
    }
    
    public async Task<DBEntity> GuardarProducto(ProductoEntity producto)
    {
        return await _productoRepo.Guardar(producto);
    }
}

Convenciones de nomenclatura

La implementación utiliza convenciones para construir los nombres de los procedimientos almacenados:

• La clase Repo determina el nombre de tabla a partir del nombre de la entidad, quitando los sufijos "Entity" o "Dto"
• Utiliza el esquema proporcionado como prefijo
• Agrega el nombre del método como sufijo

Por ejemplo, para una entidad ProductoEntity en el esquema Inventario:

• Inventario.ProductoObtener
• Inventario.ProductoObtenerById
• Inventario.ProductoGuardar
• Inventario.ProductoEliminar

Filtrado de parámetros

La implementación incluye un método UseParamerter que filtra automáticamente los parámetros no válidos antes de enviarlos a la base de datos:

public DynamicParameters? UseParamerter(object? parameters)
{
    var useparam = new DynamicParameters();
    
    if (parameters == null) return useparam;
    
    static bool IsNotValidType(Type type) =>
        (type.IsClass && type != typeof(string))
        || type.IsArray
        || (type.IsGenericType &&
            type.GetGenericTypeDefinition() != typeof(Nullable<>));
    
    parameters.GetType().GetProperties()
        .Where(p => p.CanRead && !IsNotValidType(p.PropertyType))
        .ForEachEnumerable(property =>
        {
            var v = property.GetValue(parameters);
            if (v != null) useparam.Add(property.Name, v);
        });
    
    return useparam;
}

Esto evita errores comunes como intentar pasar objetos complejos directamente a Dapper.

Ejemplos de uso

Operaciones CRUD básicas

// Obtener todos los registros
var productos = await _productoRepo.Obtener();

// Obtener por ID
var producto = await _productoRepo.ObtenerById(new { Id = 123 });

// Guardar (insertar o actualizar)
var result = await _productoRepo.Guardar(productoEntity);

// Eliminar
var result = await _productoRepo.Eliminar(new { Id = 123 });

Trabajar con DTOs

// Obtener como DTO
var productosDto = await _productoRepo.ObtenerDto<ProductoDto>();

// Obtener DTO por ID
var productoDto = await _productoRepo.ObtenerDtoById<ProductoDto>(new { Id = 123 });

Trabajar con procedimientos almacenados específicos

// Especificar nombre de procedimiento almacenado
var resultado = await _productoRepo.Obtener(
    new { Activo = true },
    Sp: "ObtenerProductosActivos"
);

Mapeo de múltiples entidades

// Mapeo personalizado
var productosMapeados = await _productoRepo.MapObtener<CategoriaEntity>(
    (producto, categoria) => {
        producto.NombreCategoria = categoria.Nombre;
        return producto;
    },
    "CategoriaId",
    new { Activo = true }
);

Dependencias

• Nosabit.Core: Proporciona tipos como DBEntity y extensiones de utilidad
• Nosabit.DataAccess.SqlServer.Abstractions: Define la interfaz ISqlDataAccess utilizada por el repositorio
• Nosabit.DataAccess.SqlServer: Implementación concreta de ISqlDataAccess
• Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern.Abstractions: Define la interfaz IRepo<TEntity>
• Dapper: ORM de alto rendimiento para acceso a datos

Requisitos

• .NET 6.0 o superior
• SQL Server 2016 o superior

Licencia

Este proyecto está licenciado bajo la Licencia MIT.