NestXRepository.Core 2.3.3

NestXRepository.Core

Librería de acceso a datos de alto rendimiento para .NET 10+ que combina la velocidad de Dapper con el poder de Entity Framework Core, optimizada para PostgreSQL con arquitectura multi-base de datos.

¿Qué problema resuelve?

Escoge la herramienta correcta para cada escenario sin duplicar código:

• Queries de lectura masivas (>1000 registros) → Dapper (3x más rápido)
• CRUD con relaciones complejas → Entity Framework
• Inserciones masivas (>100 registros) → BulkInsert (25x más rápido)
• Filtros dinámicos complejos → EFQueryable con LINQ
• Reports con múltiples JOINs → DPQueryJoin

Todo en una sola interfaz. Cero configuración duplicada.

Instalación

dotnet add package NestXRepository.Core

Requisitos:

• .NET 10.0+
• PostgreSQL 12+ (SQL Server y MySQL preparados para futuras versiones)
• Entity Framework Core 10.0+
• Dapper 2.1+
• Npgsql 10.0+

Quick Start

1. Configuración (Una línea)

// Program.cs
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");

builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseNpgsql(connectionString));

//  Registra automáticamente IGenericRepository<T> para todas tus entidades
builder.Services.AddGenericRepository<MyDbContext>(connectionString);

2. Uso en tus servicios

public class ProductService
{
    private readonly IGenericRepository<Product> _repo;

    public ProductService(IGenericRepository<Product> repo) => _repo = repo;

    // Lectura rápida con Dapper
    public async Task<List<Product>> GetActiveProducts()
        => await _repo.DPGetAll(p => p.IsActive, top: 100);

    // CRUD completo con EF
    public async Task<Guid> CreateProduct(Product product)
        => await _repo.EFAdd<Guid>(product);

    // Queries dinámicas complejas
    public async Task<List<Product>> SearchProducts(string? name, bool? inStock)
    {
        var query = _repo.EFQueryable()
            .Where(p => p.IsActive);

        if (!string.IsNullOrEmpty(name))
            query = query.Where(p => p.Name.Contains(name));

        if (inStock.HasValue)
            query = query.Where(p => p.Stock > 0);

        return await query.Include(p => p.Category).ToListAsync();
    }
}

Características Principales

Documentación

• Referencia Técnica Completa - Referencia de todos los métodos con ejemplos
• Arquitectura y Diseño - Patrones de diseño, decisiones técnicas y optimizaciones

Casos de Uso

Lectura de Alto Rendimiento

// 10,000 registros en ~180ms (vs 420ms con EF puro)
var products = await _repo.DPGetAll(p => p.IsActive, top: 10000);

Inserciones Masivas

// 10,000 inserts en ~350ms (vs 8,500ms con EF tradicional)
var insertedIds = _repo.BulkInsert(products, includeForeignKeys: false);

Queries Dinámicas Complejas

var query = _repo.EFQueryable()
    .Where(u => u.IsActive)
    .Where(u => u.CreatedAt >= DateTime.Now.AddMonths(-1))
    .Include(u => u.Orders)
        .ThenInclude(o => o.OrderDetails)
    .OrderByDescending(u => u.CreatedAt)
    .Select(u => new UserSummary 
    { 
        Name = u.Name, 
        OrderCount = u.Orders.Count 
    });

var result = await query.ToListAsync();

JOINs Multi-Tabla con Dapper

var sql = @"
    SELECT u.*, o.*, p.* 
    FROM users u
    INNER JOIN orders o ON u.id = o.userid
    INNER JOIN products p ON o.productid = p.id
    WHERE u.isactive = true";

var result = await _repo.DPQueryJoin<User, Order, Product, UserOrderDto>(
    sql,
    (user, order, product) => new UserOrderDto
    {
        UserName = user.Name,
        OrderId = order.Id,
        ProductName = product.Name
    },
    splitOn: "id,id"
);

Arquitectura

GenericRepository.Core/
├── Dialects/                          # Abstracción multi-base de datos
│   ├── ISqlDialect.cs
│   ├── PostgreSqlDialect.cs           # Activo
│   ├── SqlServerDialect.cs            # Preparado
│   └── MySqlDialect.cs                # Preparado
├── Interfaces/
│   └── IGenericRepository.cs
├── Repositories/                      # Clase parcial dividida en 11 archivos
│   ├── GenericRepository.cs           # Constructores y configuración
│   ├── GenericRepository.BulkOps.cs   # PostgreSQL COPY
│   ├── GenericRepository.DapperQueries.cs
│   ├── GenericRepository.Delete.cs
│   ├── GenericRepository.EFQueries.cs
│   ├── GenericRepository.ExpressionConverter.cs
│   ├── GenericRepository.Helpers.cs
│   ├── GenericRepository.Insert.cs
│   ├── GenericRepository.Internals.cs
│   ├── GenericRepository.SoftDelete.cs
│   ├── GenericRepository.Update.cs
│   ├── ConnectionProvider.cs
│   └── ServiceCollectionExtensions.cs
├── unit/
│   ├── IDapperUnitOfWork.cs
│   └── DapperUnitOfWork.cs
└── docs/                              # Documentación técnica

Testing

# Todos los tests
dotnet test

# Por categoría
dotnet test --filter "FullyQualifiedName~Infrastructure"
dotnet test --filter "FullyQualifiedName~EF"
dotnet test --filter "FullyQualifiedName~ForeignKey"
dotnet test --filter "FullyQualifiedName~Performance"
dotnet test --filter "FullyQualifiedName~Transactions"
dotnet test --filter "FullyQualifiedName~Security"

Benchmarks

Mediciones en PostgreSQL con 100,000 registros:

Contribuciones

Este proyecto es propietario de NestX Software. Para reportar bugs o sugerir mejoras, contacta al equipo de desarrollo.

Licencia

Propietaria - NestX Software © 2026

Recursos Adicionales

• Comparativa Dapper vs EF - Guía de cuándo usar cada uno
• Patrones de Optimización - Caching, paralelización, bulk operations