Ícono de mensaje
Saltar al pie de página
  1. IronXL
  2. Blog de IronXL
  3. Usando IronXL
  4. Generar Excel en C#
USANDO IRONXL

Cómo generar un archivo de Excel en C# usando IronXL

Jordi Bardia
Jordi Bardia
Publicado:

Generar archivos de hojas de cálculo de Excel programáticamente en C# o Visual Basic tradicionalmente requería la instalación de Microsoft Office o un complejo COM Interop. IronXL cambia esto completamente, ofreciendo una API simple que crea archivos de aplicaciones de Excel sin ninguna dependencia de Office. Este tutorial te guía para construir archivos de Excel en C# usando IronXL, desde la creación básica de hojas de cálculo hasta el formato avanzado y la integración de bases de datos. Ya sea que esté creando informes, exportando datos (archivos XLS o archivos XLSX), o automatizando la generación de hojas de cálculo, aprenderá las técnicas esenciales para trabajar con Excel en aplicaciones .NET.

Generar Excel en C#: Imagen 1 - IronXL

¿Por qué generar archivos de hojas de cálculo de Excel sin Microsoft Office?

Desarrollar funciones de generación de Excel sin las dependencias de Office resuelve problemas críticos de implementación. Los entornos de servidor rara vez tienen Microsoft Office instalado debido a los costos de licencias y la sobrecarga de recursos. Cada instalación de Office requiere un espacio en disco y memoria significativos, lo que lo hace poco práctico para implementaciones en la nube o aplicaciones contenedorizadas.

IronXL elimina estas limitaciones funcionando de manera independiente. Tu generación de archivos de Excel en C# se ejecuta en Windows, Linux, macOS, contenedores de Docker, o Azure App Services sin modificaciones. Esta compatibilidad multiplataforma significa que escribes una vez y despliegas en cualquier lugar, ya sea apuntando a aplicaciones .NET Framework, .NET Core, o .NET 8/9.

Generar Excel en C#: Imagen 2 - Multiplataforma

El rendimiento mejora drásticamente sin la sobrecarga de la interoperabilidad COM. La automatización tradicional de Office crea instancias de proceso separadas para cada operación, consumiendo memoria y recursos de CPU. IronXL procesa todo en memoria dentro del espacio de proceso de tu aplicación, lo que resulta en una ejecución más rápida y un menor consumo de recursos cuando generas archivos de Excel de manera programática.

La implementación se vuelve sencilla ya que IronXL se entrega como un único paquete NuGet. Sin entradas de registro, sin registros COM, y sin paquetes de servicio de Office para mantener. Tus pipelines de integración continua funcionan sin problemas, y los contenedores de Docker se mantienen ligeros. Este enfoque simplificado ha hecho de IronXL una elección popular, según se discute en varios foros de desarrolladores donde los profesionales comparten sus experiencias con la automatización de Excel.

Algunos desarrolladores todavía exploran la Herramienta de Productividad Open XML de Microsoft para trabajar directamente con estructuras de archivos Office Open XML. Aún así, ese enfoque requiere más esfuerzo manual y un conocimiento detallado del esquema XML y la instalación del SDK de Open XML. IronXL abstrae estas complejidades de trabajar con varios archivos XML diferentes, dándote un camino mucho más rápido para trabajar con Excel programáticamente.

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 3 - Características

¿Cómo instalar IronXL en su proyecto C#?

La instalación de IronXL toma solo unos momentos a través del Administrador de Paquetes NuGet en el Explorador de Soluciones. En Visual Studio, haz clic derecho en tu proyecto y selecciona "Administrar Paquetes NuGet". Busca "IronXL.Excel" y haz clic en Instalar. El paquete incluye automáticamente todas las dependencias necesarias para generar archivos de Excel en C#.

Alternativamente, usa la Consola del Administrador de Paquetes:

Install-Package IronXL.Excel

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 4 - Instalación

Para usuarios de .NET CLI que trabajan con proyectos modernos de C#:

dotnet add package IronXL.Excel
dotnet add package IronXL.Excel
SHELL

Verifica la instalación con esta simple prueba para crear un archivo Excel de manera programática:

using IronXL;
// new Excel workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");
using IronXL;
// new Excel workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este código crea un objeto de libro de trabajo en memoria. Si se ejecuta sin errores, IronXL está listo para usarse. La biblioteca es compatible con todas las versiones modernas de .NET, asegurando la compatibilidad con tus proyectos existentes. Para una guía de instalación detallada y solución de problemas, consulta la documentación oficial. ¿Listo para comenzar? Descarga IronXL ahora y comienza a generar archivos de Excel en minutos.

Resultado

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 5 - Salida de Consola

¿Cómo crear tu primer archivo de Excel?

Crear archivos de Excel con IronXL comienza con la clase WorkBook, tu puerta de entrada a todas las operaciones de Excel. La biblioteca es compatible tanto con formatos modernos XLSX como con formatos heredados XLS, dándote flexibilidad para diferentes requisitos cuando generas archivos de Excel en C#.

