¿Para qué se utiliza IronXL en C#?

IronXL es una potente biblioteca para C# que permite a los desarrolladores crear, editar y leer archivos de Excel con facilidad. Permite generar informes de Excel profesionales con formato avanzado, fórmulas e integración de datos.

¿Cómo puedo crear informes de Excel con IronXL?

Para crear informes de Excel utilizando IronXL, puede utilizar su sólida API para agregar datos, formatear celdas, aplicar fórmulas e integrarse con bases de datos, todo dentro de un entorno de C#.

¿Qué funciones ofrece IronXL para la generación de informes de Excel?

IronXL ofrece funciones como el formato de celdas, la aplicación de fórmulas, la validación de datos, la creación de gráficos y la integración perfecta con bases de datos para la generación de informes completos de Excel.

¿Es IronXL compatible con la integración de bases de datos?

Sí, IronXL admite la integración de bases de datos, lo que le permite extraer datos directamente de las bases de datos e incorporarlos a sus informes de Excel, agilizando el análisis de datos y la generación de informes.

¿Puede IronXL manejar fórmulas complejas de Excel?

IronXL puede manejar una amplia gama de fórmulas de Excel, lo que permite a los desarrolladores ejecutar cálculos complejos y automatizar el procesamiento de datos dentro de los informes de Excel.

¿Es posible formatear celdas de Excel con IronXL?

IronXL proporciona amplias capacidades de formato, lo que le permite personalizar la apariencia de las celdas, incluyendo el estilo de fuente, color, bordes y más, para crear informes de Excel visualmente atractivos.

¿Puedo crear gráficos en Excel con IronXL?

Sí, IronXL permite crear una gran variedad de gráficos dentro de las hojas de cálculo de Excel, lo que ayuda a representar visualmente los datos y a mejorar la interpretabilidad de los informes.

¿Cómo simplifica IronXL el proceso de generación de informes de Excel?

IronXL simplifica el proceso de generación de informes de Excel ofreciendo un amplio conjunto de funciones que agilizan la entrada, el formato, el cálculo y la salida de datos, todo ello dentro del entorno de programación C#.

¿IronXL maneja grandes conjuntos de datos eficientemente?

El rendimiento de IronXL está optimizado, lo que le permite manejar grandes conjuntos de datos de manera eficiente, por lo que es ideal para generar informes complejos sin comprometer la velocidad o la fiabilidad.

¿Para qué lenguaje de programación está diseñado IronXL?

IronXL está diseñado específicamente para su uso con C#, proporcionando una integración y funcionalidad perfectas para los desarrolladores que trabajan dentro del marco .NET.

La biblioteca de Excel en C#

Explore Biblioteca de hojas de cálculo de Excel de IronXL para C# .NET Prueba gratis

Leer archivos de Excel sin Interop

Ver Todos los Ejemplos de Código %s

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

USANDO IRONXL

Creating Excel Reports in C# with IronXL

Curtis Chau

Updated: 8 de mayo de 2026

Crear informes de Excel en C# es un requisito fundamental en los negocios modernos y en aplicaciones de .NET. Ya sea que estés generando estados financieros, análisis de ventas o paneles de inventario, automatizar el proceso para crear archivos de Excel y hojas de cálculo de Excel ahorra horas de esfuerzo manual mientras reduce errores.

IronXL proporciona una solución potente e intuitiva para que los desarrolladores creen un informe de Excel en C# sin necesidad de Microsoft Office, MS Excel o las dependencias tradicionales de Interop. A diferencia de la Automatización OLE o de los enfoques que dependen de la aplicación Excel, IronXL permite generar libros de trabajo de Excel y datos de Excel directamente en el código con solo una línea donde sea necesario. En esta guía, le enseñaremos cómo crear informes de Excel con IronXL, ¡completos con código de ejemplo fácil de seguir que puede implementar fácilmente en sus propios proyectos!

¿Qué es IronXL y por qué utilizarlo para la generación de archivos Excel?

