Cómo generar archivos de Excel en C# usando IronXL

¿Por qué generar archivos 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 al funcionar de forma 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 se escribe una vez y se implementa en cualquier lugar, ya sea para aplicaciones de .NET Framework, .NET Core o .NET 10.

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 su aplicación, lo que se traduce en una ejecución más rápida y un menor consumo de recursos al generar archivos Excel mediante programación.

La implementación se vuelve sencilla ya que IronXL se entrega como un único paquete NuGet. Sin entradas en el Registro, sin registro COM y sin paquetes de servicio de Office que mantener. Tus procesos de integración continua funcionan sin problemas y los contenedores Docker siguen siendo 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 siguen explorando la herramienta Open XML Productivity Tool 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, ofreciéndole un camino mucho más rápido para trabajar con Excel mediante programación.

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

La instalación de IronXL se realiza en unos instantes a través del Gestor de paquetes NuGet en Visual Studio. Haga clic con el botón derecho del ratón en su proyecto en el Explorador de soluciones y seleccione "Administrar paquetes NuGet". Busque "IronXl.Excel" y haga clic en Instalar. El paquete incluye automáticamente todas las dependencias necesarias para generar archivos de Excel en C#.

Para instalarlo a través de la Consola del Administrador de paquetes o la CLI de .NET, utilice cualquiera de los siguientes comandos:

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Comprueba la instalación con esta sencilla prueba para confirmar que la biblioteca está lista:

using IronXL;
// Create an in-memory workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

using IronXL;
// Create an in-memory workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

Imports IronXL

' Create an in-memory workbook
Dim workbook = WorkBook.Create()
Console.WriteLine("IronXL installed successfully!")

Si esto se ejecuta sin errores, IronXL está listo para su uso. La biblioteca es compatible con todas las versiones modernas de .NET, asegurando la compatibilidad con tus proyectos existentes. Para obtener instrucciones detalladas sobre la instalación y la resolución de problemas, consulte la documentación oficial de instalación de NuGet.

¿Cómo se crea el primer archivo de Excel?

La creación de archivos Excel con IronXL comienza con la clase WorkBook, tu puerta de entrada a todas las operaciones de Excel. La biblioteca es compatible tanto con el formato moderno XLSX como con el formato heredado XLS, lo que te ofrece flexibilidad para diferentes requisitos a la hora de crear un archivo 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 header row
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 header row
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");

Imports IronXL

' Create a new workbook (XLSX format by default)
Dim workbook As 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
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("January Sales")

' Add header row
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.0

' Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx")

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 le permite incrustar información del documento que aparece en las propiedades del archivo de Excel, siguiendo 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 Excel completo en el disco. Para más operaciones con hojas de cálculo, consulta la guía sobre cómo escribir archivos de Excel.

¿Cómo se escriben 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. Comprender estos métodos te ayuda a elegir el enfoque más eficiente para tu escenario de datos cuando escribes en un archivo de Excel.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 at once
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based header 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");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 at once
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based header 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");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As 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 at once
worksheet("B1:B3").Value = "Active"
' Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department") ' C1
worksheet.SetCellValue(1, 2, "Sales") ' C2
worksheet.SetCellValue(2, 2, "Marketing") ' C3
' Array-based header population
Dim headers As String() = {"ID", "Name", "Email", "Phone"}
For i As Integer = 0 To headers.Length - 1
    worksheet.SetCellValue(0, i, headers(i))
Next
' Working with different data types
worksheet("E1").Value = "Salary"
worksheet("E2").Value = 75000.5D ' Decimal for currency
worksheet("E3").Value = 82000.75D
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")

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 de manera eficiente el mismo valor en varias celdas, lo que resulta ideal para inicializar columnas o aplicar valores predeterminados.

IronXL gestiona de forma inteligente diferentes tipos de datos. Los decimales mantienen la precisión de los 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. Para conjuntos de datos de gran tamaño, consulta la guía de importación de datos para conocer otros patrones.

¿Cómo se aplica un formato profesional a los archivos de Excel?

