Como ler arquivos do Excel em C# em vez de usar StreamReader

Por Que o Leitor de fluxo Não Pode Ler Arquivos Excel?

Leitor de fluxo é um leitor baseado em texto. Ele lê dados de caracteres linha por linha usando uma codificação especificada (UTF-8, ASCII, etc.) e não tem consciência de estruturas binárias ou arquivos compactados. A documentação oficial do Leitor de fluxo do .NET confirma que esta classe é projetada exclusivamente para texto codificado por caracteres. Os arquivos do Excel, apesar de parecerem planilhas simples, são na verdade estruturas complexas de XML compactadas em formato binário ou ZIP que o Leitor de fluxo não consegue interpretar.

Ao abrir um arquivo XLSX com Leitor de fluxo, você está essencialmente tentando ler um arquivo ZIP como texto simples. O resultado é um fluxo de ruído binário em vez de dados de sua planilha.

// This code will NOT work -- demonstrates the problem
using Leitor de fluxo reader = new Leitor de fluxo("ProductData.xlsx");
string content = reader.ReadLine();
Console.WriteLine(content); // Outputs garbled binary data like "PK♥♦"

// This code will NOT work -- demonstrates the problem
using Leitor de fluxo reader = new Leitor de fluxo("ProductData.xlsx");
string content = reader.ReadLine();
Console.WriteLine(content); // Outputs garbled binary data like "PK♥♦"

Ao executar este trecho de código, em vez de visualizar as linhas da sua planilha, você encontrará caracteres binários como PK♥♦ ou ruídos semelhantes. Isso ocorre porque:

• Arquivos XLSX são arquivos ZIP contendo múltiplos arquivos XML: planilhas, estilos, cadeias compartilhadas, relacionamentos. A documentação do Open XML SDK fornece uma descrição detalhada dessa estrutura.
• Arquivos XLS usam um formato proprietário binário (BIFF -- Binary Interchange Formato de Arquivo)
• Leitor de fluxo aplica uma codificação de caracteres a quaisquer bytes que lê, produzindo uma saída sem sentido para ambos os formatos.

Como instalar o IronXL em um projeto .NET?

IronXL é uma biblioteca .NET que lê, escreve e cria arquivos Excel sem exigir que o Microsoft Excel esteja instalado. Ele suporta formatos XLSX, XLS, XLSM, CSV e TSV, e é executado no Windows, Linux, macOS e containers Docker.

Para instalar o IronXL, use o Console do Gerenciador de Pacotes NuGet ou a CLI do .NET. O pacote é publicado no NuGet.org como IronXL:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Após a instalação, adicione a diretiva using IronXL; ao seu arquivo e você estará pronto para trabalhar com documentos do Excel.

! Alternativa para ler arquivos Excel usando Leitor de fluxo em C# - IronXL: Imagem 5 - Instalação

Para obter instruções detalhadas de instalação e opções de configuração do NuGet , consulte o guia de instalação do NuGet do IronXL . Uma licença de teste gratuita está disponível para que você possa avaliar o IronXL em seu projeto antes de comprar.

! Alternativa para ler arquivos Excel usando Leitor de fluxo em C# - IronXL: Imagem 4 - Multiplataforma

Como Ler Arquivos Excel com o IronXL?

IronXL fornece uma API intuitiva para ler arquivos Excel em C#. Ao contrário do Leitor de fluxo, o IronXL entende a estrutura interna do Excel e oferece acesso claro a linhas, colunas e valores de células. A documentação do IronXL fornece referências completas da API para todas as operações suportadas.

Veja como ler um arquivo Excel usando o IronXL com instruções de nível superior:

using IronXL;

