LibraryDBApi 1.1.1

LibraryDBApi - API Innovadora para Procedimientos Almacenados y Operaciones Masivas

Una biblioteca .NET 9.0 revolucionaria que automatiza llamadas a procedimientos almacenados y operaciones masivas en bases de datos SQL Server con mapeo automático de tipos y optimizaciones avanzadas.

🚀 Características Principales

✨ Procedimientos Almacenados Inteligentes

• Mapeo automático: Convierte automáticamente propiedades de modelos C# en parámetros de procedimientos almacenados
• Filtrado inteligente: Solo usa propiedades compatibles con los parámetros del procedimiento
• Resultados tipados (IEnumerable): Mapea automáticamente los resultados a colecciones IEnumerable<T> de modelos C# con coincidencia flexible
• API simplificada: Especifica solo el tipo de elemento (T), el resultado es siempre una colección (IEnumerable<T>)
• Parámetros unificados: Modelo único StoredProcedureParameters que incluye todos los parámetros necesarios

🔥 Operaciones Masivas Ultra-Rápidas

• Inserción masiva: SqlBulkCopy para máxima velocidad
• Actualización masiva: Table-Valued Parameters para eficiencia
• Eliminación masiva: Operaciones optimizadas en lote
• Upsert masivo: Inserción/actualización inteligente
• Operaciones en lote: Transacciones automáticas
• Sincronización masiva: Sincronización entre tablas

🎯 Mapeo Avanzado

• Coincidencia flexible: Ignora mayúsculas/minúsculas y caracteres especiales
• Atributos personalizados: Control total sobre el mapeo
• Conversiones automáticas: Manejo inteligente de tipos de datos
• Manejo de errores robusto: Valores por defecto y recuperación automática

📦 Instalación

Para instalar la librería en tu proyecto .NET:

dotnet add package LibraryDBApi
# O si necesitas una versión específica:
# dotnet add package LibraryDBApi --version <version>

🎯 Uso Rápido

Procedimientos Almacenados con Parámetros Unificados

// Configuración (asumiendo que tu DataService ya obtiene la cadena de conexión)
var dataService = new DataService(configuration); // Instancia de tu servicio

// 1. Procedimiento simple sin parámetros
var parameters = new StoredProcedureParameters
{
    ConnectionString = "Server=myServer;Database=myDB;Trusted_Connection=true;",
    ProcedureName = "ObtenerTodosLosClientes"
};
var resultadoClientes = await dataService.EjecutarProcedimientoAsync<Cliente>(parameters);

// 2. Procedimiento con paginación
var parametersPaginados = new StoredProcedureParameters
{
    ConnectionString = "Server=myServer;Database=myDB;Trusted_Connection=true;",
    ProcedureName = "ObtenerClientes",
    ModelPaginacion = new ModelPaginacion
    {
        PageNumber = 1,
        PageSize = 10
    }
};
var clientesPaginados = await dataService.EjecutarProcedimientoAsync<Cliente>(parametersPaginados);

// 3. Procedimiento con modelo de parámetros
var parametrosBusqueda = new { Nombre = "Juan", Edad = 25 };
var parametersConModelo = new StoredProcedureParameters
{
    ConnectionString = "Server=myServer;Database=myDB;Trusted_Connection=true;",
    ProcedureName = "BuscarClientes",
    Model = parametrosBusqueda,
    ModelPaginacion = new ModelPaginacion
    {
        PageNumber = 1,
        PageSize = 20
    }
};
var clientesBuscados = await dataService.EjecutarProcedimientoAsync<Cliente>(parametersConModelo);

// 4. Procedimiento con filtro adicional
var parametersConFiltro = new StoredProcedureParameters
{
    ConnectionString = "Server=myServer;Database=myDB;Trusted_Connection=true;",
    ProcedureName = "BuscarClientes",
    Model = parametrosBusqueda,
    ModelPaginacion = new ModelPaginacion
    {
        PageNumber = 1,
        PageSize = 20,
        Filter = "activos" // Filtro adicional como string
    }
};
var clientesFiltrados = await dataService.EjecutarProcedimientoAsync<Cliente>(parametersConFiltro);