Los archivos Excel profesionales requieren más que datos en bruto. La API de estilo de IronXL transforma hojas de cálculo sencillas en documentos empresariales pulidos mediante el formato, los colores y la jerarquía visual. Puede aplicar formato a las celdas para controlar todos los aspectos visuales de su hoja de cálculo.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 width
// 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;
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability (banded rows)
for (int row = 2; row <= 10; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
workbook.SaveAs("FormattedReport.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 width
// 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;
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability (banded rows)
for (int row = 2; row <= 10; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
workbook.SaveAs("FormattedReport.xlsx");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

' Header formatting
Dim 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 width

' Number formatting
Dim salaryColumn = worksheet("E2:E3")
salaryColumn.FormatString = "$#,##0.00"

' Date formatting
Dim dateColumn = worksheet("F2:F3")
dateColumn.FormatString = "MM/dd/yyyy"

' Cell borders
Dim 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
dataRange.Style.TopBorder.Color = "#000000"
dataRange.Style.BottomBorder.Color = "#000000"

' Text alignment
worksheet("A1:G1").Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center

' Alternating row colors for readability (banded rows)
For row As Integer = 2 To 10
    If row Mod 2 = 0 Then
        worksheet($"A{row}:G{row}").Style.SetBackgroundColor("#F2F2F2")
    End If
Next

workbook.SaveAs("FormattedReport.xlsx")

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, 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.

Ajustes de ancho de columna previenen la truncación de texto. AutoSizeColumn() ajusta automáticamente el contenido, mientras que GetColumn().Width proporciona un control exacto. El formato de los números utiliza los códigos de formato de Excel; por ejemplo, "$#,##0.00" muestra la moneda con separadores de miles y dos decimales. El formato de fecha sigue patrones similares, utilizando cadenas de formato de fecha estándar de Excel tal y como se documenta en la referencia de códigos de formato numérico de Microsoft.

Los bordes definen límites de datos, mejorando la legibilidad. La enumeración BorderType ofrece varios estilos: fino, medio, grueso, punteado y discontinuo. 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. Para obtener más información sobre la fusión de celdas y otras funciones de diseño, consulta la guía de fusión de celdas.

¿Cómo se utilizan las 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.

using IronXL;
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 and add row total formulas
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];
    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";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas before saving
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");

using IronXL;
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 and add row total formulas
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];
    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";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas before saving
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");

Imports IronXL

Dim workbook = WorkBook.Create()
' Create a budget worksheet
Dim budget As WorkSheet = 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
Dim categories As String() = {"Salaries", "Marketing", "Operations", "Equipment", "Training"}
Dim monthlyBudgets As Decimal(,) = {
    {50000, 52000, 51000},
    {15000, 18000, 20000},
    {8000, 8500, 9000},
    {12000, 5000, 7000},
    {3000, 3500, 4000}
}
' Populate data and add row total formulas
For i As Integer = 0 To categories.Length - 1
    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)
    budget($"E{i + 2}").Formula = $"=SUM(B{i + 2}:D{i + 2})"
Next
' 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"
' Average calculation
budget("A10").Value = "Average Spending"
budget("B10").Formula = "=AVERAGE(B2:B6)"
' Evaluate all formulas before saving
workbook.EvaluateAll()
workbook.SaveAs("Budget.xlsx")

Este ejemplo de presupuesto ilustra la aplicación práctica de fórmulas. La propiedad Formula admite la sintaxis estándar de fórmulas de Excel, comenzando con un signo igual. IronXL soporta 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.

El método EvaluateAll() procesa todas las fórmulas, actualizando los valores calculados en todo el libro. Esto garantiza que las fórmulas muestren resultados cuando se abre el archivo en Excel. Sin la evaluación, Excel mostraría el texto de la fórmula hasta que el usuario activara el recálculo. Para obtener más información sobre cómo leer los resultados de las fórmulas, consulta la documentación sobre cómo leer archivos de Excel.

¿Cómo se exportan los datos de una base 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 gracias a la compatibilidad integrada con DataTable, lo que elimina la necesidad de realizar una asignación manual de campos al exportar Excel desde aplicaciones C#.

using System.Data;
using IronXL;

// Simulate database retrieval (replace with 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));
    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");
DataTable salesData = GetSalesData();

// Title row
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);
}
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]);
    }
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}

// Total header
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency and date 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";
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";

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

for (int col = 0; col <= 6; col++) { reportSheet.AutoSizeColumn(col); }
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");

using System.Data;
using IronXL;

// Simulate database retrieval (replace with 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));
    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");
DataTable salesData = GetSalesData();

// Title row
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);
}
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]);
    }
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}

// Total header
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency and date 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";
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";

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

for (int col = 0; col <= 6; col++) { reportSheet.AutoSizeColumn(col); }
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");

Imports System.Data
Imports IronXL

' Simulate database retrieval (replace with actual database code)
Function GetSalesData() As DataTable
    Dim dt As New DataTable("Sales")
    dt.Columns.Add("OrderID", GetType(Integer))
    dt.Columns.Add("CustomerName", GetType(String))
    dt.Columns.Add("Product", GetType(String))
    dt.Columns.Add("Quantity", GetType(Integer))
    dt.Columns.Add("UnitPrice", GetType(Decimal))
    dt.Columns.Add("OrderDate", GetType(DateTime))
    dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99D, DateTime.Now.AddDays(-5))
    dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99D, DateTime.Now.AddDays(-4))
    dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99D, DateTime.Now.AddDays(-3))
    dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99D, DateTime.Now.AddDays(-2))
    dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99D, DateTime.Now.AddDays(-1))
    Return dt
