Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Blog sobre generar Excel C#
USANDO IRONXL

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

Jordi Bardia
Jordi Bardia
Actualizado:

La generación programática de archivos de hojas de cálculo de Excel en C# solía requerir la instalación de Microsoft Office o una interoperabilidad COM compleja. IronXL cambia esto por completo, ofreciendo una API sencilla que crea archivos de Excel sin dependencias de Office. Este tutorial te guía para construir archivos de Excel en C# usando IronXL, desde la creación básica de hojas de cálculo hasta el formato avanzado y la integración de bases de datos. Ya sea que esté creando informes, exportando datos (archivos XLS o XLSX) o automatizando la generación de hojas de cálculo, aprenderá las técnicas esenciales para trabajar con Excel en aplicaciones .NET .

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 1 - 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 restricciones al operar 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 escribes una vez y lo implementas en cualquier lugar, ya sea que se trate de aplicaciones .NET Framework, .NET Core o .NET 10.

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 2 - Multiplataforma

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

La implementación se vuelve sencilla ya que IronXL se entrega como un único paquete NuGet. Sin entradas de registro, sin registro COM y sin paquetes de servicio de Office que mantener. Sus canales de integración continua funcionan sin fricciones y los contenedores Docker siguen siendo livianos. 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 aún exploran la herramienta de productividad Open XML de Microsoft para trabajar directamente con estructuras de archivos Open XML de Office. 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 generar un archivo de Excel en C# usando IronXL: Imagen 3 - Características

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

La instalación de IronXL sólo toma unos minutos a través del Administrador de paquetes NuGet en Visual Studio. Haga clic con el botón derecho 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 instalar 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
SHELL

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 4 - Instalación

Verifique 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!");
$vbLabelText   $csharpLabel

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

Resultado

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 5 - Salida de la consola

¿Cómo crear tu primer archivo de Excel?

La creación de archivos Excel con IronXL comienza con la clase WorkBook, su puerta de entrada a todas las operaciones de Excel. La biblioteca admite formatos XLSX modernos y XLS heredados, lo que le brinda flexibilidad para diferentes requisitos cuando crea un archivo 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");
$vbLabelText   $csharpLabel

Este código demuestra varios conceptos clave para la generación de archivos de Excel. El método WorkBook.Create() inicializa un nuevo archivo Excel en la memoria. Usted especifica el formato usando 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 de archivo de Excel, siguiendo los estándares de propiedades de documento de Microsoft .

El método CreateWorkSheet() agrega 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 conocer más operaciones con hojas de cálculo, explora la guía sobre cómo escribir archivos de Excel .

Resultado

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 6 - Salida básica de Excel

¿Cómo escribir datos en celdas de Excel?

IronXL proporciona múltiples enfoques para poblar celdas de Excel, desde asignaciones de celdas individuales hasta operaciones en rangos amplios. Comprender estos métodos le ayudará a elegir el enfoque más eficiente para su escenario de datos cuando escribe 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");
$vbLabelText   $csharpLabel

El código muestra la flexible dirección de celdas de IronXL. La notación de cadena ("A1") resulta natural para los usuarios de Excel, mientras que los índices numéricos ofrecen control programático para bucles y generación dinámica. Las asignaciones de rango ("B1:B3") establecen de manera eficiente varias celdas con el mismo valor, lo que es 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 valores booleanos se muestran como VERDADERO/FALSO. Esta conversión automática elimina el código de formato manual y asegura la integridad de los datos. Para conjuntos de datos grandes, explore la guía de importación de datos para obtener patrones adicionales.

Resultado

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 7 - Salida de Excel

¿Cómo aplicar formato profesional a 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 simples en documentos comerciales pulidos a través del formato, los colores y la jerarquía visual. Puede aplicar formato de celda para controlar cada aspecto visual 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");
$vbLabelText   $csharpLabel