// 5. Usando constructor con parámetros
var modelPaginacion = new ModelPaginacion(
    pageNumber: 1,
    pageSize: 20,
    filter: "activos"
);

var parametersConstructor = new StoredProcedureParameters(
    connectionString: "Server=myServer;Database=myDB;Trusted_Connection=true;",
    procedureName: "BuscarClientes",
    model: parametrosBusqueda,
    modelPaginacion: modelPaginacion
);
var resultadoConstructor = await dataService.EjecutarProcedimientoAsync<Cliente>(parametersConstructor);

// 6. Solo con filtro (sin paginación)
var parametersSoloFiltro = new StoredProcedureParameters
{
    ConnectionString = "Server=myServer;Database=myDB;Trusted_Connection=true;",
    ProcedureName = "BuscarClientes",
    ModelPaginacion = new ModelPaginacion
    {
        Filter = "activos"
    }
};
var clientesFiltradosSolo = await dataService.EjecutarProcedimientoAsync<Cliente>(parametersSoloFiltro);

Operaciones Masivas

// Inserción masiva ultra-rápida
var clientes = new List<Cliente> { /* ... */ };
var resultadoInsercion = await dataService.InsertarDatosMasivamenteAsync(
    connectionString, // Asumiendo que connectionString es accesible o se pasa
    "Clientes", 
    clientes
);

// Actualización masiva eficiente
var resultadoActualizacion = await dataService.ActualizarUsuariosMasivamenteAsync(
    clientes // Ahora toma List<Usuario> directamente
);

// Sincronización entre tablas
var resultadoSincronizacion = await dataService.SincronizarDatosMasivamenteAsync(
    connectionString, 
    "ClientesTemp", 
    "Clientes", 
    "Id"
);

🔧 Modelos de Ejemplo

// Modelo para parámetros
public class BusquedaCliente
{
    public string Nombre { get; set; }
    public int? Edad { get; set; }
    public string Ciudad { get; set; }
}

// Modelo para resultados
public class Cliente
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public string Email { get; set; }
    public DateTime FechaRegistro { get; set; }
}

// Modelo de Usuario (ejemplo de la conversación)
public class Usuario
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public string Rol { get; set; }
    public bool Activo { get; set; }
    public DateTime FechaCreacion { get; set; }
}

🎨 Atributos de Mapeo Avanzado

public class Cliente
{
    [ColumnMapping("ID_CLIENTE")]  // Mapeo explícito
    public int Id { get; set; }
    
    [ColumnMapping("NOMBRE_COMPLETO")]
    public string Nombre { get; set; }
    
    [IgnoreMapping]  // Ignorar propiedad
    public string PropiedadInterna { get; set; }
    
    // [CustomConverter(typeof(EmailConverter))]  // Conversión personalizada (descomentar si existe)
    public string Email { get; set; }
}

⚡ Operaciones Masivas Avanzadas

// Opciones personalizadas para inserción
var opcionesInsert = new BulkInsertOptions
{
    BatchSize = 1000,
    Timeout = 300,
    // EnableStreaming = true // Comentar si no existe esta propiedad
};

var resultadoOps = await dataService.InsertarDatosMasivamenteAsync(
    connectionString, 
    "Clientes", 
    clientes, 
    opcionesInsert
);

// Operaciones en lote con transacción
var operacionesLote = new List<BatchOperation>
{
    new BatchOperation { Type = BatchOperationType.Insert, TableName = "Clientes", Data = clientes },
    new BatchOperation { Type = BatchOperationType.Update, TableName = "Productos", Data = productos }
};

var resultadoLote = await dataService.EjecutarOperacionesEnLoteAsync(
    connectionString, 
    operacionesLote
);

🛠️ Utilidades Avanzadas

// Optimización de rendimiento (ejemplo hipotético, verificar si estos métodos existen)
// await BulkOperationUtilities.OptimizarTablaAsync(connectionString, "Clientes");