IronXL es una biblioteca .NET Excel que permite a los desarrolladores crear, leer hojas de cálculo Excel y manipular archivos Excel directamente desde el código fuente de C# o Visual Basic. A diferencia de los enfoques de Microsoft Office Interop que dependen de la aplicación Excel completa o de la ingeniería inversa a través de Open XML SDK, IronXL funciona en Windows, Linux, macOS y entornos en la nube sin necesidad de instalar Excel ni dependencias de terceros. Esto lo hace ideal para informes de Excel en el servidor, flujos de trabajo automatizados y aplicaciones web construidas sobre .NET Core o el .NET Framework.

Para equipos que están pasando de procesos manuales de Excel, bibliotecas más antiguas o flujos de trabajo de herramientas de productividad Open XML que requieren navegar por varios namespaces XML, IronXL ofrece una API intuitiva. Soporta tanto archivos XLS heredados como archivos XLSX modernos, que son esencialmente archivos ZIP que contienen archivos XML y varias carpetas. Ya sea que desees generar un nuevo libro de trabajo de Excel, manipular múltiples hojas de trabajo o cargar datos de Excel desde código externo, IronXL simplifica drásticamente el proceso sin necesidad de entender los formatos subyacentes.

Introducción a IronXL para crear un archivo de Excel

Configurar IronXL para crear informes de Excel lleva solo minutos. Instala la biblioteca a través del Administrador de Paquetes NuGet en Visual Studio:

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

Descarga IronXL hoy mismo y comienza a automatizar la generación de informes de Excel.

Una vez instalado, crear tu primer informe de Excel requiere solo unas pocas líneas de código:

using IronXL;
// Create a new Excel workbook for reports
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add a worksheet for the report
WorkSheet reportSheet = workBook.CreateWorkSheet("Monthly Report");
// Add a title
reportSheet["A1"].Value = "Sales Report - January 2024";
reportSheet["A1"].Style.Font.Bold = true;
// Save the Excel report
workBook.SaveAs("MonthlyReport.xlsx");

using IronXL;
// Create a new Excel workbook for reports
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add a worksheet for the report
WorkSheet reportSheet = workBook.CreateWorkSheet("Monthly Report");
// Add a title
reportSheet["A1"].Value = "Sales Report - January 2024";
reportSheet["A1"].Style.Font.Bold = true;
// Save the Excel report
workBook.SaveAs("MonthlyReport.xlsx");

Imports IronXL

' Create a new Excel workbook for reports
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add a worksheet for the report
Dim reportSheet As WorkSheet = workBook.CreateWorkSheet("Monthly Report")
' Add a title
reportSheet("A1").Value = "Sales Report - January 2024"
reportSheet("A1").Style.Font.Bold = True
' Save the Excel report
workBook.SaveAs("MonthlyReport.xlsx")

Imports IronXL

' Create a new Excel workbook for reports
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add a worksheet for the report
Dim reportSheet As WorkSheet = workBook.CreateWorkSheet("Monthly Report")
' Add a title
reportSheet("A1").Value = "Sales Report - January 2024"
reportSheet("A1").Style.Font.Bold = True
' Save the Excel report
workBook.SaveAs("MonthlyReport.xlsx")

Este código crea un nuevo archivo de informe de Excel con un título formateado. La sintaxis de referencia de celda familiar (reportSheet["A1"]) permite a los desarrolladores especificar fácilmente dónde deben aparecer los datos exactamente, como si trabajaran con Excel manualmente.

Resultado

Cómo crear informes de Excel en C# usando IronXL: Imagen 1 - Ejemplo de salida de Excel

Carga de datos de múltiples fuentes

Los informes de Excel del mundo real rara vez usan datos estáticos. IronXL destaca en integrar datos de Excel desde varios formatos, API, nuevas fuentes DataTable o incluso varios archivos XML diferentes. Esto lo hace perfecto para la generación dinámica de informes de Excel en C# en aplicaciones web o del lado del servidor.

Integración de bases de datos

