Ler Arquivos Excel em C# Sem Instalar o Excel

Ler um arquivo do Excel em C# é uma tarefa comum para relatórios, importações de dados e automação. Com o Free Spire.XLS for .NET, uma edição comunitária gratuita, você pode carregar uma pasta de trabalho do Excel e ler seus dados sem instalar o Microsoft Excel na máquina e sem usar Interop. Este artigo mostra como ler células, planilhas e linhas, exportar uma planilha para um DataTable e manipular resultados de fórmulas.

Início Rápido: Ler um Arquivo do Excel em C#

Instale o Free Spire.XLS for .NET do NuGet. Execute este comando em um terminal:

dotnet add package FreeSpire.XLS

Ou execute este comando no Console do Gerenciador de Pacotes do NuGet:

Install-Package FreeSpire.XLS

Você também pode baixar o Free Spire.XLS for .NET e referenciar a DLL manualmente, ou encontrar o pacote no NuGet.

O exemplo a seguir carrega um arquivo do Excel, obtém a primeira planilha e imprime o valor da célula A1. Substitua input.xlsx pelo caminho completo do seu arquivo, ou certifique-se de que o arquivo esteja no diretório de trabalho atual do programa.

using System;
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook workbook = new Workbook();

        try
        {
            // Load an existing Excel file
            workbook.LoadFromFile("input.xlsx");

            // Get the first worksheet
            Worksheet sheet = workbook.Worksheets[0];

            // Read the value of cell A1 (row 1, column 1)
            string value = sheet.Range[1, 1].Value;

            Console.WriteLine("Cell A1: " + value);
        }
        finally
        {
            workbook.Dispose();
        }
    }
}

Workbook.LoadFromFile() lê o arquivo na memória. Worksheets[0] retorna a primeira planilha, e Range[1, 1].Value retorna o valor de texto da célula na primeira linha e primeira coluna. O bloco finally libera os recursos da pasta de trabalho quando você termina.

Ler uma Célula ou Planilha Específica

Os exemplos a seguir presumem que workbook já foi carregado com LoadFromFile(). Eles mostram como acessar uma planilha por índice ou nome.

Um arquivo do Excel pode conter várias planilhas. Você pode obter uma planilha por sua posição ou por seu nome:

// By index (zero-based): the first sheet is 0, the second is 1
Worksheet first = workbook.Worksheets[0];

// By name
Worksheet sales = workbook.Worksheets["Sales"];

Você também pode ler uma célula pelos seus números de linha e coluna, ou pelo seu endereço no Excel:

// By row and column numbers (one-based): row 2, column 3
string byIndex = sales.Range[2, 3].Value;

// By Excel address
string byAddress = sales.Range["C2"].Value;

Observe os dois pontos de partida diferentes. A coleção de planilhas é baseada em zero, então a primeira planilha é Worksheets[0]. Os números de linha e coluna das células são baseados em um, então Range[1, 1] é a célula A1.

Para ler um bloco de células, passe um endereço de intervalo e faça um loop por ele:

CellRange range = sales.Range["A1:C3"];

foreach (CellRange cell in range.CellList)
{
    Console.WriteLine({BODY_CONTENT}quot;{cell.RangeAddress}: {cell.Value}");
}

Ler Dados do Excel Linha a Linha em C#

Para ler todos os dados de uma planilha, faça um loop pelas linhas com um loop externo e pelas colunas com um loop interno. Escreva uma quebra de linha após cada linha para que a saída do console mantenha a estrutura da planilha:

using System;
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook workbook = new Workbook();

        try
        {
            workbook.LoadFromFile("input.xlsx");
            Worksheet sheet = workbook.Worksheets[0];

            for (int row = 1; row <= sheet.LastDataRow; row++)
            {
                for (int col = 1; col <= sheet.LastDataColumn; col++)
                {
                    Console.Write({BODY_CONTENT}quot;{sheet.Range[row, col].Value}\t");
                }

                Console.WriteLine();
            }
        }
        finally
        {
            workbook.Dispose();
        }
    }
}

Os loops vão da linha 1 e coluna 1 até LastDataRow e LastDataColumn, que retornam a última linha e coluna que contêm dados. Isso evita incluir células formatadas, mas vazias, que LastRow e LastColumn abrangeriam. Se sua planilha tiver um layout incomum, verifique o intervalo real no seu arquivo de teste antes de processar a saída.

Para uma planilha que contém os dados de exemplo abaixo:

o console mostra cada linha da planilha em sua própria linha, com os valores das células separados por tabulações:

Product    Category    Price
Keyboard   Accessories 25
Monitor    Displays    180

Ler Dados do Excel em um DataTable

Se você quiser processar dados da planilha com ADO.NET, vinculá-los a um controle ou inseri-los em um banco de dados, exporte a planilha para um DataTable com ExportDataTable():

using System;
using System.Data;
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook workbook = new Workbook();

        try
        {
            workbook.LoadFromFile("input.xlsx");

            // Recalculate formulas before exporting computed values
            workbook.CalculateAllValue();

            Worksheet sheet = workbook.Worksheets[0];

            DataTable dataTable = sheet.ExportDataTable(
                sheet.AllocatedRange,
                true,   // exportColumnNames
                true    // computedFormulaValue
            );

            // Print each row to verify the exported data
            foreach (DataRow row in dataTable.Rows)
            {
                Console.WriteLine(string.Join("\t", row.ItemArray));
            }
        }
        finally
        {
            workbook.Dispose();
        }
    }
}

Esta sobrecarga usa três parâmetros:

