Saltar al pie de página
USANDO IRONXL

Crear una API de Excel para .NET Core: Crear, leer y exportar archivos XLSX

Trabajar con archivos de Excel mediante programación abre poderosas posibilidades para las aplicaciones web del lado del servidor, desde la generación de informes de Excel basados en datos hasta la importación de datos desde hojas de cálculo cargadas por el usuario. IronXL se destaca entre las bibliotecas de API de Excel .NET, ya que proporciona una API de Excel .NET completa que maneja formatos de documentos de Microsoft Excel sin requerir la instalación de Microsoft Office, lo que la hace ideal para incorporar una funcionalidad sólida de Excel en sus aplicaciones .NET Core multiplataforma.

Este tutorial demuestra cómo crear una API de Excel para .NET Core usando IronXL, cubriendo todo, desde la creación de nuevos libros de Excel hasta la lectura de archivos XLSX existentes y la exportación de datos a diferentes formatos. Comience con una prueba gratuita para seguir el proceso.

¿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 biblioteca Excel .NET de IronXL. La API proporciona control completo sobre libros de Excel, hojas de cálculo, estilos de celda y fórmulas a través de un modelo de objetos limpio.

Primero, instale el paquete NuGet IronXL en su proyecto ASP.NET Core:

Install-Package IronXL.Excel

A continuación se muestra una acción de controlador que crea un nuevo libro de Excel con datos formateados, demuestra la administración de hojas de cálculo y aplica estilos de celda para dar formato a las celdas:

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
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");
        // Set headers with cell styles
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Q1 Sales";
        worksheet["C1"].Value = "Q2 Sales";
        worksheet["D1"].Value = "Total";
        // Apply bold formatting to header row
        worksheet["A1:D1"].Style.Font.Bold = true;
        worksheet["A1:D1"].Style.SetBackgroundColor("#4472C4");
        worksheet["A1:D1"].Style.Font.SetColor("#FFFFFF");
        // Add Excel data with number formats
        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 formats to sales columns
        worksheet["B2:D3"].Style.Format = "$#,##0";
        // Save and return the XLSX file
        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
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");
        // Set headers with cell styles
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Q1 Sales";
        worksheet["C1"].Value = "Q2 Sales";
        worksheet["D1"].Value = "Total";
        // Apply bold formatting to header row
        worksheet["A1:D1"].Style.Font.Bold = true;
        worksheet["A1:D1"].Style.SetBackgroundColor("#4472C4");
        worksheet["A1:D1"].Style.Font.SetColor("#FFFFFF");
        // Add Excel data with number formats
        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 formats to sales columns
        worksheet["B2:D3"].Style.Format = "$#,##0";
        // Save and return the XLSX file
        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
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Sales Data")
        ' Set headers with cell styles
        worksheet("A1").Value = "Product"
        worksheet("B1").Value = "Q1 Sales"
        worksheet("C1").Value = "Q2 Sales"
        worksheet("D1").Value = "Total"
        ' Apply bold formatting to header row
        worksheet("A1:D1").Style.Font.Bold = True
        worksheet("A1:D1").Style.SetBackgroundColor("#4472C4")
        worksheet("A1:D1").Style.Font.SetColor("#FFFFFF")
        ' Add Excel data with number formats
        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 formats to sales columns
        worksheet("B2:D3").Style.Format = "$#,##0"
        ' Save and return the XLSX file
        Dim stream = workbook.ToStream()
        Return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "SalesReport.xlsx")
    End Function
End Class
$vbLabelText   $csharpLabel

Archivo de Excel de salida

¡ Crea una API de Excel para .NET Core: Crea, lee y exporta archivos XLSX! Imagen 1: Archivo de Excel generado por nuestra API de .NET Core.

Este código crea un nuevo libro de Excel utilizando WorkBook.Create(), que admite los formatos XLSX y XLS. El método CreateWorkSheet() agrega hojas de cálculo de Excel donde puede completar celdas de la hoja de cálculo con valores, crear fórmulas para cálculos complejos y organizar datos en tablas de Excel y tablas de datos. Puede administrar fácilmente columnas de tablas, crear fórmulas y aplicar estilos de celdas, incluidas fuentes, colores y formatos de números. El motor de cálculo de IronXL evalúa automáticamente las fórmulas cuando cambian los datos del libro de trabajo y admite fórmulas avanzadas de Microsoft Excel, incluido soporte de fórmulas matriciales para el análisis de datos complejos.

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

La importación de datos de archivos Excel cargados por el usuario es esencial para las aplicaciones web que procesan contenido de hojas de cálculo. IronXL facilita la lectura de hojas de cálculo de Excel, permitiéndole ordenar datos o filtrarlos según criterios personalizados, ya sea trabajando con archivos XLSX, XLS o formatos CSV.

