Cree una API de Excel for .NET Core: cree, lea y exporte archivos XLSX

¿Cómo se instala IronXL en un proyecto .NET Core?

Añade IronXL a cualquier proyecto .NET 10 a través de la consola del gestor de paquetes NuGet:

Install-Package IronXl.Excel

O instálalo a través de la interfaz de usuario de Visual Studio NuGet buscando IronXL. El nombre del paquete en NuGet es IronXl.Excel.

Tras la instalación, añada using IronXL; a cualquier archivo que cree o lea libros de trabajo. No se requieren bibliotecas de interoperabilidad de Office, ni registro COM, ni instalación de Microsoft Excel en el equipo host: IronXL es totalmente autónomo.

IronXL está destinado a .NET Standard 2.0 y versiones superiores, lo que significa que la misma biblioteca funciona para proyectos de .NET Core, .NET 5/6/7/8/9/10 y .NET Framework. La documentación de IronXL cubre en detalle todos los entornos compatibles.

¿Cómo crear archivos de Excel mediante programación en .NET Core?

Crear documentos de Excel desde cero requiere solo unas pocas líneas de código con la intuitiva API de IronXL. La biblioteca ofrece un control total sobre los libros, las hojas de cálculo, los estilos de celda y las fórmulas a través de un modelo de objetos limpio.

A continuación se muestra una acción de controlador que crea un nuevo libro de Excel con datos formateados, muestra la gestión de hojas de cálculo y aplica estilos de celda:

using IronXL;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class ExcelController : ControllerBase
{
    [HttpGet("create-report")]
    public IActionResult CreateSalesReport()
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");

        // Set header labels in the first row
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Q1 Sales";
        worksheet["C1"].Value = "Q2 Sales";
        worksheet["D1"].Value = "Total";

        // Bold headers and apply a blue background with white text
        worksheet["A1:D1"].Style.Font.Bold = true;
        worksheet["A1:D1"].Style.SetBackgroundColor("#4472C4");
        worksheet["A1:D1"].Style.Font.SetColor("#FFFFFF");

        // Add data rows
        worksheet["A2"].Value = "Widget Pro";
        worksheet["B2"].Value = 15000;
        worksheet["C2"].Value = 18500;
        worksheet["D2"].Formula = "=B2+C2";

        worksheet["A3"].Value = "Gadget Plus";
        worksheet["B3"].Value = 22000;
        worksheet["C3"].Value = 24000;
        worksheet["D3"].Formula = "=B3+C3";

        // Apply currency number format to sales columns
        worksheet["B2:D3"].Style.Format = "$#,##0";

        // Stream the XLSX file back to the caller
        var stream = workbook.ToStream();
        return File(
            stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "SalesReport.xlsx");
    }
}

using IronXL;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class ExcelController : ControllerBase
{
    [HttpGet("create-report")]
    public IActionResult CreateSalesReport()
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");

        // Set header labels in the first row
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Q1 Sales";
        worksheet["C1"].Value = "Q2 Sales";
        worksheet["D1"].Value = "Total";

        // Bold headers and apply a blue background with white text
        worksheet["A1:D1"].Style.Font.Bold = true;
        worksheet["A1:D1"].Style.SetBackgroundColor("#4472C4");
        worksheet["A1:D1"].Style.Font.SetColor("#FFFFFF");

        // Add data rows
        worksheet["A2"].Value = "Widget Pro";
        worksheet["B2"].Value = 15000;
        worksheet["C2"].Value = 18500;
        worksheet["D2"].Formula = "=B2+C2";

        worksheet["A3"].Value = "Gadget Plus";
        worksheet["B3"].Value = 22000;
        worksheet["C3"].Value = 24000;
        worksheet["D3"].Formula = "=B3+C3";

        // Apply currency number format to sales columns
        worksheet["B2:D3"].Style.Format = "$#,##0";

        // Stream the XLSX file back to the caller
        var stream = workbook.ToStream();
        return File(
            stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "SalesReport.xlsx");
    }
}