• range: o intervalo de células a exportar. sheet.AllocatedRange retorna o intervalo usado da planilha. Dependendo da formatação da pasta de trabalho e das configurações de intervalo usado, ele pode incluir células vazias. Se você precisar apenas de uma região de dados específica, use um intervalo explícito e verifique seus limites.
• exportColumnNames: quando true, a primeira linha do intervalo se torna os nomes das colunas do DataTable. Quando false, a primeira linha é exportada como dados comuns.
• computedFormulaValue: quando true, o exportador usa valores calculados de fórmulas em vez do texto da fórmula. Quando false, as células de fórmula são exportadas como seu texto de fórmula. Se seus dados contiverem fórmulas, verifique os valores exportados no seu próprio arquivo de teste — o cálculo da fórmula pode precisar ser acionado antes da exportação para que os resultados sejam preenchidos corretamente.

Para mostrar o resultado em um aplicativo Windows Forms, atribua a tabela a um DataGridView:

dataGridView1.DataSource = dataTable;

Verifique os nomes das colunas e os tipos de dados da tabela exportada em relação ao seu próprio arquivo do Excel antes de confiar neles em processamentos posteriores. Para mais opções, como exportar um intervalo específico, consulte o tutorial detalhado sobre converter Excel em DataTable em C#.

Ler Resultados de Fórmulas e Manipular Valores de Células

Os trechos nesta seção presumem que sheet se refere a uma planilha de uma pasta de trabalho carregada, como nos exemplos anteriores.

Uma célula que contém uma fórmula tem duas coisas que você pode querer ler: a própria fórmula e o resultado que ela produz. Use HasFormula para verificar se uma célula contém uma fórmula, Formula para obter o texto da fórmula e FormulaValue para obter o resultado calculado. Se você precisar de resultados de fórmulas atualizados, chame workbook.CalculateAllValue() após carregar a pasta de trabalho e antes de ler FormulaValue.

CellRange cell = sheet.Range["D2"];

if (cell.HasFormula)
{
    Console.WriteLine("Formula: " + cell.Formula);
    Console.WriteLine("Result: " + cell.FormulaValue);
}
else
{
    Console.WriteLine("Value: " + cell.Value);
}

Para saber mais sobre como trabalhar com fórmulas, consulte Adicionar ou Ler Fórmulas e Funções no Excel.

Células com diferentes tipos de conteúdo podem ser lidas por meio de propriedades tipadas:

CellRange priceCell = sheet.Range["C2"];
CellRange dateCell = sheet.Range["E2"];

double price = priceCell.NumberValue;       // numeric value
DateTime date = dateCell.DateTimeValue;     // date value
string text = sheet.Range["A2"].Text;       // text as displayed

O Excel armazena números e datas de maneiras diferentes do texto simples, então escolha a propriedade que corresponda ao tipo de dados na célula.

Ler Formatos de Número e Valores Exibidos

Para células com formatos de número — porcentagens, moeda, datas — o valor armazenado, o código de formato e o texto formatado podem ser todos diferentes. Uma célula que armazena 0.15 com um formato de porcentagem é exibida como 15%. Use Value para o valor bruto, NumberFormat para o código de formato e NumberText para o texto como ele aparece no Excel:

CellRange cell = sheet.Range["C2"];

Console.WriteLine("Value: " + cell.Value);
Console.WriteLine("Number format: " + cell.NumberFormat);
Console.WriteLine("Formatted text: " + cell.NumberText);

Escolha a propriedade que corresponde ao que sua lógica subsequente precisa: o valor numérico para cálculos ou o texto formatado para exibição. Para saber mais sobre formatos de número, consulte Definir Formato de Número no Excel.

Antes de ler uma célula, você pode verificar se ela está vazia:

if (string.IsNullOrEmpty(sheet.Range["B5"].Value))
{
    Console.WriteLine("B5 is empty.");
}

Perguntas Frequentes

Posso ler arquivos do Excel em C# sem instalar o Microsoft Excel?

Sim. O Free Spire.XLS lê arquivos do Excel diretamente e não requer Microsoft Excel ou Interop no computador ou servidor que executa seu código.

Como faço para ler resultados de fórmulas em vez de fórmulas?

Para uma única célula, verifique CellRange.HasFormula e leia CellRange.FormulaValue. Para ler uma planilha inteira, chame ExportDataTable() com computedFormulaValue definido como true. Consulte Ler Resultados de Fórmulas e Manipular Valores de Células.

Posso ler arquivos do Excel protegidos por senha?

Sim. Defina a senha de abertura antes de carregar o arquivo:

Workbook workbook = new Workbook();
workbook.OpenPassword = "your-password";
workbook.LoadFromFile("protected.xlsx");

Quais formatos de arquivo do Excel o Free Spire.XLS suporta?

O Free Spire.XLS suporta os formatos .xls, .xlsx e .xlsm.

Quais são as limitações da edição gratuita?

O Free Spire.XLS for .NET é uma edição comunitária para desenvolvedores pessoais e pequenos projetos. Ao trabalhar com o formato .xls, cada pasta de trabalho é limitada a 5 planilhas e 200 linhas por planilha. Carregar e salvar arquivos .xlsx não está sujeito a esses limites. Para maior capacidade ou recursos avançados, o Spire.XLS for .NET está disponível como uma edição comercial.

Se você precisar de maior capacidade ou recursos avançados, o Spire.XLS for .NET é a edição comercial — você pode solicitar uma licença de avaliação gratuita de 30 dias para avaliá-lo.

Veja Também

• Converter Excel em DataTable em C#
• Converter Excel em CSV e CSV em Excel em C#
• Criar, Ler e Atualizar Excel em C#
• Ler Propriedades do Documento no Excel em C#