Como importar, ler e manipular dados do Excel em C#

Por que StreamReader não pode ler arquivos Excel?

StreamReader é projetado para arquivos de texto simples, lendo dados de caracteres linha por linha usando uma codificação especificada. Os arquivos Excel, apesar de sua aparência de planilha, são na verdade estruturas binárias complexas ou XML comprimidas em ZIP que StreamReader não pode interpretar. Arquivos XLSX modernos seguem o padrão Open XML do Office, enquanto arquivos XLS antigos usam um formato binário proprietário.

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
 }
}

Sub Main(ByVal args As String())
    ' This code will NOT work - demonstrates the problem
    Using reader As New StreamReader("ProductData.xlsx")
        Dim content As String = reader.ReadLine() ' Attempts to read Excel as text
        Console.WriteLine(content) ' Outputs garbled binary data
    End Using
End Sub

Quando você executa este trecho de código, em vez de ver os dados da sua planilha, você encontrará dados binários, como "PK♥♦" ou caracteres semelhantes. Isso acontece porque arquivos XLSX são arquivos ZIP contendo múltiplos arquivos XML, enquanto arquivos XLS usam um formato binário proprietário. StreamReader espera texto simples e tenta interpretar essas estruturas complexas como caracteres, resultando em uma saída sem sentido. Para aplicações containerizadas, tentar usar bibliotecas nativas do Excel ou COM Interop requereria a instalação do Microsoft Office no seu contêiner, aumentando drasticamente o tamanho e a complexidade da imagem.

Como Ler Arquivos Excel com IronXL?

IronXL fornece uma solução direta para ler arquivos Excel em C#. Ao contrário de StreamReader, o IronXL entende a estrutura interna do Excel e fornece métodos intuitivos para acessar seus dados. A biblioteca suporta Windows, Linux, macOS e contêineres Docker, tornando-a perfeita para aplicações modernas e multiplataforma. Para equipes de DevOps, a arquitetura sem dependências do IronXL significa que não há bibliotecas nativas ou componentes COM para gerenciar durante a implantação.

Primeiro, instale IronXL via o Gerenciador de Pacotes NuGet:

Install-Package IronXL.Excel

Aqui está como ler um arquivo Excel corretamente:

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}");
}

Imports IronXL

' Load the Excel file
Dim workbook As WorkBook = WorkBook.Load("sample.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Read specific cell values
Dim cellValue As String = worksheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")
' Read a range of cells
For Each cell In worksheet("A1:C5")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

Este código carrega seu arquivo Excel com sucesso e fornece acesso limpo aos valores das células. O método WorkBook.Load detecta automaticamente o formato do arquivo (XLSX, XLS, XLSM, CSV) e lida com toda a análise complexa internamente. Você pode acessar células usando a notação familiar do Excel como "A1" ou intervalos como "A1:C5", tornando o código intuitivo para qualquer pessoa familiarizada com o Excel.

Para implantações containerizadas, você pode facilmente incluir endpoints de verificação de integridade que verificam as capacidades de processamento do 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 
        });
    }
}

Imports System
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

' Health check endpoint for containerized apps
Public Async Function HealthCheck() As Task(Of IActionResult)
    Try
        ' Test Excel functionality
        Using workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            Dim sheet = workbook.CreateWorkSheet("HealthCheck")
            sheet("A1").Value = DateTime.UtcNow

            ' Convert to byte array for validation
            Dim bytes = workbook.ToByteArray()
            Return Ok(New With {
                .status = "healthy",
                .excelSupport = True,
                .timestamp = DateTime.UtcNow
            })
        End Using
    Catch ex As Exception
        Return StatusCode(503, New With {
            .status = "unhealthy",
            .error = ex.Message
        })
    End Try
End Function

Como Ler Excel a Partir de Fluxos de Memória?

Aplicações do mundo real frequentemente precisam processar arquivos Excel de fluxos ao invés de arquivos de disco. Cenários comuns incluem lidar com uploads na web, recuperar arquivos de bancos de dados ou processar dados de armazenamento em nuvem como AWS S3 ou Azure Blob Storage. IronXL lida com essas situações de forma tranquila:

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");
}

Imports IronXL
Imports System.IO

' Read Excel from a memory stream
Dim fileBytes As Byte() = File.ReadAllBytes("ProductData.xlsx")
Using stream As New MemoryStream(fileBytes)
    Dim workbook As WorkBook = WorkBook.FromStream(stream)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
    ' Process the data
    Dim rowCount As Integer = worksheet.RowCount
    Console.WriteLine($"The worksheet has {rowCount} rows")
    ' Read all data into a DataTable
    Dim dataTable = worksheet.ToDataTable(False)
    ' Display DataTable row count 
    Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows")