Este código de formato crea una apariencia profesional que cumple con los estándares comerciales. Encabezados en negrita con colores de fondo establecen una jerarquía visual. El método SetBackgroundColor() acepta códigos de color hexadecimales, lo que proporciona un control preciso sobre su esquema de colores. Las propiedades de fuente incluyen opciones de tamaño, color, negrita, cursiva y subrayado, todas esenciales para crear archivos de Excel que cumplan con las pautas de marca 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 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 como se documenta en la referencia de códigos de formato de número 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 combinación de celdas y otras funciones de diseño, consulte la guía de combinación de celdas .

Resultado

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 8 - Salida de Excel formateada

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

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

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");
$vbLabelText   $csharpLabel

Este ejemplo de presupuesto ilustra la aplicación práctica de fórmulas. La propiedad Formula acepta la sintaxis de fórmula estándar 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 y actualiza los valores calculados en todo el libro de trabajo. Esto garantiza que las fórmulas muestren resultados cuando se abre el archivo en Excel. Sin evaluación, Excel mostraría el texto de la fórmula hasta que el usuario active el recálculo. Para obtener más información sobre la lectura de resultados de fórmulas, consulte la documentación de lectura de archivos de Excel .

Resultado

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 9 - Salida de Excel usando fórmulas

¿Cómo exportar 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 hace que este proceso sea sencillo con soporte DataTable integrado, eliminando la necesidad de mapeo 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");
$vbLabelText   $csharpLabel

Este ejemplo demuestra un flujo de trabajo completo de base de datos a Excel. El DataTable simula la recuperación de una base de datos; en producción, reemplácelo con consultas de base de datos reales utilizando Entity Framework, Dapper o ADO .NET. El enfoque de asignación manual ofrece control completo sobre el formateo y diseño, como se recomienda en las mejores prácticas de exportación de datos de Microsoft.

El código crea un informe profesional con un título, encabezados formateados, y filas de datos. Las columnas de fórmula calculan totales de línea dinámicamente. La sección de resumen utiliza fórmulas de Excel para contar pedidos y sumar ingresos, garantizando que estos valores se actualicen si los datos cambian. Para trabajar con conjuntos de datos y estructuras de datos más grandes, consulte la guía de conversión de Excel a conjuntos de datos .

Resultado

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 10 - Exportación de base de datos a salida de Excel

¿Necesita poner en producción informes de Excel? Obtenga una licencia para desbloquear todo el potencial de IronXL para implementaciones de producción.

¿Cómo manejar múltiples hojas de trabajo?

Los archivos Excel complejos a menudo requieren múltiples hojas de trabajo para organizar datos relacionados. IronXL simplifica la gestión de múltiples hojas con métodos intuitivos para crear, acceder y organizar hojas de trabajo. Puede abrir y administrar 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");
$vbLabelText   $csharpLabel

Este ejemplo crea un informe completo de múltiples hojas. Cada hoja de trabajo tiene un propósito específico: datos de ventas, seguimiento de inventario y una vista de resumen. La hoja de resumen consolida métricas clave usando fórmulas entre hojas. Tenga en cuenta la sintaxis de referencia de la hoja: "Ventas!B4:B7" hace referencia a las celdas B4 a B7 en la hoja Ventas.

La hoja de inventario demuestra lógica condicional, coloreando elementos con bajo stock en rojo para una atención inmediata. El bucle foreach aplica un formato uniforme en todas las hojas, manteniendo 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 diferentes vistas de datos.

¿Cuáles son las mejores prácticas para la generación de archivos de 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 en lotes en lugar de cargar conjuntos de datos completos a la vez. El siguiente patrón mantiene el uso de memoria predecible 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");
$vbLabelText   $csharpLabel

Para aplicaciones web, genere archivos Excel en la memoria y transmítalos directamente a los usuarios en lugar de escribir archivos temporales en el disco. Siempre envuelva la lógica de generación en el manejo de errores para evitar fallas y brindar retroalimentación significativa:

// 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.");
    }
}
$vbLabelText   $csharpLabel

La siguiente tabla resume las mejores prácticas clave y cuándo aplicarlas:

