Cómo importar, leer y manipular datos de Excel en C#

¿Por qué StreamReader no puede leer archivos de Excel?

StreamReader está diseñado para archivos de texto sin formato, leyendo datos de caracteres línea por línea utilizando una codificación especificada. Los archivos Excel, a pesar de su apariencia de hoja de cálculo, son en realidad estructuras XML binarias o comprimidas en ZIP complejas que StreamReader no puede interpretar. Los archivos XLSX modernos siguen el estándar Office Open XML, mientras que los archivos XLS más antiguos utilizan un formato binario propietario.

static void Main(string[] args)
{
 // This code will NOT work - demonstrates the problem
 using (StreamReader reader = new StreamReader("ProductData.xlsx"))
 {
    string content = reader.ReadLine(); // Attempts to read Excel as text
    Console.WriteLine(content); // Outputs garbled binary data
 }
}

static void Main(string[] args)
{
 // This code will NOT work - demonstrates the problem
 using (StreamReader reader = new StreamReader("ProductData.xlsx"))
 {
    string content = reader.ReadLine(); // Attempts to read Excel as text
    Console.WriteLine(content); // Outputs garbled binary data
 }
}

Al ejecutar este fragmento de código, en lugar de ver los datos de la hoja de cálculo, aparecerán datos binarios, como "PK♥♦" o caracteres similares. Esto sucede porque los archivos XLSX son archivos ZIP que contienen múltiples archivos XML, mientras que los archivos XLS utilizan un formato binario propietario. StreamReader espera texto sin formato e intenta interpretar estas estructuras complejas como caracteres, lo que da lugar a un resultado sin sentido. En el caso de las aplicaciones en contenedores, intentar utilizar bibliotecas nativas de Excel o COM Interop requeriría instalar Microsoft Office en el contenedor, lo que aumentaría drásticamente el tamaño y la complejidad de la imagen.

¿Cómo leer archivos de Excel con IronXL?

IronXL ofrece una solución sencilla para leer archivos de Excel en C#. A diferencia de StreamReader, IronXL comprende la estructura interna de Excel y ofrece métodos intuitivos para acceder a sus datos. La biblioteca es compatible con Windows, Linux, macOS y contenedores Docker, lo que la hace perfecta para aplicaciones modernas y multiplataforma. Para los equipos de DevOps, la arquitectura sin dependencias de IronXL significa que no hay que gestionar bibliotecas nativas ni componentes COM durante la implementación.

Primero, instala IronXL a través del Administrador de Paquetes NuGet:

Install-Package IronXL.Excel

A continuación se explica cómo leer correctamente un archivo de Excel:

