Generar archivos de Excel en C# sin interoperabilidad de Office

¿Por qué es importante la generación de Excel sin Office para DevOps?

El desarrollo de funciones de generación de Excel sin Office aborda retos clave de implementación. Los entornos de servidor suelen carecer de Microsoft Office debido a los costes de licencia y a las exigencias de recursos. Cada instalación de Office requiere una cantidad considerable de espacio en disco y memoria, lo que la hace inadecuada para implementaciones en la nube o aplicaciones en contenedores. Al implementar en AWS Lambda o ejecutar en contenedores Docker, una solución ligera es fundamental para la automatización de la infraestructura.

IronXL elimina estas limitaciones al funcionar de forma independiente. La generación de archivos Excel funciona en Windows, Linux, macOS, contenedores Docker o Azure App Services sin necesidad de 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. Para los equipos que utilizan .NET MAUI o Blazor, IronXLse integra a la perfección en todas las plataformas .NET modernas.

IronXL es compatible con todas las principales plataformas .NET y sistemas operativos para ofrecer la máxima flexibilidad de implementación.

¿Cómo se compara IronXLcon otras bibliotecas de Excel?

*Basado en recientes mejoras de rendimiento **Para procesar archivos Excel de gran tamaño

¿Qué ventajas de rendimiento ofrece IronXL?

El rendimiento mejora significativamente sin la sobrecarga de COM Interop. La automatización tradicional de Office crea instancias de proceso separadas para cada operación, consumiendo memoria y recursos de CPU. IronXLprocesa 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 biblioteca ha experimentado importantes mejoras de rendimiento; las actualizaciones recientes ofrecen una mejora de velocidad de hasta 40 veces y han reducido drásticamente el uso de memoria de 19,5 GB a menos de 1 GB.

La implementación se vuelve sencilla ya que IronXLse entrega como un único paquete NuGet. No hay que mantener entradas de registro, registros COM ni paquetes de servicio de Office. Tus procesos de integración continua funcionan sin problemas y los contenedores Docker siguen siendo ligeros. Este enfoque simplificado ha convertido a IronXLen una opción muy popular, tal y como se comenta en diversos foros de desarrolladores donde los profesionales comparten sus experiencias con la automatización de Excel sin Interop.

IronXL ofrece funciones completas de manipulación de Excel a través de un diseño de API intuitivo.

¿Cuál es el mejor método de instalación para los flujos de trabajo de DevOps?

La instalación de IronXLse realiza en unos instantes a través del gestor de paquetes NuGet. 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#. Para obtener instrucciones de instalación detalladas específicas para su entorno de desarrollo, consulte la Descripción general de introducción.

Alternativamente, usa la Consola del Administrador de Paquetes:

Install-Package IronXL.Excel

Install-Package IronXL.Excel

La Consola del Administrador de Paquetes confirma la instalación correcta de IronXLcon todas las dependencias necesarias.

¿Cómo integro IronXLcon los procesos de CI/CD?

Para usuarios de .NET CLI que trabajan con proyectos modernos de C# en procesos de compilación automatizados:

dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

Para implementaciones en contenedores, añada a su Dockerfile:

RUN dotnet add package IronXL.Excel

Comprueba la instalación con esta sencilla prueba para crear archivos de Excel mediante programación:

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!");

Este código crea un objeto de libro de trabajo en memoria. Si se ejecuta sin errores, IronXLestá listo para usarse. La biblioteca es compatible con todas las versiones modernas de .NET, asegurando la compatibilidad con tus proyectos existentes. Para los desarrolladores de VB.NET, hay disponible una funcionalidad similar con ejemplos de sintaxis específicos de VB. Cuando se trabaja con formatos de archivo heredados o se encuentran problemas relacionados con el tamaño de los archivos, la biblioteca ofrece soluciones completas.

Resultado

La salida de la consola confirma que IronXLestá correctamente instalado y listo para tareas de generación de Excel.

¿Cuáles son los pasos esenciales para la generación básica de Excel?

La creación de archivos Excel con IronXLcomienza 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#. La función de creación de hojas de cálculo ofrece opciones completas para inicializar nuevos libros de trabajo.

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");