Para los informes de Excel basados en bases de datos, IronXL funciona perfectamente con ADO.NET DataTables:

using System.Data;
using System.Data.SqlClient;
// Fetch data from database
string connectionString = "Server=localhost;Database=Sales;Integrated Security=true;";
DataTable salesData = new DataTable();
using (SqlConnection conn = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(
        "SELECT ProductName, Quantity, Revenue FROM MonthlySales", conn);
    adapter.Fill(salesData);
}
// Create Excel report from DataTable
WorkBook workBook = WorkBook.Create();
WorkSheet sheet = workBook.CreateWorkSheet("Sales Data");
// Add headers
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Revenue";
// Populate data
int row = 2;
foreach (DataRow dataRow in salesData.Rows)
{
    sheet[$"A{row}"].Value = dataRow["ProductName"];
    sheet[$"B{row}"].Value = dataRow["Quantity"];
    sheet[$"C{row}"].Value = dataRow["Revenue"];
    row++;
}

using System.Data;
using System.Data.SqlClient;
// Fetch data from database
string connectionString = "Server=localhost;Database=Sales;Integrated Security=true;";
DataTable salesData = new DataTable();
using (SqlConnection conn = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(
        "SELECT ProductName, Quantity, Revenue FROM MonthlySales", conn);
    adapter.Fill(salesData);
}
// Create Excel report from DataTable
WorkBook workBook = WorkBook.Create();
WorkSheet sheet = workBook.CreateWorkSheet("Sales Data");
// Add headers
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Revenue";
// Populate data
int row = 2;
foreach (DataRow dataRow in salesData.Rows)
{
    sheet[$"A{row}"].Value = dataRow["ProductName"];
    sheet[$"B{row}"].Value = dataRow["Quantity"];
    sheet[$"C{row}"].Value = dataRow["Revenue"];
    row++;
}

Imports System.Data
Imports System.Data.SqlClient

' Fetch data from database
Dim connectionString As String = "Server=localhost;Database=Sales;Integrated Security=true;"
Dim salesData As New DataTable()
Using conn As New SqlConnection(connectionString)
    Dim adapter As New SqlDataAdapter("SELECT ProductName, Quantity, Revenue FROM MonthlySales", conn)
    adapter.Fill(salesData)
End Using

' Create Excel report from DataTable
Dim workBook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workBook.CreateWorkSheet("Sales Data")

' Add headers
sheet("A1").Value = "Product"
sheet("B1").Value = "Quantity"
sheet("C1").Value = "Revenue"

' Populate data
Dim row As Integer = 2
For Each dataRow As DataRow In salesData.Rows
    sheet($"A{row}").Value = dataRow("ProductName")
    sheet($"B{row}").Value = dataRow("Quantity")
    sheet($"C{row}").Value = dataRow("Revenue")
    row += 1
Next

Imports System.Data
Imports System.Data.SqlClient

' Fetch data from database
Dim connectionString As String = "Server=localhost;Database=Sales;Integrated Security=true;"
Dim salesData As New DataTable()
Using conn As New SqlConnection(connectionString)
    Dim adapter As New SqlDataAdapter("SELECT ProductName, Quantity, Revenue FROM MonthlySales", conn)
    adapter.Fill(salesData)
End Using

' Create Excel report from DataTable
Dim workBook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workBook.CreateWorkSheet("Sales Data")

' Add headers
sheet("A1").Value = "Product"
sheet("B1").Value = "Quantity"
sheet("C1").Value = "Revenue"

' Populate data
Dim row As Integer = 2
For Each dataRow As DataRow In salesData.Rows
    sheet($"A{row}").Value = dataRow("ProductName")
    sheet($"B{row}").Value = dataRow("Quantity")
    sheet($"C{row}").Value = dataRow("Revenue")
    row += 1
Next

Este enfoque carga datos de ventas directamente desde SQL Server en tu informe de Excel. La integración de DataTable significa que puedes usar el código de acceso a datos existente sin modificaciones. Para escenarios más complejos, consulta cómo cargar Excel desde bases de datos SQL.