Imports IronXL
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/[controller]")>
Public Class ExcelController
    Inherits ControllerBase

    <HttpGet("create-report")>
    Public Function CreateSalesReport() As IActionResult
        ' Create a new Excel workbook in XLSX format
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Sales Data")

        ' Set header labels in the first row
        worksheet("A1").Value = "Product"
        worksheet("B1").Value = "Q1 Sales"
        worksheet("C1").Value = "Q2 Sales"
        worksheet("D1").Value = "Total"

        ' Bold headers and apply a blue background with white text
        worksheet("A1:D1").Style.Font.Bold = True
        worksheet("A1:D1").Style.SetBackgroundColor("#4472C4")
        worksheet("A1:D1").Style.Font.SetColor("#FFFFFF")

        ' Add data rows
        worksheet("A2").Value = "Widget Pro"
        worksheet("B2").Value = 15000
        worksheet("C2").Value = 18500
        worksheet("D2").Formula = "=B2+C2"

        worksheet("A3").Value = "Gadget Plus"
        worksheet("B3").Value = 22000
        worksheet("C3").Value = 24000
        worksheet("D3").Formula = "=B3+C3"

        ' Apply currency number format to sales columns
        worksheet("B2:D3").Style.Format = "$#,##0"

        ' Stream the XLSX file back to the caller
        Dim stream = workbook.ToStream()
        Return File(
            stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "SalesReport.xlsx")
    End Function
End Class

¿Cuál es la mejor manera de leer datos de Excel en las API web?

La importación de datos desde archivos Excel subidos por los usuarios es esencial para cualquier aplicación web que procese contenido de hojas de cálculo. IronXL facilita la lectura de hojas de cálculo de Excel: carga desde un flujo, recorre las filas y extrae los valores introducidos de cada celda.