¿Cómo debo utilizar los metadatos en los archivos Excel generados?

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. Especifique el formato utilizando la enumeración ExcelFileFormat: elija XLSX para compatibilidad con Excel moderno o XLS para compatibilidad con versiones anteriores. La propiedad Metadata 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 y facilitando la organización de archivos en entornos Enterprise. Más información sobre la edición de metadatos de libros de trabajo.

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. IronXLmaneja 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 Excel completo en el disco. Para más operaciones con hojas de cálculo, consulta el tutorial de gestión de hojas de cálculo.

Resultado

Archivo Excel básico generado por IronXLque muestra datos estructurados con los encabezados de columna adecuados.

¿Cuáles son los métodos más eficaces para rellenar datos en 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. La guía sobre cómo escribir valores en Excel cubre exhaustivamente todas las opciones disponibles.

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("EmployeeData.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("EmployeeData.xlsx");

¿Cómo gestiono grandes conjuntos de datos de forma eficiente?

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. Al trabajar con rangos o tablas con nombre, IronXLofrece capacidades organizativas adicionales.

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;
}

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. Al trabajar con grandes conjuntos de datos, puedes añadir filas y columnas de forma dinámica o copiar rangos de celdas para mayor eficiencia.

Resultado

Hoja de cálculo con datos de empleados que muestra múltiples tipos de datos y métodos de asignación de celdas en IronXL.

¿Qué se necesita para crear archivos Excel de calidad Enterprise?

Los archivos Excel profesionales requieren más que datos en bruto. La API de estilo de IronXLtransforma hojas de cálculo sencillas en documentos empresariales pulidos mediante el formato, los colores y la jerarquía visual al generar archivos de Excel en C#. La biblioteca ofrece opciones completas de formato de celdas para crear hojas de cálculo visualmente atractivas.

using IronXL;
using IronXL.Formatting;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Add sample data first
worksheet["A1"].Value = "ID";
worksheet["B1"].Value = "Name";
worksheet["C1"].Value = "Department";
worksheet["D1"].Value = "Phone";
worksheet["E1"].Value = "Salary";
worksheet["F1"].Value = "Start Date";
worksheet["G1"].Value = "Full Time";

// Add employee data
worksheet["A2"].Value = 101;
worksheet["B2"].Value = "John Smith";
worksheet["C2"].Value = "Sales";
worksheet["D2"].Value = "(555) 123-4567";
worksheet["E2"].Value = 75000.50m;
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["G2"].Value = true;

worksheet["A3"].Value = 102;
worksheet["B3"].Value = "Jane Doe";
worksheet["C3"].Value = "Marketing";
worksheet["D3"].Value = "(555) 987-6543";
worksheet["E3"].Value = 82000.75m;
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G3"].Value = true;

// Header formatting
var headerRange = worksheet["A1:G1"];
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.SetColumnWidth(1, 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.SetColor("#000000");
dataRange.Style.BottomBorder.SetColor("#000000");
dataRange.Style.LeftBorder.SetColor("#000000");
dataRange.Style.RightBorder.SetColor("#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");
    }
}

workbook.SaveAs("FormattedEmployees.xlsx");

using IronXL;
using IronXL.Formatting;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Add sample data first
worksheet["A1"].Value = "ID";
worksheet["B1"].Value = "Name";
worksheet["C1"].Value = "Department";
worksheet["D1"].Value = "Phone";
worksheet["E1"].Value = "Salary";
worksheet["F1"].Value = "Start Date";
worksheet["G1"].Value = "Full Time";

// Add employee data
worksheet["A2"].Value = 101;
worksheet["B2"].Value = "John Smith";
worksheet["C2"].Value = "Sales";
worksheet["D2"].Value = "(555) 123-4567";
worksheet["E2"].Value = 75000.50m;
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["G2"].Value = true;

worksheet["A3"].Value = 102;
worksheet["B3"].Value = "Jane Doe";
worksheet["C3"].Value = "Marketing";
worksheet["D3"].Value = "(555) 987-6543";
worksheet["E3"].Value = 82000.75m;
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G3"].Value = true;