Trabajar con colecciones

Para datos en memoria, datos de Excel procedentes de respuestas de API o una nueva DataTable, las colecciones pueden rellenar hojas de cálculo de Excel fácilmente sin Microsoft Excel ni dependencias de terceros:

var salesRecords = new List<SalesRecord>
{
    new SalesRecord { Product = "Widget A", Units = 150, Price = 29.99m },
    new SalesRecord { Product = "Widget B", Units = 82, Price = 49.99m }
};
// Convert collection to Excel
for (int i = 0; i < salesRecords.Count; i++)
{
    sheet[$"A{i+2}"].Value = salesRecords[i].Product;
    sheet[$"B{i+2}"].Value = salesRecords[i].Units;
    sheet[$"C{i+2}"].Value = salesRecords[i].Price;
}

var salesRecords = new List<SalesRecord>
{
    new SalesRecord { Product = "Widget A", Units = 150, Price = 29.99m },
    new SalesRecord { Product = "Widget B", Units = 82, Price = 49.99m }
};
// Convert collection to Excel
for (int i = 0; i < salesRecords.Count; i++)
{
    sheet[$"A{i+2}"].Value = salesRecords[i].Product;
    sheet[$"B{i+2}"].Value = salesRecords[i].Units;
    sheet[$"C{i+2}"].Value = salesRecords[i].Price;
}

Imports System.Collections.Generic

Dim salesRecords As New List(Of SalesRecord) From {
    New SalesRecord With {.Product = "Widget A", .Units = 150, .Price = 29.99D},
    New SalesRecord With {.Product = "Widget B", .Units = 82, .Price = 49.99D}
}

' Convert collection to Excel
For i As Integer = 0 To salesRecords.Count - 1
    sheet($"A{i + 2}").Value = salesRecords(i).Product
    sheet($"B{i + 2}").Value = salesRecords(i).Units
    sheet($"C{i + 2}").Value = salesRecords(i).Price
Next

Imports System.Collections.Generic

Dim salesRecords As New List(Of SalesRecord) From {
    New SalesRecord With {.Product = "Widget A", .Units = 150, .Price = 29.99D},
    New SalesRecord With {.Product = "Widget B", .Units = 82, .Price = 49.99D}
}

' Convert collection to Excel
For i As Integer = 0 To salesRecords.Count - 1
    sheet($"A{i + 2}").Value = salesRecords(i).Product
    sheet($"B{i + 2}").Value = salesRecords(i).Units
    sheet($"C{i + 2}").Value = salesRecords(i).Price
Next

Este método permite crear un informe de Excel en C# directamente en una aplicación .NET, haciendo que el proceso involucrado para generar múltiples hojas de trabajo o archivos XLSX sea mucho más simple que la Automatización OLE manual o la ingeniería inversa de archivos XML.

Resultado

Cómo crear informes de Excel en C# usando IronXL: Imagen 2 - Hoja de trabajo de muestra a partir de la salida de datos

Formato de informes profesionales de Excel

Los datos sin procesar por sí solos no hacen un informe profesional. IronXL proporciona opciones de formateo de celdas completas para crear archivos de Excel bien terminados, listos para los negocios. El siguiente código muestra lo fácil que es esto con IronXL:

using IronXL;
using IronXL.Styles;