End Function

' Export to Excel
Dim reportWorkbook As WorkBook = WorkBook.Create()
Dim reportSheet As WorkSheet = reportWorkbook.CreateWorkSheet("Sales Report")
Dim salesData As DataTable = GetSalesData()

' Title row
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
Dim headerRow As Integer = 3
For col As Integer = 0 To salesData.Columns.Count - 1
    reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns(col).ColumnName)
Next
Dim headers = reportSheet($"A{headerRow}:F{headerRow}")
headers.Style.Font.Bold = True
headers.Style.SetBackgroundColor("#D9E1F2")

' Data rows
For row As Integer = 0 To salesData.Rows.Count - 1
    For col As Integer = 0 To salesData.Columns.Count - 1
        reportSheet.SetCellValue(row + headerRow, col, salesData.Rows(row)(col))
    Next
    reportSheet($"G{row + headerRow + 1}").Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}"
Next

' Total header
reportSheet("G3").Value = "Total"
reportSheet("G3").Style.Font.Bold = True
reportSheet("G3").Style.SetBackgroundColor("#D9E1F2")

' Format currency and date 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"
reportSheet($"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}").FormatString = "MM/dd/yyyy"

' Summary section
Dim summaryRow As Integer = 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"

For col As Integer = 0 To 6
    reportSheet.AutoSizeColumn(col)
Next
reportWorkbook.EvaluateAll()
reportWorkbook.SaveAs("DatabaseExport.xlsx")

Este ejemplo muestra un flujo de trabajo completo de la base de datos a Excel. El DataTable simula la recuperación de datos de la base de datos; en producción, sustitúyalo por consultas reales a la base de datos utilizando Entity Framework, Dapper o ADO.NET Framework. 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 los pedidos y sumar los ingresos, lo que garantiza que estos valores se actualicen si los datos cambian. Para trabajar con DataSets y estructuras de datos más grandes, consulte la guía de conversión de Excel a DataSet.

¿Cómo se gestionan varias hojas de cálculo?

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. Puedes abrir y gestionar hojas de libros de trabajo con solo unas pocas líneas de código.

using IronXL;
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");

// 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";
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];
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    if (status == "REORDER")
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}

// Summary sheet with cross-sheet formulas
summarySheet["A1"].Value = "Company Overview";
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\")";

// Apply consistent formatting across all sheets
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
}
companyReport.SaveAs("CompanyReport.xlsx");

using IronXL;
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");

// 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";
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];
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    if (status == "REORDER")
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}

// Summary sheet with cross-sheet formulas
summarySheet["A1"].Value = "Company Overview";
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\")";

// Apply consistent formatting across all sheets
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
}
companyReport.SaveAs("CompanyReport.xlsx");

Imports IronXL

Dim companyReport As WorkBook = WorkBook.Create()
' Create department sheets
Dim salesSheet As WorkSheet = companyReport.CreateWorkSheet("Sales")
Dim inventorySheet As WorkSheet = companyReport.CreateWorkSheet("Inventory")
Dim summarySheet As WorkSheet = companyReport.CreateWorkSheet("Summary")

' Populate Sales sheet
salesSheet("A1").Value = "Sales Dashboard"
salesSheet("A3").Value = "Region"
salesSheet("B3").Value = "Q1 Sales"
salesSheet("C3").Value = "Q2 Sales"
Dim regions As String() = {"North", "South", "East", "West"}
Dim q1Sales As Decimal() = {250000, 180000, 220000, 195000}
Dim q2Sales As Decimal() = {275000, 195000, 240000, 210000}
For i As Integer = 0 To regions.Length - 1
    salesSheet($"A{i + 4}").Value = regions(i)
    salesSheet($"B{i + 4}").Value = q1Sales(i)
    salesSheet($"C{i + 4}").Value = q2Sales(i)
Next

' Populate Inventory sheet
inventorySheet("A1").Value = "Inventory Status"
Dim products As String() = {"Widget A", "Widget B", "Widget C"}
Dim stock As Integer() = {150, 45, 200}
Dim reorderPoint As Integer() = {100, 50, 75}
For i As Integer = 0 To products.Length - 1
    inventorySheet($"A{i + 4}").Value = products(i)
    inventorySheet($"B{i + 4}").Value = stock(i)
    inventorySheet($"C{i + 4}").Value = reorderPoint(i)
    Dim status As String = If(stock(i) <= reorderPoint(i), "REORDER", "OK")
    inventorySheet($"D{i + 4}").Value = status
    If status = "REORDER" Then
        inventorySheet($"D{i + 4}").Style.Font.Color = "#FF0000"
    End If
Next