End Using

O método FromStream aceita qualquer tipo de stream, seja um MemoryStream, FileStream ou stream de rede. Essa flexibilidade permite processar arquivos Excel de várias fontes sem salvá-los no disco primeiro. O exemplo também demonstra converter dados de planilha em um DataTable, que se integra perfeitamente com bancos de dados e cenários de vinculação de dados. Para arquiteturas de microsserviços, essa abordagem baseada em fluxo minimiza o I/O de disco e melhora o desempenho.

[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
    });
}

Imports System.IO
Imports Microsoft.AspNetCore.Mvc

<HttpPost("upload")>
Public Async Function ProcessExcelUpload(file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file uploaded")
    End If

    Using stream As New MemoryStream()
        Await file.CopyToAsync(stream)
        stream.Position = 0

        Dim workbook = WorkBook.FromStream(stream)
        Dim worksheet = workbook.DefaultWorkSheet

        ' Process and return results
        Dim data = worksheet.ToDataSet()
        Return Ok(New With {
            .sheets = workbook.WorkSheets.Count,
            .rows = worksheet.RowCount,
            .processed = DateTime.UtcNow
        })
    End Using
End Function

Como Converter Entre Excel e CSV?

Embora StreamReader possa lidar com arquivos CSV, muitas vezes você precisa converter entre formatos Excel e CSV. O IronXL torna essa conversão direta, o que é particularmente útil para pipelines ETL e cenários de integração de dados comuns em fluxos de trabalho 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");

Imports IronXL

' Load an Excel file and save as CSV
Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
workbook.SaveAsCsv("output.csv")

' Load a CSV file and save as Excel
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("input.csv")
csvWorkbook.SaveAs("output.xlsx")

' Export specific worksheet to CSV
Dim worksheet As WorkSheet = workbook.WorkSheets(0)
worksheet.SaveAsCsv("worksheet1.csv")

Essas conversões preservam seus dados enquanto mudam o formato do arquivo. Ao converter Excel para CSV, IronXL achata a primeira planilha por padrão, mas você pode especificar qual planilha exportar. Converter de CSV para Excel cria uma planilha formatada adequadamente que preserva tipos de dados e permite futuras formatações e adições de fórmulas.

Para pipelines de dados automatizados, você também pode exportar para formatos JSON ou 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();

' Export Excel to multiple formats for data pipelines
Dim workbook = WorkBook.Load("report.xlsx")

' Export to JSON for API responses
Dim jsonData As String = 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
Dim dataTable = workbook.DefaultWorkSheet("A1:D10").ToDataTable()

Práticas Recomendadas para Implementação em Contêiner

Para engenheiros de DevOps que implantam aplicações de processamento de Excel, o IronXL oferece várias vantagens. Aqui está um Dockerfile pronto para produção otimizado para processamento 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 garante que seu aplicativo de processamento de Excel funcione perfeitamente em contêineres com poucas dependências. O licenciamento é tratado através de variáveis de ambiente, tornando fácil gerenciar em diferentes ambientes de implantação.

Quais são os próximos passos para o processamento de Excel em C#?

A incapacidade de StreamReader de processar arquivos Excel decorre da diferença fundamental entre texto simples e a complexa estrutura de arquivos do Excel. Embora StreamReader funcione perfeitamente para CSV e outros formatos de texto, arquivos Excel verdadeiros exigem uma biblioteca especializada como o IronXL, que entende as estruturas binárias e XML internas.

IronXL oferece uma solução abrangente com sua API intuitiva, suporte extenso a formatos e capacidades de processamento de fluxo impecáveis. Seja você desenvolvendo aplicativos web, software de desktop, ou serviços em nuvem, IronXL lida com arquivos Excel de forma confiável em todas as plataformas. O suporte da biblioteca a formatação condicional, gráficos, fórmulas, e recursos avançados do Excel a torna uma solução completa para aplicativos empresariais.

Para equipes de DevOps, a arquitetura amigável a contêineres do IronXL, as dependências mínimas do sistema e as sólidas características de desempenho o tornam uma escolha ideal para aplicações modernas nativas de nuvem. A biblioteca suporta escalabilidade horizontal, funciona perfeitamente em pods Kubernetes, e se integra bem com pipelines CI/CD.

Pronto para começar a trabalhar adequadamente com arquivos Excel? Baixe o teste gratuito do IronXL que melhor se adequa às necessidades do seu projeto. A biblioteca oferece opções de licenciamento flexíveis, incluindo desenvolvimento, produção, e implantação de staging, com opções para ambientes conteinerizados e aplicativos nativos em nuvem.