using IronXL;
// Create a new workbook (XLSX format by default)
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Title = "Monthly Sales Report";
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Comments = "Generated using IronXL";
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("January Sales");
// Add some basic data
worksheet["A1"].Value = "Date";
worksheet["B1"].Value = "Product";
worksheet["C1"].Value = "Quantity";
worksheet["D1"].Value = "Revenue";
// Add data rows
worksheet["A2"].Value = new DateTime(2024, 1, 15);
worksheet["B2"].Value = "Widget Pro";
worksheet["C2"].Value = 100;
worksheet["D2"].Value = 2500.00;
// Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx");
using IronXL;
// Create a new workbook (XLSX format by default)
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Title = "Monthly Sales Report";
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Comments = "Generated using IronXL";
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("January Sales");
// Add some basic data
worksheet["A1"].Value = "Date";
worksheet["B1"].Value = "Product";
worksheet["C1"].Value = "Quantity";
worksheet["D1"].Value = "Revenue";
// Add data rows
worksheet["A2"].Value = new DateTime(2024, 1, 15);
worksheet["B2"].Value = "Widget Pro";
worksheet["C2"].Value = 100;
worksheet["D2"].Value = 2500.00;
// Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este código demuestra varios conceptos clave para la generación de archivos de Excel. El método WorkBook.Create() inicializa un nuevo archivo de Excel en memoria. Especificas el formato utilizando el enum ExcelFileFormat: elige XLSX para la compatibilidad con Excel moderno o XLS para el soporte de legado. La propiedad Metadata te permite incrustar información del documento que aparece en las propiedades del archivo de Excel, cumpliendo con los estándares de propiedades de documentos de Microsoft.

El método CreateWorkSheet() añade una nueva hoja con el nombre especificado. La notación de celda familiar de Excel (A1, B1, etc.) hace que establecer valores sea intuitivo. IronXL maneja automáticamente la conversión de tipos de datos, reconociendo fechas, números y texto sin casting explícito. El método SaveAs() escribe el archivo de Excel completo en el disco. Para más operaciones de hojas de cálculo, explora el tutorial de administración de hojas de trabajo.

Resultado

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 6 - Salida Básica de Excel

¿Cómo escribir datos en celdas de Excel?

IronXL proporciona múltiples enfoques para poblar celdas de Excel, desde asignaciones de celdas individuales hasta operaciones en rangos amplios. Entender estos métodos te ayuda a elegir el enfoque más eficiente para tu escenario de datos.

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Individual cell assignment
worksheet["A1"].Value = "Employee Name";
worksheet["A2"].Value = "John Smith";
worksheet["A3"].Value = "Jane Doe";
// Range assignment for multiple cells
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based population
string[] headers = { "ID", "Name", "Email", "Phone" };
for (int i = 0; i < headers.Length; i++)
{
    worksheet.SetCellValue(0, i, headers[i]);
}
// Working with different data types
worksheet["E1"].Value = "Salary";
worksheet["E2"].Value = 75000.50m;  // Decimal for currency
worksheet["E3"].Value = 82000.75m;
worksheet["F1"].Value = "Start Date";
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G1"].Value = "Full Time";
worksheet["G2"].Value = true;  // Boolean
worksheet["G3"].Value = true;
workbook.SaveAs("FirstExcelFile.xlsx");
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Individual cell assignment
worksheet["A1"].Value = "Employee Name";
worksheet["A2"].Value = "John Smith";
worksheet["A3"].Value = "Jane Doe";
// Range assignment for multiple cells
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based population
string[] headers = { "ID", "Name", "Email", "Phone" };
for (int i = 0; i < headers.Length; i++)
{
    worksheet.SetCellValue(0, i, headers[i]);
}
// Working with different data types
worksheet["E1"].Value = "Salary";
worksheet["E2"].Value = 75000.50m;  // Decimal for currency
worksheet["E3"].Value = 82000.75m;
worksheet["F1"].Value = "Start Date";
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G1"].Value = "Full Time";
worksheet["G2"].Value = true;  // Boolean
worksheet["G3"].Value = true;
workbook.SaveAs("FirstExcelFile.xlsx");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

El código muestra la flexible dirección de celdas de IronXL. La notación de cadena ("A1") resulta natural para los usuarios de Excel, mientras que los índices numéricos ofrecen control programático para bucles y generación dinámica. Las asignaciones de rango ("B1:B3") establecen múltiples celdas al mismo valor de manera eficiente, perfectas para inicializar columnas o aplicar valores predeterminados.

IronXL maneja inteligentemente diferentes tipos de datos. Los decimales mantienen precisión para datos financieros, los objetos DateTime se formatean correctamente como fechas de Excel, y los booleanos aparecen como TRUE/FALSE. Esta conversión automática elimina el código de formato manual y asegura la integridad de los datos.

