planilha - Lendo arquivos do Excel em C#

A solução que usamos precisava:

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

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

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

Apenas fiz um projeto de demonstração rápida que exigia o gerenciamento de alguns arquivos do Excel. O componente .NET do software GemBox foi adequado às minhas necessidades. Tem uma versão gratuita com algumas limitações.

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

Aqui está um código que eu escrevi em C # usando o .NET 1.1 há alguns anos. 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;
        }
    }
}

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

Eu fiz muita leitura de arquivos do Excel em C # há um tempo atrás, e usamos duas abordagens:

• A API COM, onde você acessa diretamente os objetos do Excel 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 tabela grande com 20 colunas e 200 linhas levaria 30 segundos via COM e meio segundo via ODBC. Então, eu recomendaria a abordagem do banco de dados se tudo o que você precisa são os dados.

Felicidades,

Carl

Eu recomendo a Biblioteca FileHelpers que é uma biblioteca .NET livre 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 de links de dados do Excel http://filehelpers.sourceforge.net/example_exceldatalink.html

Eu sei que as pessoas têm feito uma "extensão" do Excel para esse propósito.
Você mais ou menos faz um botão no Excel que diz "Exportar para o programa X" e, em seguida, exportar e enviar os dados em um formato que o programa pode ler.

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

Boa sorte

Não é grátis, mas com o Office mais recente há uma API de .Net de automação muito boa. (tem havido uma API por um longo tempo, mas foi COM desagradável) Você pode fazer tudo o que quiser / precisar no código de tudo enquanto o aplicativo do Office continua a ser um processo de fundo oculto.

Nós usamos ClosedXML em sistemas bastante grandes.

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

O SpreadsheetGear é incrível. Sim, é uma despesa, mas comparado a mexer com essas outras soluções, vale a pena o custo. É rápido, confiável, muito abrangente, e eu tenho que dizer que depois de usar este produto no meu trabalho de software em tempo integral por mais de um ano e meio, o suporte ao cliente deles é fantástico!

O componente .NET Excel Reader .NET pode satisfazer seu requisito. É bom para ler arquivos XLSX e XLS. Então tente de:

http://www.devtriogroup.com/ExcelReader

Planilha Take.io fará este trabalho para você, e sem nenhum custo. Basta dar uma olhada this .

Se é apenas dados tabulares. Eu recomendaria os ajudantes de dados de arquivos de Marcos Melli, que podem ser baixados here .

Tarde para a festa, mas sou fã do LinqToExcel

Ultimamente, em parte para ficar melhor no LINQ .... Eu tenho usado a API de automação do Excel para salvar o arquivo como XML Spreadsheet e depois processar esse arquivo usando LINQ para XML.

você poderia escrever uma planilha do excel que carregasse uma determinada planilha do Excel e a salvasse como csv (ao invés de fazê-la manualmente).

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

e uma vez em csv, o programa c # pode fazer isso.

(também, se alguém lhe pedir para programar no excel, é melhor fingir que não sabe como)

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

O Pacote do Excel é um componente de código aberto (GPL) para ler / gravar arquivos do Excel 2007. Eu usei isso em um projeto pequeno, e a API é direta. Funciona apenas com XLSX (Excel 200 &), 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).

No começo, eu tentei a abordagem ADO.Net (string de conexão do Excel), mas estava repleta de hacks desagradáveis ​​- por exemplo, se a segunda linha contiver um número, ela retornará ints para todos os campos na coluna abaixo e silenciosamente descartará todos os dados isso não encaixa.

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

O 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 de nossa página de produtos . Você pode experimentá-lo com a avaliação gratuita e totalmente funcional.