Mejores prácticas de IronXL para la generación de Excel en C#
Guión Enfoque recomendado Beneficio
Large datasets (>10,000 rows) Procesamiento por lotes con escrituras fragmentadas Huella de memoria reducida
Descargas de aplicaciones web MemoryStream en lugar de archivos temporales Sin E/S de disco, respuesta más rápida
Despliegue de producción Incluya una clave de licencia IronXL válida Sin marca de agua en los archivos generados
Moneda y fechas Utilice la propiedad FormatString Visualización correcta de la configuración regional en Excel
Informes dinámicos Llamar a EvaluateAll() antes de SaveAs() Las fórmulas muestran valores calculados

IronXL funciona en entornos restringidos sin permisos elevados, haciéndolo adecuado para hosting compartido e implementaciones contenedorizadas. Incluya el archivo de licencia IronXL en su paquete de implementación y asegúrese de que su aplicación tenga permisos de escritura para cualquier operación de archivo temporal 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 .

¿A dónde puedes ir desde aquí?

IronXL transforma la generación de archivos de Excel en C# de un desafío complejo a una codificación sencilla. Ha aprendido a crear libros de trabajo, completar celdas, aplicar formato, usar fórmulas, exportar datos de bases de datos y administrar varias hojas de trabajo, todo sin dependencias de Microsoft Office. Estas técnicas funcionan de manera consistente en plataformas Windows, Linux y en la nube dirigidas a .NET 10.

Para profundizar, explore las guías prácticas de IronXL para leer y modificar archivos Excel existentes, o la página de licencia de prueba para comenzar en producción. Vea las opciones de licencia que se ajusten a los requisitos y escala de su proyecto.

Cómo generar un archivo de Excel en C# usando IronXL: Imagen 11 - Licencias

Preguntas Frecuentes

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

Puede generar archivos Excel en C# utilizando IronXL, que proporciona una API simple para crear archivos Excel sin requerir la instalación de Microsoft Office o una interoperabilidad COM compleja.

¿Se requiere Microsoft Office para trabajar con archivos de Excel en C#?

No, no se requiere Microsoft Office. IronXL permite crear y manipular archivos de Excel en C# sin dependencias de Office.

¿Cuáles son las ventajas de usar IronXL sobre los métodos tradicionales?

IronXL simplifica el proceso de generación de archivos Excel al eliminar la necesidad de Microsoft Office y la interoperabilidad COM compleja, ofreciendo una API sencilla para la creación y manipulación de archivos Excel.

¿Puedo integrar bases de datos con archivos Excel usando IronXL?

Sí, IronXL admite operaciones avanzadas como la integración de bases de datos, lo que le permite exportar datos a archivos Excel de manera eficiente.

¿Qué formatos de archivos se pueden generar con IronXL?

IronXL le permite crear formatos de archivos XLS y XLSX, lo que lo hace versátil para diferentes necesidades de generación de archivos Excel.

¿ IronXL admite formato avanzado en archivos Excel?

Sí, IronXL admite funciones de formato avanzadas, lo que le permite personalizar la apariencia y la estructura de sus archivos de Excel.

¿Es posible automatizar la generación de hojas de cálculo utilizando IronXL?

Sí, IronXL proporciona herramientas y técnicas para automatizar la generación de hojas de cálculo, agilizando procesos como la creación de informes y la exportación de datos.

¿Cómo puedo crear informes usando Excel en aplicaciones .NET ?

IronXL ofrece una forma sencilla de crear informes generando archivos Excel directamente dentro de aplicaciones .NET , proporcionando una solución poderosa para la presentación de datos.

¿Qué técnicas son esenciales para trabajar con Excel en C#?

Las técnicas esenciales para trabajar con Excel en C# usando IronXL incluyen la creación de hojas de cálculo básicas, formato avanzado e integración de bases de datos.

¿Dónde puedo encontrar documentación para usar IronXL en C#?

Puede encontrar documentación completa sobre el uso de IronXL en C# en el sitio web de Iron Software , que incluye tutoriales y ejemplos para varios casos de uso.

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

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me