' Summary sheet with cross-sheet formulas
summarySheet("A1").Value = "Company Overview"
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"")"

' Apply consistent formatting across all sheets
For Each sheet As WorkSheet In companyReport.WorkSheets
    sheet("A1").Style.Font.Bold = True
    sheet("A1").Style.Font.Height = 14
Next

companyReport.SaveAs("CompanyReport.xlsx")

Este ejemplo crea un informe completo de múltiples hojas. Cada hoja de cálculo tiene una finalidad específica: datos de ventas, seguimiento de inventario y vista resumida. La hoja de resumen consolida métricas clave usando fórmulas entre hojas. Fíjate en la sintaxis de referencia de la hoja: "Sales!B4:B7" hace referencia a las celdas B4 a B7 de la hoja Sales.

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 coherente en todas las hojas, lo que mantiene una apariencia profesional en todo el libro. 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.

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

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. Procese los datos por lotes en lugar de cargar conjuntos de datos completos de una sola vez. El siguiente patrón mantiene predecible el uso de memoria para exportaciones de gran volumen:

using IronXL;
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 2;
sheet["A1"].Value = "ID";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Value";
// Process records in manageable 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("LargeDataset.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 2;
sheet["A1"].Value = "ID";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Value";
// Process records in manageable 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("LargeDataset.xlsx");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Data")
Dim rowsPerBatch As Integer = 1000
Dim currentRow As Integer = 2
sheet("A1").Value = "ID"
sheet("B1").Value = "Name"
sheet("C1").Value = "Value"
' Process records in manageable batches
For Each batch In GetDataInBatches(rowsPerBatch)
    For Each record In batch
        sheet($"A{currentRow}").Value = record.Id
        sheet($"B{currentRow}").Value = record.Name
        sheet($"C{currentRow}").Value = record.Value
        currentRow += 1
    Next
Next
workbook.SaveAs("LargeDataset.xlsx")

En el caso de las aplicaciones web, genere archivos Excel en memoria y transmítalos directamente a los usuarios en lugar de escribir archivos temporales en el disco. Incluya siempre la lógica de generación en el manejo de errores para evitar fallos y proporcionar información útil:

// ASP.NET Core controller action with error handling
IActionResult DownloadExcel()
{
    try
    {
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Report");
        sheet["A1"].Value = "Report Data";
        // Populate report data here...
        var stream = new MemoryStream();
        workbook.SaveAs(stream);
        stream.Position = 0;
        return File(stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "report.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excel generation failed: {ex.Message}");
        return StatusCode(500, "Failed to generate Excel file.");
    }
}

// ASP.NET Core controller action with error handling
IActionResult DownloadExcel()
{
    try
    {
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Report");
        sheet["A1"].Value = "Report Data";
        // Populate report data here...
        var stream = new MemoryStream();
        workbook.SaveAs(stream);
        stream.Position = 0;
        return File(stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "report.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excel generation failed: {ex.Message}");
        return StatusCode(500, "Failed to generate Excel file.");
    }
}

Imports System
Imports System.IO
Imports Microsoft.AspNetCore.Mvc

Public Class YourController
    Inherits Controller

    Public Function DownloadExcel() As IActionResult
        Try
            Dim workbook As WorkBook = WorkBook.Create()
            Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")
            sheet("A1").Value = "Report Data"
            ' Populate report data here...
            Dim stream As New MemoryStream()
            workbook.SaveAs(stream)
            stream.Position = 0
            Return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx")
        Catch ex As Exception
            Console.WriteLine($"Excel generation failed: {ex.Message}")
            Return StatusCode(500, "Failed to generate Excel file.")
        End Try
    End Function
End Class

La siguiente tabla resume las principales prácticas recomendadas y cuándo aplicarlas:

IronXL funciona en entornos restringidos sin permisos elevados, haciéndolo adecuado para hosting compartido e implementaciones contenedorizadas. Incluya el archivo de licencia de IronXL en su paquete de implementación y asegúrese de que su aplicación tenga permisos de escritura para cualquier operación con archivos temporales que sea necesaria. Para obtener orientación adicional sobre la implementación, consulte la descripción general de las características de IronXL y la documentación completa de la API.

¿Qué pasos se pueden dar a partir de aquí?

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, rellenar celdas, aplicar formato, utilizar fórmulas, exportar datos de bases de datos y gestionar varias hojas de cálculo, todo ello sin depender de Microsoft Office. Estas técnicas funcionan de manera consistente en Windows, Linux y plataformas en la nube destinadas a .NET 10.

Para profundizar, explore las guías prácticas de IronXl.Excel para leer y modificar archivos Excel existentes, o la página de Licencia Trial para empezar a trabajar en producción. Consulte las opciones de licencia que se ajustan a los requisitos y la escala de su proyecto.