class Program
{
    static void Main(string[] args)
    {
        // Create a new workbook
        var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        // Add a new worksheet
        var sheet = workbook.CreateWorkSheet("MySheet");
        // Add header values
        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Quantity";
        sheet["C1"].Value = "Price";
        // Add sample data rows
        sheet["A2"].Value = "Laptop";
        sheet["B2"].Value = 5;
        sheet["C2"].Value = 1299.99;
        sheet["A3"].Value = "Headphones";
        sheet["B3"].Value = 15;
        sheet["C3"].Value = 199.50;
        sheet["A4"].Value = "Keyboard";
        sheet["B4"].Value = 10;
        sheet["C4"].Value = 89.99;
        sheet["A5"].Value = "Monitor";
        sheet["B5"].Value = 7;
        sheet["C5"].Value = 249.00;
        // Header formatting
        var headerRange = sheet["A1:C1"];
        headerRange.Style.Font.Bold = true;
        headerRange.Style.SetBackgroundColor("#4472C4");
        headerRange.Style.Font.Color = "#FFFFFF";
        headerRange.Style.BottomBorder.Type = BorderType.Thick;
        // Number formatting for currency
        sheet["C:C"].FormatString = "$#,##0.00";
        // Alternating row colors for readability
        for (int row = 2; row <= 10; row++)
        {
            if (row % 2 == 0)
            {
                sheet[$"A{row}:C{row}"].Style.SetBackgroundColor("#F2F2F2");
            }
        }
        // Column width adjustment
        sheet.Columns[0].Width = 15 * 256; // Width in 1/256th of character width
        sheet.Columns[2].Width = 12 * 256;
        // Add borders around data
        var dataRange = sheet["A1:C10"];
        dataRange.Style.TopBorder.Type = BorderType.Thin;
        dataRange.Style.RightBorder.Type = BorderType.Thin;
        dataRange.Style.BottomBorder.Type = BorderType.Thin;
        dataRange.Style.LeftBorder.Type = BorderType.Thin;
        // Save the workbook to a file
        workbook.SaveAs("MyWorkbook.xlsx");
    }
}

using IronXL;
using IronXL.Styles;

class Program
{
    static void Main(string[] args)
    {
        // Create a new workbook
        var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        // Add a new worksheet
        var sheet = workbook.CreateWorkSheet("MySheet");
        // Add header values
        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Quantity";
        sheet["C1"].Value = "Price";
        // Add sample data rows
        sheet["A2"].Value = "Laptop";
        sheet["B2"].Value = 5;
        sheet["C2"].Value = 1299.99;
        sheet["A3"].Value = "Headphones";
        sheet["B3"].Value = 15;
        sheet["C3"].Value = 199.50;
        sheet["A4"].Value = "Keyboard";
        sheet["B4"].Value = 10;
        sheet["C4"].Value = 89.99;
        sheet["A5"].Value = "Monitor";
        sheet["B5"].Value = 7;
        sheet["C5"].Value = 249.00;
        // Header formatting
        var headerRange = sheet["A1:C1"];
        headerRange.Style.Font.Bold = true;
        headerRange.Style.SetBackgroundColor("#4472C4");
        headerRange.Style.Font.Color = "#FFFFFF";
        headerRange.Style.BottomBorder.Type = BorderType.Thick;
        // Number formatting for currency
        sheet["C:C"].FormatString = "$#,##0.00";
        // Alternating row colors for readability
        for (int row = 2; row <= 10; row++)
        {
            if (row % 2 == 0)
            {
                sheet[$"A{row}:C{row}"].Style.SetBackgroundColor("#F2F2F2");
            }
        }
        // Column width adjustment
        sheet.Columns[0].Width = 15 * 256; // Width in 1/256th of character width
        sheet.Columns[2].Width = 12 * 256;
        // Add borders around data
        var dataRange = sheet["A1:C10"];
        dataRange.Style.TopBorder.Type = BorderType.Thin;
        dataRange.Style.RightBorder.Type = BorderType.Thin;
        dataRange.Style.BottomBorder.Type = BorderType.Thin;
        dataRange.Style.LeftBorder.Type = BorderType.Thin;
        // Save the workbook to a file
        workbook.SaveAs("MyWorkbook.xlsx");
    }
}

Imports IronXL
Imports IronXL.Styles