[HttpPost("import")]
public IActionResult ImportExcelData(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");
    using var stream = file.OpenReadStream();
    WorkBook workbook = WorkBook.Load(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;
    var records = new List<Dictionary<string, object>>();
    // Read cell range starting from row 2 (skip headers)
    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();
    WorkBook workbook = WorkBook.Load(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;
    var records = new List<Dictionary<string, object>>();
    // Read cell range starting from row 2 (skip headers)
    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()
        Dim workbook As WorkBook = WorkBook.Load(stream)
        Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
        Dim records As New List(Of Dictionary(Of String, Object))()

        ' Read cell range starting from row 2 (skip headers)
        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
$vbLabelText   $csharpLabel

Resultado

¡ Crea una API de Excel para .NET Core: Crea, lee y exporta archivos XLSX! Imagen 2: Salida que muestra los datos de Excel importados correctamente.

El método WorkBook.Load() abre archivos de Excel desde secuencias, rutas de archivos o matrices de bytes, lo que permite a los usuarios importar datos desde archivos externos cargados a través de su API. Puede acceder a valores de celdas individuales utilizando la sintaxis intuitiva worksheet["A1"] o iterar a través de un rango de celdas. IronXL maneja la validación de datos automáticamente y proporciona accesores de tipo seguro como IntValue, DecimalValue y DateTimeValue para una extracción de datos confiable de las celdas de la hoja de cálculo.

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

Las aplicaciones modernas a menudo necesitan exportar hojas de cálculo a múltiples formatos para generar informes interactivos y realizar un seguimiento del rendimiento. IronXL admite la exportación de datos a XLSX, XLS, CSV, JSON y HTML, lo que facilita la presentación de datos en diferentes páginas web y varios formatos de imagen.

[HttpGet("export/{format}")]
public IActionResult ExportData(string format)
{
    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)
{
    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
    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
$vbLabelText   $csharpLabel

El uso de plantillas de Excel con diseños predefinidos acelera la generación de informes al permitirle cargar hojas de cálculo prediseñadas y completarlas con datos dinámicos del libro de trabajo. Este enfoque funciona especialmente bien para informes de ventas, facturas e informes de Excel basados en datos donde es importante mantener un formato consistente. El soporte multiplataforma de IronXL significa que estas operaciones de archivos funcionan de manera idéntica en Windows, Linux y macOS, perfecto para implementaciones de .NET Core y .NET Framework.

Conclusión

La creación de una API de Excel con IronXL proporciona a sus aplicaciones .NET Core potentes capacidades para trabajar con documentos de Excel. Desde la creación de archivos XLSX con datos formateados y fórmulas complejas hasta la importación de cargas de usuarios y la exportación de datos a múltiples formatos, la API de Excel .NET de IronXL simplifica cada aspecto de la manipulación de hojas de cálculo.

La biblioteca maneja funciones avanzadas como barras de datos, reglas de formato condicional, gráficos de líneas y gráficos dinámicos de manera eficiente. Para aplicaciones profesionales, también proporciona protección con contraseña, firmas digitales y controles de formulario para garantizar que sus informes XLSX e informes .NET Excel sean seguros y funcionales. Incluso al manejar hojas de cálculo grandes, IronXL mantiene un alto rendimiento sin dependencias de Microsoft Office.

¿Está listo para agregar la funcionalidad de Excel a sus aplicaciones .NET? Explore las opciones de licencia o comience su prueba gratuita para experimentar todas las capacidades de esta poderosa biblioteca .NET Excel.

Preguntas Frecuentes

¿Qué es IronXL?

IronXL es una biblioteca API de Excel .NET que permite a los desarrolladores crear, leer y exportar archivos de Excel mediante programación sin necesidad de tener instalado Microsoft Office.

¿Cómo puede IronXL beneficiar a las aplicaciones .NET Core?

IronXL proporciona una API de Excel completa para aplicaciones .NET Core, lo que permite a los desarrolladores integrar la funcionalidad de Excel, como generar informes e importar datos, sin depender de Microsoft Office.

¿Necesito tener instalado Microsoft Office para usar IronXL?

No, IronXL no requiere la instalación de Microsoft Office para manejar formatos de documentos de Excel, lo que lo hace conveniente para aplicaciones del lado del servidor.

¿Puede IronXL manejar archivos XLSX?

Sí, IronXL puede crear, leer y exportar archivos XLSX, lo que permite una gestión integral de archivos Excel dentro de aplicaciones .NET Core.

¿Qué tipos de aplicaciones pueden beneficiarse del uso de IronXL?

Las aplicaciones web del lado del servidor que requieren informes de Excel basados en datos o necesitan importar datos de hojas de cálculo cargadas por el usuario pueden beneficiarse enormemente del uso de IronXL.

¿IronXL es adecuado para aplicaciones .NET Core multiplataforma?

Sí, IronXL está diseñado para uso multiplataforma, lo que lo hace ideal para integrar la funcionalidad de Excel en aplicaciones .NET Core en diferentes sistemas operativos.

Jordi Bardia
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