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 de Excel, a pesar de su apariencia de hoja de cálculo, son en realidad complejas estructuras XML binarias o comprimidas en ZIP 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
 }
}

Cuando ejecuta este fragmento de código, en lugar de ver los datos de su hoja de cálculo, encontrará 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 y trata de interpretar estas estructuras complejas como caracteres, lo que resulta en una salida sin sentido. Para aplicaciones en contenedores, intentar usar bibliotecas nativas de Excel o interoperabilidad COM 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 proporciona una solución sencilla para leer archivos Excel en C#. A diferencia de StreamReader, IronXL entiende la estructura interna de Excel y proporciona métodos intuitivos para acceder a sus datos. La biblioteca admite contenedores de Windows, Linux, macOS y Docker , lo que la hace perfecta para aplicaciones modernas y multiplataforma. Para los equipos DevOps , la arquitectura de dependencia cero de IronXL significa que no hay bibliotecas nativas ni componentes COM que administrar durante la implementación.

Diagrama de compatibilidad multiplataforma que muestra la compatibilidad de .NET en diversas versiones, sistemas operativos, entornos de desarrollo y plataformas en la nube, como Windows, Linux, macOS, Docker, Azure y AWS.

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

Install-Package IronXL.Excel

Salida de terminal que muestra la instalación exitosa del paquete IronXL.Excel y sus dependencias mediante la Consola del Administrador de paquetes en Visual Studio.

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

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 con éxito su archivo de Excel y proporciona 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 maneja todo el análisis complejo internamente. Puede acceder a las celdas utilizando la notación familiar de Excel como "A1" o rangos como "A1:C5", lo que hace que el código sea intuitivo para cualquier persona familiarizada con Excel.

Para implementaciones en contenedores, puede incluir fácilmente puntos finales de verificació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. Los escenarios comunes incluyen el manejo de cargas web, la recuperación de archivos de bases de datos o el procesamiento de datos del almacenamiento en la nube como AWS S3 o Azure Blob Storage . IronXL gestiona estas situaciones sin problemas:

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 WorkBook . FromStream acepta cualquier tipo de flujo, ya sea MemoryStream , FileStream o un flujo de red. Esta flexibilidad permite procesar archivos de Excel de diversas fuentes sin tener que guardarlos primero en el disco. El ejemplo también muestra la conversión de datos de una hoja de cálculo a una DataTable , que se integra perfectamente con bases de datos y escenarios de enlace de datos. Para 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?

Si bien StreamReader puede manejar archivos CSV, a menudo es necesario convertir entre formatos Excel y CSV . IronXL hace que esta conversión sea sencilla, lo que resulta particularmente útil para las canalizaciones ETL y los escenarios de integración de datos comunes en los flujos de trabajo 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 puede especificar qué hoja de cálculo exportar. La conversión de CSV a Excel crea una hoja de cálculo con el formato correcto que conserva los tipos de datos y permite futuras incorporaciones de formato y fórmulas .

Para canalizaciones de datos automatizadas, 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();

Mejores prácticas para la implementación de contenedores

Para los ingenieros DevOps que implementan aplicaciones de procesamiento de Excel, IronXL ofrece varias ventajas. Aquí hay un 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 su aplicación de procesamiento de Excel se ejecute sin problemas en contenedores con dependencias mínimas. La licencia se gestiona 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. Mientras que StreamReader funciona perfectamente para CSV y otros formatos de texto, los verdaderos archivos de Excel requieren una biblioteca especializada como IronXL que entienda las estructuras binarias y XML que contienen.

IronXL ofrece una solución integral con su API intuitiva, amplio soporte de formatos y capacidades de procesamiento de transmisión perfectas. Ya sea que esté creando aplicaciones web , software de escritorio o servicios en la nube, IronXL maneja archivos Excel de manera confiable en todas las plataformas. El soporte de la biblioteca para formato condicional , gráficos , fórmulas y funciones avanzadas de Excel la convierte en una solución completa para aplicaciones empresariales.

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

Página de licencias de IronXL con cuatro niveles de precios (Lite, Plus, Professional e Unlimited) con opción de alternar entre IronXL e Iron Suite, y precios de licencia perpetua que van desde $749 hasta $3,999.

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