// Load the Excel file from disk
WorkBook workbook = WorkBook.Load("ProductData.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Read a specific cell by address
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Iterate over a range of cells
foreach (var cell in worksheet["A1:C10"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Read a numeric value
decimal price = worksheet["B2"].DecimalValue;
Console.WriteLine($"Price: {price:C}");

using IronXL;

// Load the Excel file from disk
WorkBook workbook = WorkBook.Load("ProductData.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Read a specific cell by address
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Iterate over a range of cells
foreach (var cell in worksheet["A1:C10"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Read a numeric value
decimal price = worksheet["B2"].DecimalValue;
Console.WriteLine($"Price: {price:C}");

Imports IronXL

' Load the Excel file from disk
Dim workbook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Read a specific cell by address
Dim cellValue As String = worksheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")

' Iterate over a range of cells
For Each cell In worksheet("A1:C10")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

' Read a numeric value
Dim price As Decimal = worksheet("B2").DecimalValue
Console.WriteLine($"Price: {price:C}")

O método WorkBook.Load detecta automaticamente o formato do arquivo (XLSX, XLS, XLSM, CSV) e lida com toda a análise complexa. Você acessa as células usando a notação padrão do Excel, como "A1" ou intervalos como "A1:C10", o que torna o código imediatamente legível para qualquer pessoa familiarizada com planilhas.

using IronXL;

WorkBook workbook = WorkBook.Load("MultiSheet.xlsx");

// List all worksheets
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}");
}

// Access a sheet by name
WorkSheet summary = workbook.GetWorkSheet("Summary");
string totalRevenue = summary["B20"].StringValue;
Console.WriteLine($"Total Revenue: {totalRevenue}");

// Access a sheet by index
WorkSheet firstSheet = workbook.WorkSheets[0];
int lastRow = firstSheet.RowCount;
Console.WriteLine($"Last row in first sheet: {lastRow}");

using IronXL;

WorkBook workbook = WorkBook.Load("MultiSheet.xlsx");

// List all worksheets
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}");
}

// Access a sheet by name
WorkSheet summary = workbook.GetWorkSheet("Summary");
string totalRevenue = summary["B20"].StringValue;
Console.WriteLine($"Total Revenue: {totalRevenue}");

// Access a sheet by index
WorkSheet firstSheet = workbook.WorkSheets[0];
int lastRow = firstSheet.RowCount;
Console.WriteLine($"Last row in first sheet: {lastRow}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("MultiSheet.xlsx")

' List all worksheets
For Each sheet As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}")
Next

' Access a sheet by name
Dim summary As WorkSheet = workbook.GetWorkSheet("Summary")
Dim totalRevenue As String = summary("B20").StringValue
Console.WriteLine($"Total Revenue: {totalRevenue}")

' Access a sheet by index
Dim firstSheet As WorkSheet = workbook.WorkSheets(0)
Dim lastRow As Integer = firstSheet.RowCount
Console.WriteLine($"Last row in first sheet: {lastRow}")

Como Ler Dados do Excel a partir de um Fluxo de Memória?

Aplicações do mundo real frequentemente precisam processar arquivos Excel de fluxos ao invés de arquivos de disco. Os cenários comuns incluem lidar com carregamento de arquivos de formulários web, recuperar livros de trabalho de uma coluna BLOB de banco de dados ou processar arquivos baixados do armazenamento em nuvem (Azure Blob Storage, AWS S3). IronXL lida com esses cenários através de WorkBook.FromStream:

using IronXL;
using System.IO;

// Simulate reading file bytes (e.g., from a database or web upload)
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");

using MemoryStream stream = new MemoryStream(fileBytes);
WorkBook workbook = WorkBook.FromStream(stream);
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Get row and column counts
Console.WriteLine($"Rows: {worksheet.RowCount}, Columns: {worksheet.ColumnCount}");

// Convert to DataTable for database or grid binding
var dataTable = worksheet.ToDataTable(useHeaderRow: true);
Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");

foreach (System.Data.DataRow row in dataTable.Rows)
{
    string productName = row["ProductName"]?.ToString() ?? string.Empty;
    string sku = row["SKU"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Product: {productName}, SKU: {sku}");
}

using IronXL;
using System.IO;

// Simulate reading file bytes (e.g., from a database or web upload)
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");

using MemoryStream stream = new MemoryStream(fileBytes);
WorkBook workbook = WorkBook.FromStream(stream);
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Get row and column counts
Console.WriteLine($"Rows: {worksheet.RowCount}, Columns: {worksheet.ColumnCount}");

// Convert to DataTable for database or grid binding
var dataTable = worksheet.ToDataTable(useHeaderRow: true);
Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");

foreach (System.Data.DataRow row in dataTable.Rows)
{
    string productName = row["ProductName"]?.ToString() ?? string.Empty;
    string sku = row["SKU"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Product: {productName}, SKU: {sku}");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

WorkBook.FromStream aceita qualquer Stream -- MemoryStream, FileStream, ou um fluxo de rede. Essa flexibilidade significa que você nunca precisa escrever arquivos temporários no disco apenas para ler dados do Excel. A conversão para DataTable também se integra diretamente com SqlBulkCopy, controles de vinculação de dados e estruturas de relatório.

Como Converter entre Formatos Excel e CSV?

Embora o Leitor de fluxo possa lidar com arquivos CSV, aplicações de produção frequentemente precisam mover dados entre Excel e CSV. O IronXL simplifica a conversão de formatos. Você pode exportar dados do Excel para CSV ou importar dados CSV para uma planilha em apenas algumas linhas:

using IronXL;

// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
workbook.SaveAsCsv("output.csv");

// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("legacy-report.csv");
csvWorkbook.SaveAs("converted.xlsx");

// Export a specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("sheet1-export.csv");

using IronXL;

// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
workbook.SaveAsCsv("output.csv");

// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("legacy-report.csv");
csvWorkbook.SaveAs("converted.xlsx");

// Export a specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("sheet1-export.csv");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Essas conversões preservam seus dados enquanto mudam o formato do contêiner. Ao converter Excel para CSV, o IronXL exporta a primeira planilha por padrão; você pode especificar qualquer planilha que escolher. Converter um arquivo CSV para Excel cria uma planilha devidamente estruturada que você pode formatar, adicionar fórmulas e inserir dados adicionais .

Como Criar e Formatar Arquivos Excel com IronXL?

Ler dados do Excel é apenas parte do fluxo de trabalho. Muitas aplicações também precisam criar novos arquivos do Excel e aplicar formatação. O IronXL suporta formatação de células, incluindo fontes, cores, bordas, formatos de número e mesclagem de células :

using IronXL;

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");

// Write headers with formatting
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";

// Apply bold formatting to header row
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.SetBackgroundColor("#4472C4");
sheet["A1:C1"].Style.Font.Color = "#FFFFFF";

// Write data rows
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] units = { 120, 85, 210 };
decimal[] revenues = { 2400.00m, 1700.00m, 4200.00m };

for (int i = 0; i < products.Length; i++)
{
    sheet[$"A{i + 2}"].Value = products[i];
    sheet[$"B{i + 2}"].Value = units[i];
    sheet[$"C{i + 2}"].Value = revenues[i];
    sheet[$"C{i + 2}"].FormatString = "$#,##0.00";
}

// Save the workbook
workbook.SaveAs("FormattedReport.xlsx");
Console.WriteLine("Report created successfully.");

using IronXL;

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");

// Write headers with formatting
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";

// Apply bold formatting to header row
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.SetBackgroundColor("#4472C4");
sheet["A1:C1"].Style.Font.Color = "#FFFFFF";

// Write data rows
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] units = { 120, 85, 210 };
decimal[] revenues = { 2400.00m, 1700.00m, 4200.00m };

for (int i = 0; i < products.Length; i++)
{
    sheet[$"A{i + 2}"].Value = products[i];
    sheet[$"B{i + 2}"].Value = units[i];
    sheet[$"C{i + 2}"].Value = revenues[i];
    sheet[$"C{i + 2}"].FormatString = "$#,##0.00";
}

// Save the workbook
workbook.SaveAs("FormattedReport.xlsx");
Console.WriteLine("Report created successfully.");

Imports IronXL

' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")

' Write headers with formatting
sheet("A1").Value = "Product"
sheet("B1").Value = "Units Sold"
sheet("C1").Value = "Revenue"

' Apply bold formatting to header row
sheet("A1:C1").Style.Font.Bold = True
sheet("A1:C1").Style.SetBackgroundColor("#4472C4")
sheet("A1:C1").Style.Font.Color = "#FFFFFF"

' Write data rows
Dim products As String() = {"Widget A", "Widget B", "Widget C"}
Dim units As Integer() = {120, 85, 210}
Dim revenues As Decimal() = {2400.0D, 1700.0D, 4200.0D}

For i As Integer = 0 To products.Length - 1
    sheet($"A{i + 2}").Value = products(i)
    sheet($"B{i + 2}").Value = units(i)
    sheet($"C{i + 2}").Value = revenues(i)
    sheet($"C{i + 2}").FormatString = "$#,##0.00"
Next

' Save the workbook
workbook.SaveAs("FormattedReport.xlsx")
Console.WriteLine("Report created successfully.")

Essa capacidade de ler livros de trabalho existentes e criar novos arquivos formatados torna o IronXL uma solução completa para Excel em aplicativos .NET. Revise a página de funcionalidades do IronXL para uma análise detalhada das operações suportadas.

Como Licenciar e Implementar o IronXL em Produção?

IronXL é gratuito para desenvolvimento e teste. Para aplicações de produção, uma licença é necessária. Você pode explorar opções de licenciamento do IronXL na página do produto, que cobre níveis de Desenvolvedor, Equipe e Organização, dependendo das suas necessidades de implantação.

Após a compra, aplique sua chave de licença no código antes de qualquer chamada ao IronXL:

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Alternativamente, defina a variável de ambiente IRONXL_LICENSE_KEY em seu ambiente de implantação e o IronXL a detectará automaticamente. Esta é a abordagem preferida para implantações conteinerizadas (Docker, Kubernetes) e ambientes em nuvem onde codificar chaves não é aceitável.

Para fins de avaliação, uma licença de teste gratuita fornece funcionalidade completa para que você possa validar o IronXL em seus casos de uso específicos antes de adquirir. O teste está disponível sem cartão de crédito e é ativado imediatamente.

Comparado a alternativas como Microsoft.Office.Interop.Excel, o IronXL tem várias vantagens de implantação:

• Não exige que o Microsoft Excel esteja instalado no servidor
• Compatível com Linux e Docker -- essencial para aplicativos em nuvem
• Nenhum gerenciamento do ciclo de vida de objetos COM ou problemas de threading de apartamento
• Início mais rápido e menor uso de memória em contextos de servidor
• Comportamento consistente em todas as plataformas suportadas

Essas qualidades tornam o IronXL uma escolha prática para qualquer aplicativo .NET que precisa processar arquivos Excel em produção, seja localmente ou na nuvem.