// Header formatting
var headerRange = worksheet["A1:G1"];
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.SetColumnWidth(1, 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.SetColor("#000000");
dataRange.Style.BottomBorder.SetColor("#000000");
dataRange.Style.LeftBorder.SetColor("#000000");
dataRange.Style.RightBorder.SetColor("#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");
    }
}

workbook.SaveAs("FormattedEmployees.xlsx");

¿Cómo implemento funciones de estilo avanzadas?

Este código de formato crea una apariencia profesional que cumple con los estándares empresariales. Los encabezados en negrita con patrones y colores de fondo establecen una jerarquía visual. El método SetBackgroundColor() acepta códigos de color hexadecimales, lo que permite un control preciso sobre la combinación de colores. Las propiedades de la fuente incluyen opciones de tamaño, color, negrita, cursiva y subrayado, todas ellas esenciales para crear archivos de Excel que se ajusten a las directrices de imagen corporativa. Para necesidades de estilo avanzadas, explora las capacidades de formato condicional.

Ajustes de ancho de columna previenen la truncación de texto. AutoSizeColumn() ajusta automáticamente el contenido, mientras que SetColumnWidth() ofrece un control exacto. La función de ajuste automático del tamaño de filas y columnas garantiza una visualización óptima de tus datos. El formato de los números utiliza los códigos de formato de Excel; obtenga más información sobre los formatos numéricos de Excel para conocer todas las opciones de formato.

Los bordes y la alineación de las celdas definen los límites de los datos, lo que mejora la legibilidad. La enumeración BorderType ofrece varios estilos: fino, medio, grueso, punteado y discontinuo. Las opciones de bordes y alineación centran los encabezados y alinean los números a la derecha, siguiendo las convenciones de las hojas de cálculo. Los colores alternos de las filas, a menudo denominados "filas con bandas", ayudan a los lectores a seguir la información en conjuntos de datos extensos.

Resultado

Archivo Excel con formato profesional que muestra las capacidades de estilo de IronXLpara documentos empresariales.

¿Qué funciones de fórmulas permiten realizar cálculos dinámicos?

Las fórmulas de Excel dan vida a las hojas de cálculo con cálculos automáticos. IronXLadmite la creación y evaluación de fórmulas, habilitando hojas de cálculo dinámicas que se actualizan automáticamente. La biblioteca es compatible con más de 165 funciones de Excel y permite editar fórmulas mediante programación.

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");

¿Cómo puedo solucionar los problemas habituales con las fórmulas?

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

Cuando las fórmulas no calculan como se espera:

• Asegúrese de que la sintaxis sea correcta: las fórmulas deben comenzar con =
• Comprobar referencias de celdas: verificar que los rangos sean correctos
• Llamada a EvaluateAll(): Necesaria antes de guardar para ver los resultados
• Validar los tipos de datos: Asegurarse de que las celdas numéricas contengan números, no texto

El método EvaluateAll() procesa todas las fórmulas, actualizando los valores calculados en todo el libro. 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. Para escenarios complejos que impliquen fórmulas de Excel en C#, IronXLofrece una compatibilidad completa.

Resultado

Hoja de cálculo de presupuesto con fórmulas activas que calculan totales y porcentajes automáticamente.

¿Cuáles son las mejores prácticas para la exportación 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. IronXLagiliza este proceso con soporte integrado para DataTable, lo que elimina la asignación manual de campos al generar archivos Excel desde aplicaciones C#. La biblioteca ofrece múltiples métodos para la integración de bases de datos y la compatibilidad con DataGrid.

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");

¿Cómo puedo optimizar las exportaciones de bases de datos de gran tamaño?

Este completo ejemplo muestra un flujo de trabajo completo de base de datos a Excel para generar archivos Excel en C#. El DataTable simula la recuperación de datos de una base de datos; en producción, sustitúyalo por sus consultas de base de datos reales utilizando Entity Framework, Dapper o ADO.NET Framework. Para una integración directa con SQL, explore la posibilidad de cargar Excel desde bases de datos SQL o actualizar registros de la base de datos desde Excel.