[HttpPost("import")]
public IActionResult ImportExcelData(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");

    using var stream = file.OpenReadStream();

    // Load the workbook directly from the upload stream
    WorkBook workbook = WorkBook.Load(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    var records = new List<Dictionary<string, object>>();

    // Start at row 2 to skip the header row
    for (int row = 2; row <= worksheet.RowCount; row++)
    {
        var record = new Dictionary<string, object>
        {
            ["Product"] = worksheet[$"A{row}"].StringValue,
            ["Sales"]   = worksheet[$"B{row}"].DecimalValue,
            ["Date"]    = worksheet[$"C{row}"].DateTimeValue
        };
        records.Add(record);
    }

    return Ok(new {
        message     = "Import successful",
        recordCount = records.Count,
        data        = records
    });
}

[HttpPost("import")]
public IActionResult ImportExcelData(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");

    using var stream = file.OpenReadStream();

    // Load the workbook directly from the upload stream
    WorkBook workbook = WorkBook.Load(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    var records = new List<Dictionary<string, object>>();

    // Start at row 2 to skip the header row
    for (int row = 2; row <= worksheet.RowCount; row++)
    {
        var record = new Dictionary<string, object>
        {
            ["Product"] = worksheet[$"A{row}"].StringValue,
            ["Sales"]   = worksheet[$"B{row}"].DecimalValue,
            ["Date"]    = worksheet[$"C{row}"].DateTimeValue
        };
        records.Add(record);
    }

    return Ok(new {
        message     = "Import successful",
        recordCount = records.Count,
        data        = records
    });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.Collections.Generic
Imports IronXL

<HttpPost("import")>
Public Function ImportExcelData(file As IFormFile) As IActionResult
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file uploaded")
    End If

    Using stream = file.OpenReadStream()
        ' Load the workbook directly from the upload stream
        Dim workbook As WorkBook = WorkBook.Load(stream)
        Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

        Dim records As New List(Of Dictionary(Of String, Object))()

        ' Start at row 2 to skip the header row
        For row As Integer = 2 To worksheet.RowCount
            Dim record As New Dictionary(Of String, Object) From {
                {"Product", worksheet($"A{row}").StringValue},
                {"Sales", worksheet($"B{row}").DecimalValue},
                {"Date", worksheet($"C{row}").DateTimeValue}
            }
            records.Add(record)
        Next

        Return Ok(New With {
            .message = "Import successful",
            .recordCount = records.Count,
            .data = records
        })
    End Using
End Function

¿Cómo puedes exportar datos de Excel a diferentes formatos?

Las aplicaciones suelen necesitar ofrecer hojas de cálculo en múltiples formatos de salida. IronXL permite exportar a XLSX, XLS, CSV, JSON y HTML con una sola llamada de método, sin necesidad de herramientas de conversión externas.

[HttpGet("export/{format}")]
public IActionResult ExportData(string format)
{
    // Load a pre-designed template workbook
    WorkBook workbook = WorkBook.Load("template.xlsx");

    return format.ToLower() switch
    {
        "xlsx" => File(
            workbook.ToStream(),
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "export.xlsx"),

        "csv"  => File(
            workbook.ToStream(FileFormat.CSV),
            "text/csv",
            "export.csv"),

        "json" => Ok(workbook.ToJson()),

        _      => BadRequest("Unsupported format")
    };
}

[HttpGet("export/{format}")]
public IActionResult ExportData(string format)
{
    // Load a pre-designed template workbook
    WorkBook workbook = WorkBook.Load("template.xlsx");

    return format.ToLower() switch
    {
        "xlsx" => File(
            workbook.ToStream(),
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "export.xlsx"),

        "csv"  => File(
            workbook.ToStream(FileFormat.CSV),
            "text/csv",
            "export.csv"),

        "json" => Ok(workbook.ToJson()),

        _      => BadRequest("Unsupported format")
    };
}

Imports Microsoft.AspNetCore.Mvc

<HttpGet("export/{format}")>
Public Function ExportData(format As String) As IActionResult
    ' Load a pre-designed template workbook
    Dim workbook As WorkBook = WorkBook.Load("template.xlsx")

    Select Case format.ToLower()
        Case "xlsx"
            Return File(workbook.ToStream(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "export.xlsx")
        Case "csv"
            Return File(workbook.ToStream(FileFormat.CSV), "text/csv", "export.csv")
        Case "json"
            Return Ok(workbook.ToJson())
        Case Else
            Return BadRequest("Unsupported format")
    End Select
End Function

El uso de plantillas de Excel con diseños predefinidos agiliza la generación de informes. Cargue un libro de trabajo prediseñado, rellene datos dinámicos en celdas o rangos con nombre y, a continuación, transmita el resultado. Este enfoque es adecuado para informes de ventas, facturas y documentos de cumplimiento normativo, en los que la coherencia del formato es más importante que la flexibilidad.

La compatibilidad multiplataforma de IronXL significa que estas operaciones con archivos funcionan de forma idéntica en Windows, Linux y macOS, lo que lo hace adecuado para implementaciones en contenedores de .NET Core. Más información en la guía multiplataforma de IronXL.

¿Cómo se aplican el formato condicional y las barras de datos?

Más allá de los estilos de celda básicos, IronXL admite reglas de formato condicional: resaltar en verde las celdas que superen un umbral, marcar los valores negativos en rojo o aplicar barras de datos con degradado para que las tendencias sean visibles de inmediato en la hoja de cálculo sin necesidad de procesamiento posterior en una herramienta independiente.

El formato condicional resulta especialmente valioso en paneles financieros e informes de KPI, donde los lectores necesitan detectar valores atípicos de un solo vistazo. En lugar de depender de que el destinatario aplique su propio formato tras la descarga, las reglas se incluyen en el archivo XLSX y se evalúan automáticamente cuando el archivo se abre en cualquier versión de Microsoft Excel o en un visor compatible.

El formato condicional se configura a través de la propiedad ConditionalFormatting de la hoja de cálculo. Las reglas se aplican a un rango de celdas designado y admiten varios tipos de condiciones: comparaciones de valores de celda, reglas basadas en fórmulas, escalas de color que clasifican los valores de menor a mayor y superposiciones de barras de datos que funcionan como gráficos de barras dentro de la celda. La especificación Open XML define la estructura de reglas subyacente que IronXL escribe en el archivo XLSX.

Para obtener una referencia completa sobre la aplicación de escalas de color, conjuntos de iconos y barras de datos, consulte el tutorial de formato condicional en la documentación de IronXL.

¿Cómo se protegen los archivos y las hojas de cálculo de Excel?

La distribución de informes que contienen datos confidenciales requiere un nivel de control de acceso. IronXL admite tanto la protección con contraseña a nivel de libro como a nivel de hoja de cálculo:

• Contraseña del libro: Establezca workbook.Password = "secret" antes de llamar a .SaveAs() para cifrar el archivo XLSX. Los destinatarios deben introducir la contraseña para abrirlo en Excel.
• Protección de hojas de cálculo: Llama a worksheet.ProtectSheet("password") para bloquear la edición de celdas sin impedir la visualización de la hoja. Se pueden desbloquear rangos específicos para la introducción de datos utilizando la API AllowEditRange.
• Distribución de solo lectura: para documentos que nunca deben editarse, combine la protección de hojas de cálculo con el cifrado a nivel de archivo.

Los archivos XLSX protegidos con contraseña utilizan el cifrado AES-128 de forma predeterminada, el mismo estándar que aplica el Excel nativo. Esto significa que un archivo protegido mediante IronXL es totalmente compatible con el cuadro de diálogo de apertura de archivos integrado en Excel; no se requiere ningún visor especial por parte del destinatario.

Estas características de seguridad complementan el modelo de seguridad estándar de .NET Core y resultan especialmente útiles a la hora de crear puntos finales de generación de informes financieros o de recursos humanos. La documentación sobre protección de archivos proporciona la referencia completa de la API.

¿Cómo se trabaja con fórmulas de Excel en .NET?

El motor de cálculo integrado de IronXL evalúa fórmulas estándar de Excel en tiempo de ejecución, por lo que la API puede devolver valores calculados sin necesidad de guardarlos en el disco y volver a abrir el archivo en Excel primero. Asigne una cadena de fórmula a la propiedad .Formula de cualquier celda:

// Sum a column and place the result in a footer row
worksheet[$"B{lastRow}"].Formula = $"=SUM(B2:B{lastRow - 1})";

// Calculate an average across a range
worksheet[$"C{lastRow}"].Formula = $"=AVERAGE(C2:C{lastRow - 1})";

// Retrieve the computed value immediately
decimal total = worksheet[$"B{lastRow}"].DecimalValue;

// Sum a column and place the result in a footer row
worksheet[$"B{lastRow}"].Formula = $"=SUM(B2:B{lastRow - 1})";

// Calculate an average across a range
worksheet[$"C{lastRow}"].Formula = $"=AVERAGE(C2:C{lastRow - 1})";

// Retrieve the computed value immediately
decimal total = worksheet[$"B{lastRow}"].DecimalValue;

' Sum a column and place the result in a footer row
worksheet($"B{lastRow}").Formula = $"=SUM(B2:B{lastRow - 1})"

' Calculate an average across a range
worksheet($"C{lastRow}").Formula = $"=AVERAGE(C2:C{lastRow - 1})"

' Retrieve the computed value immediately
Dim total As Decimal = worksheet($"B{lastRow}").DecimalValue

IronXL es compatible con la mayoría de las funciones estándar de Excel, incluidas las categorías matemáticas, estadísticas, de texto, de fecha y de búsqueda. Las fórmulas de matriz (semántica Ctrl+Shift+Enter) también son compatibles para escenarios avanzados. Dado que la evaluación de fórmulas se realiza dentro del proceso de .NET, no hay ida y vuelta a un servicio de cálculo externo: los resultados están disponibles inmediatamente después de asignar la fórmula, lo que mantiene predecibles los tiempos de respuesta de la API incluso al realizar cálculos en miles de filas. La referencia de fórmulas enumera todas las funciones compatibles.

¿Cuales son tus próximos pasos?

Crear una API de Excel con IronXL proporciona a las aplicaciones de .NET Core sólidas capacidades para trabajar con hojas de cálculo. Desde la creación de archivos XLSX con datos formateados y fórmulas calculadas hasta la importación de archivos subidos por los usuarios y la exportación de datos en múltiples formatos, IronXL gestiona todos los aspectos de la manipulación programática de hojas de cálculo de forma multiplataforma y sin necesidad de Office.

Explora estos recursos para ir más allá:

• Página del producto IronXL: descripción general de las características y guía de introducción
• Documentación de IronXL: referencia completa de la API y artículos prácticos
• Crear archivos Excel en C#: tutorial detallado sobre la creación de libros y hojas de cálculo
• Leer archivos Excel en C#: carga, análisis y extracción de datos
• Exportar Excel a CSV: exportación a CSV con opciones de codificación y delimitador
• API de formato de celdas: fuentes, colores, bordes y formatos numéricos
• Formato condicional: reglas, barras de datos, escalas de color
• Compatibilidad con fórmulas: referencia de funciones de Excel compatibles
• Protección de archivos: API de contraseñas para libros y hojas de cálculo
• Paquete NuGet: versión actual e historial de versiones

Inicie una prueba gratuita para probar IronXL en un proyecto real, o consulte las opciones de licencia para encontrar el plan adecuado para la implementación en producción.