Resultado

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 7 - Salida de Excel

Para conjuntos de datos más grandes, considera este patrón:

// Populate from a data source
var employees = GetEmployeeData(); // Your data source
for (int row = 0; row < employees.Count; row++)
{
    worksheet[$"A{row + 2}"].Value = employees[row].Id;
    worksheet[$"B{row + 2}"].Value = employees[row].Name;
    worksheet[$"C{row + 2}"].Value = employees[row].Department;
    worksheet[$"D{row + 2}"].Value = employees[row].Salary;
}
// Populate from a data source
var employees = GetEmployeeData(); // Your data source
for (int row = 0; row < employees.Count; row++)
{
    worksheet[$"A{row + 2}"].Value = employees[row].Id;
    worksheet[$"B{row + 2}"].Value = employees[row].Name;
    worksheet[$"C{row + 2}"].Value = employees[row].Department;
    worksheet[$"D{row + 2}"].Value = employees[row].Salary;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este enfoque itera a través de tu colección de datos, mapeando cada propiedad a su columna correspondiente. La interpolación de cadenas ($"A{row + 2}") genera dinámicamente direcciones de celdas, comenzando desde la fila 2 para preservar los encabezados.

¿Cómo aplicar formato profesional?

Los archivos Excel profesionales requieren más que datos en bruto. La API de estilo de IronXL transforma hojas de cálculo planas en documentos comerciales pulidos a través de formateo, colores y jerarquía visual cuando genera archivos de Excel en C#.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Header formatting
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
// Column width adjustment
worksheet.AutoSizeColumn(0); // Auto-fit column A
worksheet.GetColumn(1).Width = 20; // Set column B to 20 characters
// Number formatting
var salaryColumn = worksheet["E2:E3"];
salaryColumn.FormatString = "$#,##0.00";
// Date formatting  
var dateColumn = worksheet["F2:F3"];
dateColumn.FormatString = "MM/dd/yyyy";
// Cell borders
var dataRange = worksheet["A1:G3"];
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin;
// To set border color, use:
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
dataRange.Style.LeftBorder.Color = "#000000";
dataRange.Style.RightBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability
for (int row = 2; row <= 3; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Header formatting
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
// Column width adjustment
worksheet.AutoSizeColumn(0); // Auto-fit column A
worksheet.GetColumn(1).Width = 20; // Set column B to 20 characters
// Number formatting
var salaryColumn = worksheet["E2:E3"];
salaryColumn.FormatString = "$#,##0.00";
// Date formatting  
var dateColumn = worksheet["F2:F3"];
dateColumn.FormatString = "MM/dd/yyyy";
// Cell borders
var dataRange = worksheet["A1:G3"];
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin;
// To set border color, use:
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
dataRange.Style.LeftBorder.Color = "#000000";
dataRange.Style.RightBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability
for (int row = 2; row <= 3; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este código de formato crea una apariencia profesional que cumple con los estándares empresariales. Encabezados en negrita con colores de fondo establecen una jerarquía visual. El método SetBackgroundColor() acepta códigos de color hexadecimales, dando control preciso sobre tu esquema de color. Las propiedades de fuente incluyen tamaño, color, negrita, cursiva, y opciones de subrayado, todos son esenciales para crear archivos de Excel que coincidan con las pautas de marca corporativa.

Ajustes de ancho de columna previenen la truncación de texto. AutoSizeColumn() ajusta automáticamente el contenido, mientras SetColumnWidth() proporciona un control exacto. El formato de números usa los códigos de formato de Excel. Por ejemplo, "$#,##0.00" muestra moneda con separadores de mil y dos decimales. El formato de fecha sigue patrones similares, usando cadenas de formato de fecha estándar de Excel como se documenta en las especificaciones de Excel de Microsoft.

Los bordes definen límites de datos, mejorando la legibilidad. El enum BorderType ofrece varios estilos: delgado, medio, grueso, punteado, y rayado. Las opciones de alineación centran los encabezados y alinean a la derecha los números, siguiendo las convenciones de las hojas de cálculo. Los colores de filas alternas, a menudo referidos como "filas con bandas," ayudan a los lectores a seguir la información a través de conjuntos de datos amplios. Aprende más sobre formateo avanzado para crear datos de Excel formateados en nuestra guía de estilos de celda.

Resultado

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 8 - Salida de Excel Formateado

¿Cómo utilizar fórmulas de Excel mediante programación?

Las fórmulas de Excel dan vida a las hojas de cálculo con cálculos automáticos. IronXL admite la creación y evaluación de fórmulas, habilitando hojas de cálculo dinámicas que se actualizan automáticamente.

var workbook = WorkBook.Create();
// Create a budget worksheet
WorkSheet budget = workbook.CreateWorkSheet("Q1 Budget");
// Headers
budget["A1"].Value = "Category";
budget["B1"].Value = "January";
budget["C1"].Value = "February";
budget["D1"].Value = "March";
budget["E1"].Value = "Q1 Total";
// Budget categories and values
string[] categories = { "Salaries", "Marketing", "Operations", "Equipment", "Training" };
decimal[,] monthlyBudgets = {
    { 50000, 52000, 51000 },
    { 15000, 18000, 20000 },
    { 8000, 8500, 9000 },
    { 12000, 5000, 7000 },
    { 3000, 3500, 4000 }
};
// Populate data
for (int i = 0; i < categories.Length; i++)
{
    budget[$"A{i + 2}"].Value = categories[i];
    budget[$"B{i + 2}"].Value = monthlyBudgets[i, 0];
    budget[$"C{i + 2}"].Value = monthlyBudgets[i, 1];
    budget[$"D{i + 2}"].Value = monthlyBudgets[i, 2];
    // Row total formula
    budget[$"E{i + 2}"].Formula = $"=SUM(B{i + 2}:D{i + 2})";
}
// Monthly totals row
budget["A7"].Value = "Monthly Total";
budget["B7"].Formula = "=SUM(B2:B6)";
budget["C7"].Formula = "=SUM(C2:C6)";
budget["D7"].Formula = "=SUM(D2:D6)";
budget["E7"].Formula = "=SUM(E2:E6)";
// Calculate percentages
budget["A9"].Value = "Marketing %";
budget["B9"].Formula = "=B3/B7*100";
budget["C9"].Formula = "=C3/C7*100";
budget["D9"].Formula = "=D3/D7*100";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");
var workbook = WorkBook.Create();
// Create a budget worksheet
WorkSheet budget = workbook.CreateWorkSheet("Q1 Budget");
// Headers
budget["A1"].Value = "Category";
budget["B1"].Value = "January";
budget["C1"].Value = "February";
budget["D1"].Value = "March";
budget["E1"].Value = "Q1 Total";
// Budget categories and values
string[] categories = { "Salaries", "Marketing", "Operations", "Equipment", "Training" };
decimal[,] monthlyBudgets = {
    { 50000, 52000, 51000 },
    { 15000, 18000, 20000 },
    { 8000, 8500, 9000 },
    { 12000, 5000, 7000 },
    { 3000, 3500, 4000 }
};
// Populate data
for (int i = 0; i < categories.Length; i++)
{
    budget[$"A{i + 2}"].Value = categories[i];
    budget[$"B{i + 2}"].Value = monthlyBudgets[i, 0];
    budget[$"C{i + 2}"].Value = monthlyBudgets[i, 1];
    budget[$"D{i + 2}"].Value = monthlyBudgets[i, 2];
    // Row total formula
    budget[$"E{i + 2}"].Formula = $"=SUM(B{i + 2}:D{i + 2})";
}
// Monthly totals row
budget["A7"].Value = "Monthly Total";
budget["B7"].Formula = "=SUM(B2:B6)";
budget["C7"].Formula = "=SUM(C2:C6)";
budget["D7"].Formula = "=SUM(D2:D6)";
budget["E7"].Formula = "=SUM(E2:E6)";
// Calculate percentages
budget["A9"].Value = "Marketing %";
budget["B9"].Formula = "=B3/B7*100";
budget["C9"].Formula = "=C3/C7*100";
budget["D9"].Formula = "=D3/D7*100";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este ejemplo de presupuesto ilustra la aplicación práctica de fórmulas. La propiedad Formula acepta la sintaxis estándar de fórmulas de Excel, comenzando con un signo igual. IronXL admite funciones comunes: SUM, AVERAGE, COUNT, MAX, MIN, y muchas más. Las referencias de celdas en las fórmulas funcionan exactamente como en Excel, incluyendo referencias relativas y absolutas.

Las fórmulas de suma de filas (=SUM(B{i + 2}:D{i + 2})) calculan los totales trimestrales para cada categoría. La interpolación de cadenas genera dinámicamente las referencias de celdas correctas para cada fila. Los totales mensuales suman columnas enteras, mientras que los cálculos de porcentajes dividen celdas específicas por totales.

El método EvaluateAll() procesa todas las fórmulas, actualizando valores calculados en todo el libro de trabajo. Esto asegura que las fórmulas muestren resultados cuando se abran en Excel. Sin evaluación, Excel mostraría las fórmulas hasta que el usuario desencadene un recálculo.

Resultado

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 9 - Salida de Excel usando Fórmulas

¿Cómo exportar datos de bases de datos a Excel?

Las aplicaciones del mundo real a menudo exportan datos de bases de datos a Excel para informes y análisis. IronXL simplifica este proceso con soporte incorporado para DataTable, eliminando la necesidad de asignación manual de campos al generar archivos de Excel desde aplicaciones C#.

using System.Data;
using System.Data.SqlClient;
// Simulate database retrieval (replace with your actual database code)
DataTable GetSalesData()
{
    DataTable dt = new DataTable("Sales");
    dt.Columns.Add("OrderID", typeof(int));
    dt.Columns.Add("CustomerName", typeof(string));
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Quantity", typeof(int));
    dt.Columns.Add("UnitPrice", typeof(decimal));
    dt.Columns.Add("OrderDate", typeof(DateTime));
    // Sample data (normally from database)
    dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99m, DateTime.Now.AddDays(-5));
    dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99m, DateTime.Now.AddDays(-4));
    dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99m, DateTime.Now.AddDays(-3));
    dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99m, DateTime.Now.AddDays(-2));
    dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99m, DateTime.Now.AddDays(-1));
    return dt;
}
// Export to Excel
WorkBook reportWorkbook = WorkBook.Create();
WorkSheet reportSheet = reportWorkbook.CreateWorkSheet("Sales Report");
// Get data from database
DataTable salesData = GetSalesData();
// Method 1: Manual mapping with formatting
reportSheet["A1"].Value = "Order Report - " + DateTime.Now.ToString("MMMM yyyy");
reportSheet.Merge("A1:F1");
reportSheet["A1"].Style.Font.Bold = true;
reportSheet["A1"].Style.Font.Height = 14;
// Headers
int headerRow = 3;
for (int col = 0; col < salesData.Columns.Count; col++)
{
    reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns[col].ColumnName);
}
// Format headers
var headers = reportSheet[$"A{headerRow}:F{headerRow}"];
headers.Style.Font.Bold = true;
headers.Style.SetBackgroundColor("#D9E1F2");
// Data rows
for (int row = 0; row < salesData.Rows.Count; row++)
{
    for (int col = 0; col < salesData.Columns.Count; col++)
    {
        reportSheet.SetCellValue(row + headerRow, col, salesData.Rows[row][col]);
    }
    // Add total column with formula
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}
// Add total header and format
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency columns
reportSheet[$"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
// Format date column
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";
// Add summary section
int summaryRow = headerRow + salesData.Rows.Count + 2;
reportSheet[$"A{summaryRow}"].Value = "Summary";
reportSheet[$"A{summaryRow}"].Style.Font.Bold = true;
reportSheet[$"A{summaryRow + 1}"].Value = "Total Orders:";
reportSheet[$"B{summaryRow + 1}"].Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})";
reportSheet[$"A{summaryRow + 2}"].Value = "Total Revenue:";
reportSheet[$"B{summaryRow + 2}"].Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})";
reportSheet[$"B{summaryRow + 2}"].FormatString = "$#,##0.00";
// Auto-fit columns
for (int col = 0; col <= 6; col++)
{
    reportSheet.AutoSizeColumn(col);
}
// Evaluate formulas and save
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");
using System.Data;
using System.Data.SqlClient;
// Simulate database retrieval (replace with your actual database code)
DataTable GetSalesData()
{
    DataTable dt = new DataTable("Sales");
    dt.Columns.Add("OrderID", typeof(int));
    dt.Columns.Add("CustomerName", typeof(string));
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Quantity", typeof(int));
    dt.Columns.Add("UnitPrice", typeof(decimal));
    dt.Columns.Add("OrderDate", typeof(DateTime));
    // Sample data (normally from database)
    dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99m, DateTime.Now.AddDays(-5));
    dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99m, DateTime.Now.AddDays(-4));
    dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99m, DateTime.Now.AddDays(-3));
    dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99m, DateTime.Now.AddDays(-2));
    dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99m, DateTime.Now.AddDays(-1));
    return dt;
}
// Export to Excel
WorkBook reportWorkbook = WorkBook.Create();
WorkSheet reportSheet = reportWorkbook.CreateWorkSheet("Sales Report");
// Get data from database
DataTable salesData = GetSalesData();
// Method 1: Manual mapping with formatting
reportSheet["A1"].Value = "Order Report - " + DateTime.Now.ToString("MMMM yyyy");
reportSheet.Merge("A1:F1");
reportSheet["A1"].Style.Font.Bold = true;
reportSheet["A1"].Style.Font.Height = 14;
// Headers
int headerRow = 3;
for (int col = 0; col < salesData.Columns.Count; col++)
{
    reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns[col].ColumnName);
}
// Format headers
var headers = reportSheet[$"A{headerRow}:F{headerRow}"];
headers.Style.Font.Bold = true;
headers.Style.SetBackgroundColor("#D9E1F2");
// Data rows
for (int row = 0; row < salesData.Rows.Count; row++)
{
    for (int col = 0; col < salesData.Columns.Count; col++)
    {
        reportSheet.SetCellValue(row + headerRow, col, salesData.Rows[row][col]);
    }
    // Add total column with formula
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}
// Add total header and format
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency columns
reportSheet[$"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
// Format date column
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";
// Add summary section
int summaryRow = headerRow + salesData.Rows.Count + 2;
reportSheet[$"A{summaryRow}"].Value = "Summary";
reportSheet[$"A{summaryRow}"].Style.Font.Bold = true;
reportSheet[$"A{summaryRow + 1}"].Value = "Total Orders:";
reportSheet[$"B{summaryRow + 1}"].Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})";
reportSheet[$"A{summaryRow + 2}"].Value = "Total Revenue:";
reportSheet[$"B{summaryRow + 2}"].Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})";
reportSheet[$"B{summaryRow + 2}"].FormatString = "$#,##0.00";
// Auto-fit columns
for (int col = 0; col <= 6; col++)
{
    reportSheet.AutoSizeColumn(col);
}
// Evaluate formulas and save
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este completo ejemplo demuestra un flujo de trabajo de base de datos a Excel completo para generar archivos de Excel en C#. El DataTable simula la recuperación de bases de datos: en producción, reemplaza esto con tus consultas reales de base de datos usando Entity Framework, Dapper, o ADO.NET. El enfoque de asignación manual ofrece control completo sobre el formateo y diseño, como se recomienda en las mejores prácticas de exportación de datos de Microsoft.