using IronXL;
// Load the Excel file
WorkBook workbook = WorkBook.Load("sample.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Read specific cell values
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");
// Read a range of cells
foreach (var cell in worksheet["A1:C5"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

using IronXL;
// Load the Excel file
WorkBook workbook = WorkBook.Load("sample.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Read specific cell values
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");
// Read a range of cells
foreach (var cell in worksheet["A1:C5"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

Este código carga correctamente tu archivo de Excel y proporciona un acceso limpio a los valores de las celdas. El método WorkBook.Load detecta automáticamente el formato de archivo (XLSX, XLS, XLSM, CSV) y gestiona internamente todo el análisis sintáctico complejo. Se puede acceder a las celdas utilizando la notación habitual de Excel, como "A1", o rangos como "A1:C5", lo que hace que el código resulte intuitivo para cualquiera que esté familiarizado con Excel.

Para implementaciones en contenedores, puede incluir fácilmente puntos finales de comprobación de estado que verifiquen las capacidades de procesamiento de Excel:

// Health check endpoint for containerized apps
public async Task<IActionResult> HealthCheck()
{
    try
    {
        // Test Excel functionality
        using var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var sheet = workbook.CreateWorkSheet("HealthCheck");
        sheet["A1"].Value = DateTime.UtcNow;

        // Convert to byte array for validation
        var bytes = workbook.ToByteArray();
        return Ok(new { 
            status = "healthy", 
            excelSupport = true,
            timestamp = DateTime.UtcNow 
        });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { 
            status = "unhealthy", 
            error = ex.Message 
        });
    }
}

// Health check endpoint for containerized apps
public async Task<IActionResult> HealthCheck()
{
    try
    {
        // Test Excel functionality
        using var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var sheet = workbook.CreateWorkSheet("HealthCheck");
        sheet["A1"].Value = DateTime.UtcNow;

        // Convert to byte array for validation
        var bytes = workbook.ToByteArray();
        return Ok(new { 
            status = "healthy", 
            excelSupport = true,
            timestamp = DateTime.UtcNow 
        });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { 
            status = "unhealthy", 
            error = ex.Message 
        });
    }
}

¿Cómo leer Excel desde flujos de memoria?

Las aplicaciones del mundo real a menudo necesitan procesar archivos de Excel desde flujos en lugar de archivos de disco. Entre los escenarios habituales se incluyen la gestión de cargas web, la recuperación de archivos de bases de datos o el procesamiento de datos de almacenamiento en la nube, como AWS S3 o Azure Blob Storage. IronXL gestiona estas situaciones a la perfección:

using IronXL;
using System.IO;
// Read Excel from a memory stream
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");
using (MemoryStream stream = new MemoryStream(fileBytes))
{
    WorkBook workbook = WorkBook.FromStream(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;
    // Process the data
    int rowCount = worksheet.RowCount;
    Console.WriteLine($"The worksheet has {rowCount} rows");
    // Read all data into a DataTable
    var dataTable = worksheet.ToDataTable(false);
    // Display DataTable row count 
    Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");
}

using IronXL;
using System.IO;
// Read Excel from a memory stream
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");
using (MemoryStream stream = new MemoryStream(fileBytes))
{
    WorkBook workbook = WorkBook.FromStream(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;
    // Process the data
    int rowCount = worksheet.RowCount;
    Console.WriteLine($"The worksheet has {rowCount} rows");
    // Read all data into a DataTable
    var dataTable = worksheet.ToDataTable(false);
    // Display DataTable row count 
    Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");
}

El método FromStream acepta cualquier tipo de flujo, ya sea un MemoryStream, un FileStream o un flujo de red. Esta flexibilidad le permite procesar archivos de Excel de diversas fuentes sin necesidad de guardarlos primero en el disco. El ejemplo también muestra cómo convertir datos de hojas de cálculo a una DataTable, que se integra a la perfección con bases de datos y escenarios de enlace de datos. En el caso de las arquitecturas de microservicios, este enfoque basado en flujos minimiza la E/S de disco y mejora el rendimiento.

[HttpPost("upload")]
public async Task<IActionResult> ProcessExcelUpload(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");

    using var stream = new MemoryStream();
    await file.CopyToAsync(stream);
    stream.Position = 0;

    var workbook = WorkBook.FromStream(stream);
    var worksheet = workbook.DefaultWorkSheet;

    // Process and return results
    var data = worksheet.ToDataSet();
    return Ok(new { 
        sheets = workbook.WorkSheets.Count,
        rows = worksheet.RowCount,
        processed = DateTime.UtcNow
    });
}

[HttpPost("upload")]
public async Task<IActionResult> ProcessExcelUpload(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");

    using var stream = new MemoryStream();
    await file.CopyToAsync(stream);
    stream.Position = 0;

    var workbook = WorkBook.FromStream(stream);
    var worksheet = workbook.DefaultWorkSheet;

    // Process and return results
    var data = worksheet.ToDataSet();
    return Ok(new { 
        sheets = workbook.WorkSheets.Count,
        rows = worksheet.RowCount,
        processed = DateTime.UtcNow
    });
}

¿Cómo convertir entre Excel y CSV?

Aunque StreamReader puede gestionar archivos CSV, a menudo es necesario convertir entre los formatos Excel y CSV. IronXL simplifica esta conversión, lo que resulta especialmente útil para los flujos de trabajo de ETL y los escenarios de integración de datos habituales en los flujos de trabajo de DevOps:

using IronXL;
// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("data.xlsx");
workbook.SaveAsCsv("output.csv");
// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("input.csv");
csvWorkbook.SaveAs("output.xlsx");
// Export specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("worksheet1.csv");

using IronXL;
// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("data.xlsx");
workbook.SaveAsCsv("output.csv");
// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("input.csv");
csvWorkbook.SaveAs("output.xlsx");
// Export specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("worksheet1.csv");

Estas conversiones preservan tus datos mientras cambian el formato de archivo. Al convertir Excel a CSV, IronXL aplana la primera hoja de cálculo de forma predeterminada, pero puedes especificar qué hoja de cálculo exportar. La conversión de CSV a Excel crea una hoja de cálculo con el formato adecuado que conserva los tipos de datos y permite realizar cambios de formato y añadir fórmulas en el futuro.

Para los flujos de datos automatizados, también puede exportar a formatos JSON o XML:

// Export Excel to multiple formats for data pipelines
var workbook = WorkBook.Load("report.xlsx");

// Export to JSON for API responses
string jsonData = workbook.ToJson();

// Export to HTML for web display
workbook.SaveAsHtml("report.html");

// Export to XML for integration systems
workbook.SaveAsXml("report.xml");

// Export specific range to DataTable for database insertion
var dataTable = workbook.DefaultWorkSheet["A1:D10"].ToDataTable();

// Export Excel to multiple formats for data pipelines
var workbook = WorkBook.Load("report.xlsx");

// Export to JSON for API responses
string jsonData = workbook.ToJson();

// Export to HTML for web display
workbook.SaveAsHtml("report.html");

// Export to XML for integration systems
workbook.SaveAsXml("report.xml");

// Export specific range to DataTable for database insertion
var dataTable = workbook.DefaultWorkSheet["A1:D10"].ToDataTable();

Prácticas recomendadas para la implementación de contenedores

Para los ingenieros que implementan aplicaciones de procesamiento de Excel, IronXL ofrece varias ventajas. Aquí tienes un archivo Dockerfile listo para producción y optimizado para el procesamiento de Excel:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

# Install any required system fonts for Excel rendering
RUN apt-get update && apt-get install -y \
    fontconfig \
    libfreetype6 \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["YourApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build

FROM build AS publish
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .

# Set environment variables for IronXL
ENV IRONXL_LICENSE_KEY=${IRONXL_LICENSE_KEY}
ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=false

ENTRYPOINT ["dotnet", "YourApp.dll"]

Este Dockerfile garantiza que tu aplicación de procesamiento de Excel se ejecute sin problemas en contenedores con un mínimo de dependencias. La gestión de las licencias se realiza a través de variables de entorno, lo que facilita su administración en diferentes entornos de implementación.

¿Cuáles son los próximos pasos para el procesamiento de Excel en C#?

La incapacidad de StreamReader para procesar archivos de Excel se debe a la diferencia fundamental entre el texto sin formato y la compleja estructura de archivos de Excel. Aunque StreamReader funciona perfectamente con CSV y otros formatos de texto, los archivos Excel auténticos requieren una biblioteca especializada como IronXL que comprenda las estructuras binarias y XML que contienen.

IronXL ofrece una solución integral con su API intuitiva, su amplia compatibilidad con formatos y sus capacidades de procesamiento de flujos sin interrupciones. Tanto si estás creando aplicaciones web, software de escritorio o servicios en la nube, IronXL gestiona archivos de Excel de forma fiable en todas las plataformas. La compatibilidad de la biblioteca con el formato condicional, los gráficos, las fórmulas y las funciones avanzadas de Excel la convierte en una solución completa para aplicaciones Enterprise.

Para los equipos de DevOps, la arquitectura compatible con contenedores de IronXL, sus mínimas dependencias del sistema y sus sólidas características de rendimiento lo convierten en la opción ideal para las aplicaciones modernas nativas de la nube. La biblioteca admite el escalado horizontal, funciona a la perfección en pods de Kubernetes y se integra bien con los procesos de CI/CD.

¿Listo para empezar a trabajar con archivos de Excel correctamente? Descarga la versión de prueba gratuita de IronXL que mejor se adapte a las necesidades de tu proyecto. La biblioteca ofrece opciones de licencia flexibles que incluyen implementaciones de desarrollo, staging y producción, con opciones para entornos en contenedores y aplicaciones nativas de la nube.