// Análisis de rendimiento
// var estadisticas = await BulkOperationUtilities.AnalizarRendimientoAsync(
//     connectionString, 
//     "Clientes"
// );

// Recomendaciones de optimización
// var recomendaciones = await BulkOperationUtilities.ObtenerRecomendacionesAsync(
//     connectionString, 
//     "Clientes"
// );

🔍 Manejo de Resultados

// Ahora el método EjecutarProcedimientoAsync<T> siempre retorna StoredProcedureResult<IEnumerable<T>>
var parameters = new StoredProcedureParameters
{
    ConnectionString = "Server=myServer;Database=myDB;Trusted_Connection=true;",
    ProcedureName = "BuscarClientes",
    Model = parametrosBusqueda
};

var resultadoConsulta = await dataService.EjecutarProcedimientoAsync<Cliente>(parameters);

if (resultadoConsulta.IsSuccess)
{
    var clientes = resultadoConsulta.Data; // clientes es de tipo IEnumerable<Cliente>
    Console.WriteLine($"Se encontraron {clientes.Count()} clientes");
    
    // Información de paginación si está disponible
    if (resultadoConsulta.TotalRecords.HasValue)
    {
        Console.WriteLine($"Total de registros: {resultadoConsulta.TotalRecords}");
        Console.WriteLine($"Página actual: {resultadoConsulta.PageNumber}");
        Console.WriteLine($"Tamaño de página: {resultadoConsulta.PageSize}");
    }
    
    // Puedes iterar sobre 'clientes' o usar métodos LINQ como .ToList(), .FirstOrDefault(), etc.
    var primerCliente = clientes.FirstOrDefault();
}
else
{
    Console.WriteLine($"Error: {resultadoConsulta.Message}");
}

🚀 Ventajas Clave

1. Simplicidad: API intuitiva que infere automáticamente los tipos y siempre retorna colecciones.
2. Rendimiento: Operaciones masivas optimizadas para máxima velocidad.
3. Flexibilidad: Mapeo automático con opciones de personalización.
4. Robustez: Manejo de errores avanzado y recuperación automática.
5. Unificación: Un solo modelo de parámetros para todos los escenarios.

📊 Comparación de Rendimiento

📦 Publicación del Paquete NuGet

Sigue estos pasos para crear y publicar el paquete NuGet de LibraryDBApi:

1. Crear el paquete .nupkg

Primero, asegúrate de que tu proyecto tenga la versión correcta (por ejemplo, 1.0.1 en LibraryDBApi.csproj si aún no lo has hecho, aunque la creación del paquete inferirá la versión del csproj). Luego, ejecuta el siguiente comando en la raíz de tu proyecto LibraryDBApi:

dotnet pack --configuration Release /p:Version=1.0.1

Este comando compilará tu proyecto en modo Release y generará el archivo .nupkg (por ejemplo, LibraryDBApi.1.0.1.nupkg) en la carpeta bin/Release/ o bin/Release/net9.0/.

2. Publicar el paquete en NuGet.org

Antes de publicar, asegúrate de tener una cuenta en NuGet.org y haber generado una clave de API.

dotnet nuget push "C:\Users\bedom\OneDrive\Documentos\Daniel M\Proyectos\LibraryDBApi\LibraryDBApi.1.1.1.nupkg" --source "https://nuget.pkg.github.com/DANII3L/index.json" --api-key "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" --skip-duplicate

Reemplaza bin/Release/LibraryDBApi.1.0.1.nupkg con la ruta real a tu archivo .nupkg (la ruta exacta puede variar ligeramente dependiendo de la estructura de tu proyecto y la versión de .NET, podría ser bin/Release/net9.0/LibraryDBApi.1.0.1.nupkg).

Reemplaza TU_API_KEY_AQUI con tu clave de API generada en NuGet.org.

Una vez que el comando se complete exitosamente, tu paquete estará disponible públicamente en NuGet.org para que otros desarrolladores puedan instalarlo.