Module Program
    Sub Main(args As String())
        ' Create a new workbook
        Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
        ' Add a new worksheet
        Dim sheet = workbook.CreateWorkSheet("MySheet")
        ' Add header values
        sheet("A1").Value = "Product"
        sheet("B1").Value = "Quantity"
        sheet("C1").Value = "Price"
        ' Add sample data rows
        sheet("A2").Value = "Laptop"
        sheet("B2").Value = 5
        sheet("C2").Value = 1299.99
        sheet("A3").Value = "Headphones"
        sheet("B3").Value = 15
        sheet("C3").Value = 199.5
        sheet("A4").Value = "Keyboard"
        sheet("B4").Value = 10
        sheet("C4").Value = 89.99
        sheet("A5").Value = "Monitor"
        sheet("B5").Value = 7
        sheet("C5").Value = 249.0
        ' Header formatting
        Dim headerRange = sheet("A1:C1")
        headerRange.Style.Font.Bold = True
        headerRange.Style.SetBackgroundColor("#4472C4")
        headerRange.Style.Font.Color = "#FFFFFF"
        headerRange.Style.BottomBorder.Type = BorderType.Thick
        ' Number formatting for currency
        sheet("C:C").FormatString = "$#,##0.00"
        ' Alternating row colors for readability
        For row As Integer = 2 To 10
            If row Mod 2 = 0 Then
                sheet($"A{row}:C{row}").Style.SetBackgroundColor("#F2F2F2")
            End If
        Next
        ' Column width adjustment
        sheet.Columns(0).Width = 15 * 256 ' Width in 1/256th of character width
        sheet.Columns(2).Width = 12 * 256
        ' Add borders around data
        Dim dataRange = sheet("A1:C10")
        dataRange.Style.TopBorder.Type = BorderType.Thin
        dataRange.Style.RightBorder.Type = BorderType.Thin
        dataRange.Style.BottomBorder.Type = BorderType.Thin
        dataRange.Style.LeftBorder.Type = BorderType.Thin
        ' Save the workbook to a file
        workbook.SaveAs("MyWorkbook.xlsx")
    End Sub
End Module

Imports IronXL
Imports IronXL.Styles

Module Program
    Sub Main(args As String())
        ' Create a new workbook
        Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
        ' Add a new worksheet
        Dim sheet = workbook.CreateWorkSheet("MySheet")
        ' Add header values
        sheet("A1").Value = "Product"
        sheet("B1").Value = "Quantity"
        sheet("C1").Value = "Price"
        ' Add sample data rows
        sheet("A2").Value = "Laptop"
        sheet("B2").Value = 5
        sheet("C2").Value = 1299.99
        sheet("A3").Value = "Headphones"
        sheet("B3").Value = 15
        sheet("C3").Value = 199.5
        sheet("A4").Value = "Keyboard"
        sheet("B4").Value = 10
        sheet("C4").Value = 89.99
        sheet("A5").Value = "Monitor"
        sheet("B5").Value = 7
        sheet("C5").Value = 249.0
        ' Header formatting
        Dim headerRange = sheet("A1:C1")
        headerRange.Style.Font.Bold = True
        headerRange.Style.SetBackgroundColor("#4472C4")
        headerRange.Style.Font.Color = "#FFFFFF"
        headerRange.Style.BottomBorder.Type = BorderType.Thick
        ' Number formatting for currency
        sheet("C:C").FormatString = "$#,##0.00"
        ' Alternating row colors for readability
        For row As Integer = 2 To 10
            If row Mod 2 = 0 Then
                sheet($"A{row}:C{row}").Style.SetBackgroundColor("#F2F2F2")
            End If
        Next
        ' Column width adjustment
        sheet.Columns(0).Width = 15 * 256 ' Width in 1/256th of character width
        sheet.Columns(2).Width = 12 * 256
        ' Add borders around data
        Dim dataRange = sheet("A1:C10")
        dataRange.Style.TopBorder.Type = BorderType.Thin
        dataRange.Style.RightBorder.Type = BorderType.Thin
        dataRange.Style.BottomBorder.Type = BorderType.Thin
        dataRange.Style.LeftBorder.Type = BorderType.Thin
        ' Save the workbook to a file
        workbook.SaveAs("MyWorkbook.xlsx")
    End Sub
End Module