El código crea un informe profesional con un título, encabezados formateados, y filas de datos. Las columnas de fórmula calculan totales de línea dinámicamente. La sección de resumen utiliza fórmulas de Excel para contar pedidos y sumar ingresos, asegurando que estos valores se actualicen si los datos cambian. El formato de moneda y fecha sigue los estándares de documentos empresariales, mientras el ajuste automático de columnas asegura que todo el contenido se visualice correctamente. Para manejar conjuntos de datos más grandes, explora nuestra guía de optimización de rendimiento.

Resultado

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 10 - Exportación de Base de Datos a Salida de Excel

¿Necesitas simplificar tus informes de Excel? Obtén una licencia para desbloquear todo el potencial de IronXL para implementaciones en producción.

¿Cómo gestionar varias hojas de trabajo?

Los archivos Excel complejos a menudo requieren múltiples hojas de trabajo para organizar datos relacionados. IronXL simplifica la gestión de múltiples hojas con métodos intuitivos para crear, acceder y organizar hojas de trabajo.

// Create a multi-sheet workbook
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet hrSheet = companyReport.CreateWorkSheet("HR Metrics");
// Populate Sales sheet
salesSheet["A1"].Value = "Sales Dashboard";
salesSheet["A3"].Value = "Region";
salesSheet["B3"].Value = "Q1 Sales";
salesSheet["C3"].Value = "Q2 Sales";
string[] regions = { "North", "South", "East", "West" };
decimal[] q1Sales = { 250000, 180000, 220000, 195000 };
decimal[] q2Sales = { 275000, 195000, 240000, 210000 };
for (int i = 0; i < regions.Length; i++)
{
    salesSheet[$"A{i + 4}"].Value = regions[i];
    salesSheet[$"B{i + 4}"].Value = q1Sales[i];
    salesSheet[$"C{i + 4}"].Value = q2Sales[i];
}
// Populate Inventory sheet
inventorySheet["A1"].Value = "Inventory Status";
inventorySheet["A3"].Value = "Product";
inventorySheet["B3"].Value = "Stock Level";
inventorySheet["C3"].Value = "Reorder Point";
inventorySheet["D3"].Value = "Status";
// Add inventory data with conditional status
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] stock = { 150, 45, 200 };
int[] reorderPoint = { 100, 50, 75 };
for (int i = 0; i < products.Length; i++)
{
    inventorySheet[$"A{i + 4}"].Value = products[i];
    inventorySheet[$"B{i + 4}"].Value = stock[i];
    inventorySheet[$"C{i + 4}"].Value = reorderPoint[i];
    // Status based on stock level
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    // Color code status
    if (status == "REORDER")
    {
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
    }
}
// Create summary sheet referencing other sheets
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Company Overview";
summarySheet["A3"].Value = "Metric";
summarySheet["B3"].Value = "Value";
summarySheet["A4"].Value = "Total Q1 Sales";
summarySheet["B4"].Formula = "=SUM(Sales!B4:B7)";
summarySheet["A5"].Value = "Total Q2 Sales";
summarySheet["B5"].Formula = "=SUM(Sales!C4:C7)";
summarySheet["A6"].Value = "Products Need Reorder";
summarySheet["B6"].Formula = "=COUNTIF(Inventory!D4:D6,\"REORDER\")";
// Format all sheets consistently
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    // Format headers
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
    var headerRow = sheet["A3:D3"];
    headerRow.Style.Font.Bold = true;
    headerRow.Style.SetBackgroundColor("#E7E6E6");
}
// Save multi-sheet workbook
companyReport.SaveAs("CompanyReport.xlsx");
// Create a multi-sheet workbook
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet hrSheet = companyReport.CreateWorkSheet("HR Metrics");
// Populate Sales sheet
salesSheet["A1"].Value = "Sales Dashboard";
salesSheet["A3"].Value = "Region";
salesSheet["B3"].Value = "Q1 Sales";
salesSheet["C3"].Value = "Q2 Sales";
string[] regions = { "North", "South", "East", "West" };
decimal[] q1Sales = { 250000, 180000, 220000, 195000 };
decimal[] q2Sales = { 275000, 195000, 240000, 210000 };
for (int i = 0; i < regions.Length; i++)
{
    salesSheet[$"A{i + 4}"].Value = regions[i];
    salesSheet[$"B{i + 4}"].Value = q1Sales[i];
    salesSheet[$"C{i + 4}"].Value = q2Sales[i];
}
// Populate Inventory sheet
inventorySheet["A1"].Value = "Inventory Status";
inventorySheet["A3"].Value = "Product";
inventorySheet["B3"].Value = "Stock Level";
inventorySheet["C3"].Value = "Reorder Point";
inventorySheet["D3"].Value = "Status";
// Add inventory data with conditional status
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] stock = { 150, 45, 200 };
int[] reorderPoint = { 100, 50, 75 };
for (int i = 0; i < products.Length; i++)
{
    inventorySheet[$"A{i + 4}"].Value = products[i];
    inventorySheet[$"B{i + 4}"].Value = stock[i];
    inventorySheet[$"C{i + 4}"].Value = reorderPoint[i];
    // Status based on stock level
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    // Color code status
    if (status == "REORDER")
    {
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
    }
}
// Create summary sheet referencing other sheets
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Company Overview";
summarySheet["A3"].Value = "Metric";
summarySheet["B3"].Value = "Value";
summarySheet["A4"].Value = "Total Q1 Sales";
summarySheet["B4"].Formula = "=SUM(Sales!B4:B7)";
summarySheet["A5"].Value = "Total Q2 Sales";
summarySheet["B5"].Formula = "=SUM(Sales!C4:C7)";
summarySheet["A6"].Value = "Products Need Reorder";
summarySheet["B6"].Formula = "=COUNTIF(Inventory!D4:D6,\"REORDER\")";
// Format all sheets consistently
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    // Format headers
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
    var headerRow = sheet["A3:D3"];
    headerRow.Style.Font.Bold = true;
    headerRow.Style.SetBackgroundColor("#E7E6E6");
}
// Save multi-sheet workbook
companyReport.SaveAs("CompanyReport.xlsx");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este ejemplo crea un informe completo de múltiples hojas. Cada hoja de trabajo sirve un propósito específico: datos de ventas, seguimiento de inventario, y métricas de recursos humanos. La hoja de resumen consolida métricas clave usando fórmulas entre hojas. Observa la sintaxis de referencia de hojas en las fórmulas: "Sales!B4:B7" se refiere a las celdas B4 a B7 en la hoja de Ventas.