Para exportaciones de bases de datos de gran tamaño, tenga en cuenta:

• Procesamiento por lotes: Exportación por partes para gestionar la memoria
• Operaciones asíncronas: Mantener la interfaz de usuario receptiva durante la exportación
• Informes de progreso: Mostrar el progreso de la exportación a los usuarios
• Gestión de errores: gestionar con elegancia los tiempos de espera de la base de datos

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 los pedidos y sumar los ingresos, lo que garantiza que estos valores se actualicen si los datos cambian. Para trabajar con DataSets en lugar de DataTables, consulte la guía de exportación de conjuntos de datos de Datatable.

Resultado

Informe de ventas profesional generado a partir de datos de la base de datos con cálculos y formato automáticos.

¿Necesitas simplificar tus informes de Excel? Consigue una licencia para aprovechar todo el potencial de IronXLen implementaciones de producción.

¿Cuándo debo utilizar libros de trabajo de varias hojas?

Los archivos Excel complejos a menudo requieren múltiples hojas de trabajo para organizar datos relacionados. IronXLsimplifica la gestión de múltiples hojas con métodos intuitivos para crear, acceder y organizar hojas de trabajo. Más información sobre cómo gestionar hojas de cálculo y copiar datos de hojas de cálculo para escenarios avanzados.

// 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");

¿Cómo puedo hacer referencia a datos de varias hojas?

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. Fíjate en la sintaxis de referencia a hojas en las fórmulas: "Sales!B4:B7" hace referencia a las celdas B4 a B7 de la hoja "Sales". Para operaciones más complejas, explora la posibilidad de combinar rangos de Excel y agrupar filas y columnas.

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, lo que permite a los usuarios navegar fácilmente entre las diferentes vistas de datos. Para casos más complejos, considere la posibilidad de añadir paneles fijos para mantener los encabezados visibles mientras se desplaza por conjuntos de datos de gran tamaño.

¿Cómo puedo garantizar la generación escalable de archivos Excel en producción?

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. Consulte las prácticas recomendadas de seguridad y las opciones de protección de archivos para implementaciones Enterprise.

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);
}

¿Cuáles son los problemas habituales de los equipos de DevOps?

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
}

Para aplicaciones web, genere archivos Excel en memoria y transmítalos a los usuarios. Este enfoque funciona perfectamente con aplicaciones ASP.NET MVC:

// 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");
}

¿Cómo configuro IronXLpara implementaciones en contenedores?

Las consideraciones de implementación aseguran operaciones de producción sin problemas. IronXLfunciona en entornos restringidos sin permisos elevados, haciéndolo adecuado para hosting compartido e implementaciones contenedorizadas. Incluye el archivo de licencia IronXLen tu paquete de implementación, y asegura que tu aplicación tenga permisos de escritura para operaciones de archivos temporales si es necesario. Para una configuración adecuada de la licencia, consulte el uso de claves de licencia y la configuración de web.config.

Para implementaciones de Docker:

FROM mcr.microsoft.com/dotnet/runtime:8.0
WORKDIR /app
COPY . .
# Instalar dependencias for Excel operations
RUN apt-get update && apt-get install -y libgdiplus
ENV IRONXL_LICENSE_KEY=${IRONXL_LICENSE_KEY}
ENTRYPOINT ["dotnet", "YourApp.dll"]

Cuando trabaje con datos confidenciales, considere la posibilidad de proteger los libros con contraseña y asegurar las hojas de cálculo. IronXLofrece funciones de seguridad completas para proteger sus archivos de Excel contra el acceso no autorizado. Para obtener un rendimiento óptimo con archivos de gran tamaño, implemente estrategias de recorte de datos y borrado de celdas para gestionar el tamaño de los archivos de forma eficaz.

Para implementaciones en Linux, asegúrese de realizar una configuración adecuada siguiendo la guía de configuración de Linux. Al realizar la implementación en AWS Lambda, consulte la guía de implementación de AWS para conocer las configuraciones específicas para entornos sin servidor.