Estas opciones de formateo transforman los datos básicos en informes profesionales. La API de estilo cubre todo desde fuentes y colores hasta bordes y alineación, dando control total sobre la apariencia del informe de Excel. Para necesidades de formateo avanzadas, explora la formateo condicional para resaltar datos importantes automáticamente.

Cómo crear informes de Excel en C# usando IronXL: Imagen 3 - Salida de Excel formateada

Uso de fórmulas para cálculos de informes dinámicos de Excel

El poder de Excel radica en sus fórmulas, y IronXL soporta completamente la creación de fórmulas de Excel:

// Add formula for row totals
sheet["D1"].Value = "Total";
sheet["D2"].Formula = "=B2*C2";
// Copy formula down the column
for (int row = 3; row <= 10; row++)
{
    sheet[$"D{row}"].Formula = $"=B{row}*C{row}";
}
// Add summary formulas
sheet["A12"].Value = "Summary";
sheet["B12"].Formula = "=SUM(B2:B10)";
sheet["C12"].Formula = "=AVERAGE(C2:C10)";
sheet["D12"].Formula = "=SUM(D2:D10)";

// Add formula for row totals
sheet["D1"].Value = "Total";
sheet["D2"].Formula = "=B2*C2";
// Copy formula down the column
for (int row = 3; row <= 10; row++)
{
    sheet[$"D{row}"].Formula = $"=B{row}*C{row}";
}
// Add summary formulas
sheet["A12"].Value = "Summary";
sheet["B12"].Formula = "=SUM(B2:B10)";
sheet["C12"].Formula = "=AVERAGE(C2:C10)";
sheet["D12"].Formula = "=SUM(D2:D10)";

' Add formula for row totals
sheet("D1").Value = "Total"
sheet("D2").Formula = "=B2*C2"
' Copy formula down the column
For row As Integer = 3 To 10
    sheet($"D{row}").Formula = $"=B{row}*C{row}"
Next
' Add summary formulas
sheet("A12").Value = "Summary"
sheet("B12").Formula = "=SUM(B2:B10)"
sheet("C12").Formula = "=AVERAGE(C2:C10)"
sheet("D12").Formula = "=SUM(D2:D10)"

' Add formula for row totals
sheet("D1").Value = "Total"
sheet("D2").Formula = "=B2*C2"
' Copy formula down the column
For row As Integer = 3 To 10
    sheet($"D{row}").Formula = $"=B{row}*C{row}"
Next
' Add summary formulas
sheet("A12").Value = "Summary"
sheet("B12").Formula = "=SUM(B2:B10)"
sheet("C12").Formula = "=AVERAGE(C2:C10)"
sheet("D12").Formula = "=SUM(D2:D10)"

El soporte de fórmulas incluye todas las funciones estándar de Excel como SUM, AVERAGE, IF, VLOOKUP y más. IronXL maneja automáticamente las dependencias de las fórmulas y el orden de cálculo, haciendo que la generación de informes de Excel con cálculos complejos sea sencilla. Aprende más sobre funciones matemáticas en IronXL.

Cómo crear informes de Excel en C# usando IronXL: Imagen 4 - Ejemplo de salida con fórmulas

Informes basados en plantillas

Para informes de Excel recurrentes o libros de trabajo estandarizados, IronXL soporta la generación basada en plantillas, permitiendo a los desarrolladores crear un archivo de Excel desde una plantilla sin tener que lidiar con Open XML SDK, archivos rels o varias carpetas:

// Load existing template
Workbook templateBook = Workbook.Load("ReportTemplate.xlsx");
Worksheet templateSheet = templateBook.DefaultWorksheet;
// Find and replace template markers
foreach (var cell in templateSheet["A1:Z100"])
{
    if (cell.Text.Contains("{{CompanyName}}"))
        cell.Value = cell.Text.Replace("{{CompanyName}}", "Acme Corp");
    if (cell.Text.Contains("{{ReportDate}}"))
        cell.Value = cell.Text.Replace("{{ReportDate}}", DateTime.Now.ToString("MMMM yyyy"));
}
// Save as new report
templateBook.SaveAs($"Report_{DateTime.Now:yyyyMMdd}.xlsx");