La hoja de inventario demuestra lógica condicional, coloreando elementos con bajo stock en rojo para una atención inmediata. El bucle foreach aplica un formato consistente en todas las hojas, manteniendo una apariencia profesional en todo el libro de trabajo. Los nombres de las hojas aparecen como pestañas en Excel, permitiendo a los usuarios navegar fácilmente entre diferentes vistas de datos.

¿Cuáles son las mejores prácticas para la generación de Excel?

Una generación eficiente de archivos Excel en C# requiere enfoques reflexivos para el uso de memoria, manejo de errores e implementación. Estas prácticas aseguran que tus aplicaciones escalen efectivamente mientras mantienen la fiabilidad al crear hojas de cálculo de Excel programáticamente.

La gestión de memoria se vuelve crítica con archivos grandes. En lugar de cargar conjuntos de datos enteros en memoria, procesa los datos en partes:

// Process large datasets efficiently
public void ExportLargeDataset(string filename)
{
    WorkBook workbook = WorkBook.Create();
    WorkSheet sheet = workbook.CreateWorkSheet("Data");
    int rowsPerBatch = 1000;
    int currentRow = 1;
    // Process in batches
    foreach (var batch in GetDataInBatches(rowsPerBatch))
    {
        foreach (var record in batch)
        {
            sheet[$"A{currentRow}"].Value = record.Id;
            sheet[$"B{currentRow}"].Value = record.Name;
            sheet[$"C{currentRow}"].Value = record.Value;
            currentRow++;
        }
    }
    workbook.SaveAs(filename);
}
// Process large datasets efficiently
public void ExportLargeDataset(string filename)
{
    WorkBook workbook = WorkBook.Create();
    WorkSheet sheet = workbook.CreateWorkSheet("Data");
    int rowsPerBatch = 1000;
    int currentRow = 1;
    // Process in batches
    foreach (var batch in GetDataInBatches(rowsPerBatch))
    {
        foreach (var record in batch)
        {
            sheet[$"A{currentRow}"].Value = record.Id;
            sheet[$"B{currentRow}"].Value = record.Name;
            sheet[$"C{currentRow}"].Value = record.Value;
            currentRow++;
        }
    }
    workbook.SaveAs(filename);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

El manejo de errores previene bloqueos de la aplicación y proporciona retroalimentación significativa al generar archivos de Excel:

try
{
    WorkBook workbook = WorkBook.Create();
    // Excel generation code
    workbook.SaveAs("output.xlsx");
}
catch (Exception ex)
{
    // Log the error
    Console.WriteLine($"Excel generation failed: {ex.Message}");
    // Implement appropriate recovery or notification
}
try
{
    WorkBook workbook = WorkBook.Create();
    // Excel generation code
    workbook.SaveAs("output.xlsx");
}
catch (Exception ex)
{
    // Log the error
    Console.WriteLine($"Excel generation failed: {ex.Message}");
    // Implement appropriate recovery or notification
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Para aplicaciones web, genera archivos de Excel en memoria y transmítelos a los usuarios:

// ASP.NET Core example
public IActionResult DownloadExcel()
{
    WorkBook workbook = GenerateReport();
    var stream = new MemoryStream();
    workbook.SaveAs(stream);
    stream.Position = 0;
    return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx");
}
// ASP.NET Core example
public IActionResult DownloadExcel()
{
    WorkBook workbook = GenerateReport();
    var stream = new MemoryStream();
    workbook.SaveAs(stream);
    stream.Position = 0;
    return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Las consideraciones de implementación aseguran operaciones de producción sin problemas. IronXL funciona en entornos restringidos sin permisos elevados, haciéndolo adecuado para hosting compartido e implementaciones contenedorizadas. Incluye el archivo de licencia IronXL en tu paquete de implementación, y asegura que tu aplicación tenga permisos de escritura para operaciones de archivos temporales si es necesario. Para orientación adicional sobre la implementación, consulta la documentación de implementación.

Conclusión

IronXL transforma la generación de archivos de Excel en C# de un desafío complejo a una codificación sencilla. Has aprendido a crear libros de trabajo, poblar celdas, aplicar formato, usar fórmulas, y exportar datos de bases de datos, todo sin dependencias de Microsoft Office. Estas técnicas para la generación de archivos Excel de manera programática funcionan consistentemente en plataformas de Windows, Linux y en la nube.

¿Listo para implementar la generación de Excel en tus aplicaciones C#? Comienza tu prueba gratuita o explora la completa documentación de la API para características avanzadas. Para implementaciones en producción, revisa las opciones de licencias que se ajusten a los requisitos de tu proyecto.

Cómo Generar un Archivo de Excel en C# Usando IronXL: Figura 11 - Licencias

Preguntas Frecuentes

¿Qué es IronXL?

IronXL es una biblioteca que permite a los desarrolladores crear, leer y editar archivos Excel en C# sin requerir Microsoft Office o un complejo COM Interop.

¿Cómo puedo generar archivos Excel usando C#?

Puedes generar archivos Excel en C# usando IronXL, que proporciona una API sencilla para crear, formatear y manipular archivos Excel de forma programática.

¿Necesito tener instalado Microsoft Office para usar IronXL?

No, IronXL no requiere que Microsoft Office esté instalado en tu sistema, convirtiéndolo en una solución ligera para crear y editar archivos Excel.

¿Puede IronXL manejar el formato avanzado de Excel?

Sí, IronXL admite opciones de formato avanzadas, lo que te permite aplicar estilos, formatos y otras características de Excel a tus hojas de cálculo.

¿Es posible integrar bases de datos con archivos Excel usando IronXL?

Sí, IronXL te permite integrar archivos Excel con bases de datos, facilitando tareas como la exportación de datos y la generación de informes directamente desde aplicaciones C#.

¿Con qué formatos de archivo puede trabajar IronXL?

IronXL puede trabajar con formatos de archivo XLS y XLSX, proporcionando flexibilidad en la gestión de archivos Excel.

¿Puedo automatizar la generación de hojas de cálculo con IronXL?

Sí, IronXL te permite automatizar la generación de hojas de cálculo, siendo ideal para tareas como la creación de informes y la exportación de datos.

¿IronXL es compatible con aplicaciones .NET?

IronXL es totalmente compatible con aplicaciones .NET, permitiendo una integración y funcionalidad perfectas dentro de tus proyectos C#.

¿Cuáles son algunos casos de uso comunes para IronXL?

Los casos de uso comunes de IronXL incluyen la creación de informes, la exportación de datos, la automatización de tareas de hojas de cálculo y la integración de funcionalidades de Excel dentro de aplicaciones .NET.

¿Cómo simplifica IronXL la creación de archivos Excel en C#?

IronXL simplifica la creación de archivos Excel al ofrecer una API simple e intuitiva que elimina la necesidad de configuraciones y dependencias complejas, agilizando el proceso de desarrollo.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita