Lendo arquivos do Excel em C #

Existe uma biblioteca gratuita ou de código aberto para ler arquivos do Excel (.xls) diretamente de um programa em C #?

Não precisa ser muito sofisticado, apenas para selecionar uma planilha e ler os dados como strings. Até agora, tenho usado a função de texto Exportar para Unicode do Excel e analisando o arquivo resultante (delimitado por tabulações), mas gostaria de eliminar a etapa manual.

var fileName = string.Format("{0}\\fileNameHere", Directory.GetCurrentDirectory());
var connectionString = string.Format("Provider=Microsoft.Jet.OLEDB.4.0; data source={0}; Extended Properties=Excel 8.0;", fileName);

var adapter = new OleDbDataAdapter("SELECT * FROM [workSheetNameHere$]", connectionString);
var ds = new DataSet();

adapter.Fill(ds, "anyNameHere");

DataTable data = ds.Tables["anyNameHere"];

Isto é o que eu costumo usar. É um pouco diferente, porque normalmente colo um AsEnumerable () na edição das tabelas:

var data = ds.Tables["anyNameHere"].AsEnumerable();

pois isso permite que eu use o LINQ para pesquisar e criar estruturas a partir dos campos.

var query = data.Where(x => x.Field<string>("phoneNumber") != string.Empty).Select(x =>
                new MyContact
                    {
                        firstName= x.Field<string>("First Name"),
                        lastName = x.Field<string>("Last Name"),
                        phoneNumber =x.Field<string>("Phone Number"),
                    });

Se forem apenas dados simples contidos no arquivo do Excel, você poderá ler os dados via ADO.NET. Veja as cadeias de conexão listadas aqui:

http://www.connectionstrings.com/?carrier=excel2007 ou http://www.connectionstrings.com/?carrier=excel

-Ryan

Atualização: você pode ler a planilha através de algo como select * from [Sheet1$]

A abordagem do ADO.NET é rápida e fácil, mas há algumas peculiaridades que você deve conhecer, especialmente em relação à forma como os DataTypes são tratados.

Este excelente artigo o ajudará a evitar algumas armadilhas comuns: http://blog.lab49.com/archives/196

Isto é o que eu usei para o Excel 2003:

Dictionary<string, string> props = new Dictionary<string, string>();
props["Provider"] = "Microsoft.Jet.OLEDB.4.0";
props["Data Source"] = repFile;
props["Extended Properties"] = "Excel 8.0";

StringBuilder sb = new StringBuilder();
foreach (KeyValuePair<string, string> prop in props)
{
    sb.Append(prop.Key);
    sb.Append('=');
    sb.Append(prop.Value);
    sb.Append(';');
}
string properties = sb.ToString();

using (OleDbConnection conn = new OleDbConnection(properties))
{
    conn.Open();
    DataSet ds = new DataSet();
    string columns = String.Join(",", columnNames.ToArray());
    using (OleDbDataAdapter da = new OleDbDataAdapter(
        "SELECT " + columns + " FROM [" + worksheet + "$]", conn))
    {
        DataTable dt = new DataTable(tableName);
        da.Fill(dt);
        ds.Tables.Add(dt);
    }
}

E o Excel Data Reader?

http://exceldatareader.codeplex.com/

Eu usei essa raiva, em um ambiente de produção, para extrair grandes quantidades de dados de uma variedade de arquivos do Excel para o SQL Server Compact. Funciona muito bem e é bastante robusto.

Aqui está um código que eu escrevi em C # usando o .NET 1.1 há alguns anos atrás. Não tenho certeza se isso seria exatamente o que você precisa (e pode não ser o meu melhor código :)).

using System;
using System.Data;
using System.Data.OleDb;

namespace ExportExcelToAccess
{
    /// <summary>
    /// Summary description for ExcelHelper.
    /// </summary>
    public sealed class ExcelHelper
    {
        private const string CONNECTION_STRING = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=<FILENAME>;Extended Properties=\"Excel 8.0;HDR=Yes;\";";

        public static DataTable GetDataTableFromExcelFile(string fullFileName, ref string sheetName)
        {
            OleDbConnection objConnection = new OleDbConnection();
            objConnection = new OleDbConnection(CONNECTION_STRING.Replace("<FILENAME>", fullFileName));
            DataSet dsImport = new DataSet();

            try
            {
                objConnection.Open();

                DataTable dtSchema = objConnection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);

                if( (null == dtSchema) || ( dtSchema.Rows.Count <= 0 ) )
                {
                    //raise exception if needed
                }

                if( (null != sheetName) && (0 != sheetName.Length))
                {
                    if( !CheckIfSheetNameExists(sheetName, dtSchema) )
                    {
                        //raise exception if needed
                    }
                }
                else
                {
                    //Reading the first sheet name from the Excel file.
                    sheetName = dtSchema.Rows[0]["TABLE_NAME"].ToString();
                }

                new OleDbDataAdapter("SELECT * FROM [" + sheetName + "]", objConnection ).Fill(dsImport);
            }
            catch (Exception)
            {
                //raise exception if needed
            }
            finally
            {
                // Clean up.
                if(objConnection != null)
                {
                    objConnection.Close();
                    objConnection.Dispose();
                }
            }


            return dsImport.Tables[0];
            #region Commented code for importing data from CSV file.
            //              string strConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;" +"Data Source=" + System.IO.Path.GetDirectoryName(fullFileName) +";" +"Extended Properties=\"Text;HDR=YES;FMT=Delimited\"";
            //
            //              System.Data.OleDb.OleDbConnection conText = new System.Data.OleDb.OleDbConnection(strConnectionString);
            //              new System.Data.OleDb.OleDbDataAdapter("SELECT * FROM " + System.IO.Path.GetFileName(fullFileName).Replace(".", "#"), conText).Fill(dsImport);
            //              return dsImport.Tables[0];

            #endregion
        }

        /// <summary>
        /// This method checks if the user entered sheetName exists in the Schema Table
        /// </summary>
        /// <param name="sheetName">Sheet name to be verified</param>
        /// <param name="dtSchema">schema table </param>
        private static bool CheckIfSheetNameExists(string sheetName, DataTable dtSchema)
        {
            foreach(DataRow dataRow in dtSchema.Rows)
            {
                if( sheetName == dataRow["TABLE_NAME"].ToString() )
                {
                    return true;
                }   
            }
            return false;
        }
    }
}

Koogra é um componente de código aberto escrito em C # que lê e grava arquivos do Excel.

Embora você tenha solicitado especificamente .xls, implicando os formatos de arquivo mais antigos, para os formatos OpenXML (por exemplo, xlsx), recomendo o OpenXML SDK ( http://msdn.microsoft.com/en-us/library/bb448854.aspx )

Eu li muito os arquivos do Excel em C # há um tempo atrás e usamos duas abordagens:

• A API COM, onde você acessa os objetos do Excel diretamente e os manipula através de métodos e propriedades
• O driver ODBC que permite usar o Excel como um banco de dados.

A última abordagem foi muito mais rápida: ler uma grande tabela com 20 colunas e 200 linhas levaria 30 segundos via COM e meio segundo via ODBC. Então, eu recomendaria a abordagem de banco de dados se tudo que você precisa são os dados.

Felicidades,

Carl

O ExcelMapper é uma ferramenta de código-fonte aberto ( http://code.google.com/p/excelmapper/ ) que pode ser usada para ler planilhas do Excel como objetos fortemente tipados. Ele suporta os formatos xls e xlsx.

Quero mostrar um método simples para ler o arquivo xls / xlsx com o .NET. Espero que o seguinte seja útil para você.

 DataTable privado ReadExcelToTable (caminho da string)    
 {

     // String de conexão

     string connstring = "Provedor = Microsoft.ACE.OLEDB.12.0; Fonte de dados =" + caminho + "; Propriedades estendidas = 'Excel 8.0; HDR = NÃO; IMEX = 1';";  
     //o mesmo nome 
     // string connstring = Provider = Microsoft.JET.OLEDB.4.0; Fonte de dados = "+ caminho + //"; Propriedades estendidas = 'Excel 8.0; HDR = NO; IMEX = 1'; "; 

     using (OleDbConnection conn = new OleDbConnection (connstring))
     {
        conn.Open ();
        // Obter nome de todas as folhas
        DataTable sheetsName = conn.GetOleDbSchemaTable (OleDbSchemaGuid.Tables, novo objeto [] {nulo, nulo, nulo, "Tabela"});  

        // Obter o nome da primeira planilha
        string firstSheetName = sheetsName.Rows [0] [2] .ToString (); 

        // String de consulta 
        string sql = string.Format ("SELECT * FROM [{0}]", firstSheetName); 
        OleDbDataAdapter ada = novo OleDbDataAdapter (sql, connstring);
        Conjunto de dados = novo DataSet ();
        preenchimento (conjunto);
        retornar set.Tables [0];   
   }
 }

O código é do artigo: http://www.c-sharpcorner.com/uploadfile/d2dcfc/read-excel-file-with-net/ . Você pode obter mais detalhes com isso.

Não é gratuito, mas com o Office mais recente, existe uma API .Net de automação muito boa. (há uma API há muito tempo, mas a COM é desagradável) Você pode fazer tudo o que deseja / precisa no código enquanto o aplicativo do Office permanece um processo oculto em segundo plano.

Perdoe-me se eu estiver fora da base aqui, mas não é para isso que servem os PIA do Office ?

Ultimamente, em parte para melhorar o LINQ ... Eu tenho usado a API de automação do Excel para salvar o arquivo como planilha XML e, em seguida, obter esse processo usando o LINQ to XML.

SpreadsheetGear for .NET é um componente de planilha compatível com Excel para .NET. Você pode ver o que nossos clientes dizem sobre o desempenho no lado direito da nossa página de produtos . Você pode tentar você mesmo com a avaliação totalmente funcional e gratuita .

O SmartXLS é outro componente da planilha do Excel que suporta a maioria dos recursos de gráficos do Excel, mecanismos de fórmulas e pode ler / gravar o formato open200ml do excel2007.

O componente .NET Excel Reader .NET pode atender aos seus requisitos. É bom o suficiente para ler arquivos XLSX e XLS. Então, experimente:

http://www.devtriogroup.com/ExcelReader

Eu recomendo a Biblioteca FileHelpers, que é uma biblioteca .NET gratuita e fácil de usar para importar / exportar dados do EXCEL, comprimento fixo ou registros delimitados em arquivos, strings ou fluxos + Mais.

A seção de documentação do Excel Data Link http://filehelpers.sourceforge.net/example_exceldatalink.html

Você pode tentar usar esta solução de código-fonte aberto que torna o gerenciamento do Excel muito mais limpo.

http://excelwrapperdotnet.codeplex.com/

SpreadsheetGear é incrível. Sim, é uma despesa, mas, comparada com as outras soluções, vale a pena o custo. É rápido, confiável, muito abrangente, e devo dizer que depois de usar este produto em meu trabalho de software em período integral por mais de um ano e meio, o suporte ao cliente é fantástico!

A solução que usamos, precisava:

• Permitir leitura / gravação de arquivos produzidos no Excel
• Seja rápido no desempenho (não como usar COMs)
• Seja independente do MS Office (necessário para ser utilizável sem clientes com o MS Office instalado)
• Seja gratuito ou de código aberto (mas desenvolvido ativamente)

Existem várias opções, mas descobrimos que o NPoi (porta .NET do projeto de código aberto Poi existente há muito tempo em Java ) é o melhor: http://npoi.codeplex.com/

Também permite trabalhar com os formatos de arquivo .doc e .ppt

Se são apenas dados tabulares. Eu recomendaria ajudantes de dados de arquivo de Marcos Melli, que podem ser baixados aqui .

Cheguei atrasado na festa, mas sou fã do LinqToExcel

você pode escrever uma planilha do Excel que carrega uma determinada planilha do Excel e a salva como CSV (em vez de fazê-lo manualmente).

então você pode automatizar isso a partir de c #.

e uma vez em csv, o programa c # pode grocá-lo.

(Além disso, se alguém solicitar que você programe no Excel, é melhor fingir que você não sabe como)

(edit: ah sim, rob e ryan estão certos)

Eu sei que as pessoas estão fazendo uma "extensão" do Excel para esse fim.
Você mais ou menos cria um botão no Excel que diz "Exportar para o Programa X", depois exporta e envia os dados em um formato que o programa possa ler.

http://msdn.microsoft.com/en-us/library/ms186213.aspx deve ser um bom lugar para começar.

Boa sorte

Acabei de fazer um projeto de demonstração rápida que exigia o gerenciamento de alguns arquivos do Excel. O componente .NET do software GemBox era adequado para minhas necessidades. Tem uma versão gratuita com algumas limitações.

http://www.gemboxsoftware.com/GBSpreadsheet.htm

O Pacote do Excel é um componente de código aberto (GPL) para leitura / gravação de arquivos do Excel 2007. Usei-o em um projeto pequeno, e a API é direta. Funciona apenas com XLSX (Excel 200 e), não com XLS.

O código-fonte também parece bem organizado e fácil de contornar (se você precisar expandir a funcionalidade ou corrigir problemas menores, como eu fiz).

Inicialmente, tentei a abordagem ADO.Net (cadeia de conexão do Excel), mas estava repleta de hackers desagradáveis ​​- por exemplo, se a segunda linha contiver um número, ela retornará ints para todos os campos da coluna abaixo e eliminará silenciosamente todos os dados isso não se encaixa.

Usamos o ClosedXML em sistemas bastante grandes.

• Livre
• Fácil de instalar
• Codificação direta
• Suporte muito responsivo
• A equipe de desenvolvedores é extremamente aberta a novas sugestões. Muitas vezes, novos recursos e correções de erros são implementados na mesma semana

Take.ioA planilha fará esse trabalho para você, sem nenhum custo. Basta dar uma olhada nisso .

Eu apenas usei o ExcelLibrary para carregar uma planilha .xls em um DataSet. Funcionou muito bem para mim.