// Load existing template
Workbook templateBook = Workbook.Load("ReportTemplate.xlsx");
Worksheet templateSheet = templateBook.DefaultWorksheet;
// Find and replace template markers
foreach (var cell in templateSheet["A1:Z100"])
{
    if (cell.Text.Contains("{{CompanyName}}"))
        cell.Value = cell.Text.Replace("{{CompanyName}}", "Acme Corp");
    if (cell.Text.Contains("{{ReportDate}}"))
        cell.Value = cell.Text.Replace("{{ReportDate}}", DateTime.Now.ToString("MMMM yyyy"));
}
// Save as new report
templateBook.SaveAs($"Report_{DateTime.Now:yyyyMMdd}.xlsx");

Imports System

' Load existing template
Dim templateBook As Workbook = Workbook.Load("ReportTemplate.xlsx")
Dim templateSheet As Worksheet = templateBook.DefaultWorksheet
' Find and replace template markers
For Each cell In templateSheet("A1:Z100")
    If cell.Text.Contains("{{CompanyName}}") Then
        cell.Value = cell.Text.Replace("{{CompanyName}}", "Acme Corp")
    End If
    If cell.Text.Contains("{{ReportDate}}") Then
        cell.Value = cell.Text.Replace("{{ReportDate}}", DateTime.Now.ToString("MMMM yyyy"))
    End If
Next
' Save as new report
templateBook.SaveAs($"Report_{DateTime.Now:yyyyMMdd}.xlsx")

Imports System

' Load existing template
Dim templateBook As Workbook = Workbook.Load("ReportTemplate.xlsx")
Dim templateSheet As Worksheet = templateBook.DefaultWorksheet
' Find and replace template markers
For Each cell In templateSheet("A1:Z100")
    If cell.Text.Contains("{{CompanyName}}") Then
        cell.Value = cell.Text.Replace("{{CompanyName}}", "Acme Corp")
    End If
    If cell.Text.Contains("{{ReportDate}}") Then
        cell.Value = cell.Text.Replace("{{ReportDate}}", DateTime.Now.ToString("MMMM yyyy"))
    End If
Next
' Save as new report
templateBook.SaveAs($"Report_{DateTime.Now:yyyyMMdd}.xlsx")

Este enfoque mantiene un formato consistente mientras actualiza contenido dinámico, perfecto para informes mensuales o documentos estandarizados.

Cómo crear informes de Excel en C# usando IronXL: Imagen 5 - La plantilla de informe vs. nuestro archivo de Excel creado usando la plantilla

Mejores prácticas y solución de problemas

Al implementar la generación de informes de Excel, ten en cuenta estos consejos:

Uso de memoria con archivos grandes: procese los datos en fragmentos en lugar de cargar conjuntos de datos completos ( recomendaciones de Microsoft para archivos grandes de Excel )
Problemas de formato de fecha: utilice DateTime.ToOADate() para fechas compatibles con Excel ( explicación del sistema de fechas de Excel )
Errores de archivo bloqueado: Siempre deseche correctamente los objetos de Excel utilizando declaraciones using o nuevos enfoques MemoryStream.
Faltan estilos: Algunas propiedades de estilo requieren establecer primero el color de fondo

Conclusión

IronXL transforma la generación de informes de Excel de ser un proceso tedioso y manual a un flujo de trabajo automatizado y confiable. Con su API intuitiva, soporte multiplataforma y conjunto de características completas, los desarrolladores pueden crear informes de Excel profesionales en minutos en lugar de horas. La combinación de integración fácil de datos, poderosas opciones de formateo y soporte de fórmulas hace de IronXL una herramienta esencial para cualquier desarrollador de C# que trabaje con informes de Excel. Para los desarrolladores interesados, IronXL ofrece una prueba gratuita y otras opciones de licencia para empresas y particulares.

Primer Paso:

Curtis Chau

Chatea con el equipo de ingeniería ahora

Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.

...