Lettura di file Excel da C #

Esiste una libreria gratuita o open source per leggere i file Excel (.xls) direttamente da un programma C #?

Non deve essere troppo elaborato, basta selezionare un foglio di lavoro e leggere i dati come stringhe. Finora ho usato la funzione di testo Esporta in Unicode di Excel e ho analizzato il file risultante (delimitato da tabulazioni), ma vorrei eliminare il passaggio manuale.

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"];

Questo è quello che di solito uso. È un po 'diverso perché di solito applico un AsEnumerable () alla modifica delle tabelle:

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

in quanto ciò mi consente di utilizzare LINQ per cercare e creare strutture dai campi.

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 sono solo semplici dati contenuti nel file Excel, puoi leggere i dati tramite ADO.NET. Vedi le stringhe di connessione elencate qui:

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

-Ryan

Aggiornamento: quindi puoi semplicemente leggere il foglio di lavoro tramite qualcosa di simile select * from [Sheet1$]

L'approccio ADO.NET è rapido e semplice, ma presenta alcune stranezze di cui dovresti essere a conoscenza, in particolare per quanto riguarda la gestione dei DataTypes.

Questo eccellente articolo ti aiuterà a evitare alcune insidie ​​comuni: http://blog.lab49.com/archives/196

Questo è quello che ho usato per 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);
    }
}

Che ne dici di Excel Data Reader?

http://exceldatareader.codeplex.com/

Ci ho usato la rabbia, in un ambiente di produzione, per estrarre grandi quantità di dati da una varietà di file Excel in SQL Server Compact. Funziona molto bene ed è piuttosto robusto.

Ecco del codice che ho scritto in C # usando .NET 1.1 qualche anno fa. Non sono sicuro se questo sarebbe esattamente ciò di cui hai bisogno (e potrebbe non essere il mio miglior codice :)).

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 è un componente open source scritto in C # che legge e scrive file Excel.

Sebbene tu abbia richiesto specificamente .xls, implicando i formati di file più vecchi, per i formati OpenXML (ad esempio xlsx) consiglio vivamente l'SDK OpenXML ( http://msdn.microsoft.com/en-us/library/bb448854.aspx )

Qualche tempo fa ho letto molto dai file Excel in C # e abbiamo usato due approcci:

• L'API COM, dove si accede direttamente agli oggetti di Excel e li manipola attraverso metodi e proprietà
• Il driver ODBC che consente di utilizzare Excel come un database.

Quest'ultimo approccio è stato molto più veloce: la lettura di una grande tabella con 20 colonne e 200 righe richiederebbe 30 secondi tramite COM e mezzo secondo tramite ODBC. Quindi consiglierei l'approccio al database se tutto ciò di cui hai bisogno sono i dati.

Saluti,

Carl

ExcelMapper è uno strumento open source ( http://code.google.com/p/excelmapper/ ) che può essere utilizzato per leggere i fogli di lavoro di Excel come oggetti fortemente tipizzati. Supporta entrambi i formati xls e xlsx.

Voglio mostrare un metodo semplice per leggere il file xls / xlsx con .NET. Spero che quanto segue possa esserti utile.

 Private DataTable ReadExcelToTable (percorso stringa)    
 {

     // Stringa di connessione

     string connstring = "Provider = Microsoft.ACE.OLEDB.12.0; Origine dati =" + percorso + "; Proprietà estese = 'Excel 8.0; HDR = NO; IMEX = 1';";  
     // lo stesso nome 
     // string connstring = Provider = Microsoft.JET.OLEDB.4.0; Origine dati = "+ percorso + //"; Proprietà estese = 'Excel 8.0; HDR = NO; IMEX = 1'; "; 

     using (OleDbConnection conn = new OleDbConnection (connstring))
     {
        conn.Open ();
        // Ottieni nome per tutti i fogli
        DataTableheetName = conn.GetOleDbSchemaTable (OleDbSchemaGuid.Tables, nuovo oggetto [] {null, null, null, "Table"});  

        // Ottieni il nome del primo foglio
        stringa firstSheetName =heetName.Rows [0] [2] .ToString (); 

        //Stringa della domanda 
        string sql = string.Format ("SELECT * FROM [{0}]", firstSheetName); 
        OleDbDataAdapter ada = new OleDbDataAdapter (sql, connstring);
        DataSet set = new DataSet ();
        ada.Fill (set);
        return set.Tables [0];   
   }
 }

Il codice proviene dall'articolo: http://www.c-sharpcorner.com/uploadfile/d2dcfc/read-excel-file-with-net/ . Puoi ottenere maggiori dettagli da esso.

Non gratuito, ma con l'ultima versione di Office c'è un'API .Net di automazione molto bella. (C'è stata un'API per molto tempo ma è stata una brutta COM) Puoi fare tutto ciò che vuoi / hai bisogno nel codice mentre l'app di Office rimane un processo in background nascosto.

Perdonami se sono fuori base qui, ma non è questo a che cosa servono le PIA di Office ?

Ultimamente, in parte per migliorare su LINQ .... Ho usato l'API di automazione di Excel per salvare il file come foglio di calcolo XML e quindi ottenere il processo utilizzando LINQ to XML.

SpreadsheetGear per .NET è un componente di foglio di calcolo compatibile con Excel per .NET. Puoi vedere cosa dicono i nostri clienti sulle prestazioni sul lato destro della nostra pagina del prodotto . Puoi provarlo tu stesso con la valutazione gratuita e completamente funzionale .

SmartXLS è un altro componente del foglio di calcolo Excel che supporta la maggior parte delle funzionalità di grafici Excel, motori di formule e può leggere / scrivere il formato openxml excel2007.

Il componente .NET Excel Reader .NET può soddisfare le tue esigenze. È abbastanza buono per leggere file XLSX e XLS. Quindi provalo da:

http://www.devtriogroup.com/ExcelReader

Consiglio la Libreria FileHelpers che è una libreria .NET gratuita e facile da usare per importare / esportare dati da EXCEL, record a lunghezza fissa o delimitati in file, stringhe o stream + Altro.

La sezione documentazione di Excel Data Link http://filehelpers.sourceforge.net/example_exceldatalink.html

Puoi provare a utilizzare questa soluzione open source che rende la gestione di Excel molto più pulita.

http://excelwrapperdotnet.codeplex.com/

SpreadsheetGear è fantastico. Sì, è una spesa, ma rispetto al giocherellare con queste altre soluzioni, vale il costo. È veloce, affidabile, molto completo e devo dire che dopo aver utilizzato questo prodotto nel mio lavoro di software a tempo pieno per oltre un anno e mezzo, il loro supporto clienti è fantastico!

La soluzione che abbiamo usato, doveva:

• Consenti lettura / scrittura di file prodotti da Excel
• Sii veloce nelle prestazioni (non come usare le COM)
• Essere indipendenti da MS Office (necessario per essere utilizzabili senza client con MS Office installato)
• Sii libero o open source (ma sviluppato attivamente)

Esistono diverse opzioni, ma abbiamo trovato NPoi (porta .NET del lungo progetto Java open source Poi esistente ) per essere il migliore: http://npoi.codeplex.com/

Inoltre, consente di lavorare con i formati di file .doc e .ppt

Se sono solo dati tabulari. Consiglierei gli aiutanti dei dati di file di Marcos Melli che possono essere scaricati qui .

In ritardo alla festa, ma sono un fan di LinqToExcel

potresti scrivere un foglio di calcolo Excel che carica un determinato foglio di calcolo Excel e lo salva come CSV (anziché farlo manualmente).

allora potresti automatizzarlo da c #.

e una volta che è in CSV, il programma c # può farlo.

(Inoltre, se qualcuno ti chiede di programmare in Excel, è meglio fingere di non sapere come)

(modifica: ah sì, rob e ryan hanno entrambi ragione)

So che le persone hanno creato un'estensione di Excel per questo scopo.
Più o meno si crea un pulsante in Excel che dice "Esporta nel programma X", quindi si esporta e invia i dati in un formato che il programma può leggere.

http://msdn.microsoft.com/en-us/library/ms186213.aspx dovrebbe essere un buon punto di partenza.

In bocca al lupo

Ho appena fatto un progetto demo veloce che ha richiesto la gestione di alcuni file Excel. Il componente .NET del software GemBox era adeguato alle mie esigenze. Ha una versione gratuita con alcune limitazioni.

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

Excel Package è un componente open-source (GPL) per la lettura / scrittura di file Excel 2007. L'ho usato su un piccolo progetto e l'API è semplice. Funziona solo con XLSX (Excel 200 e), non con XLS.

Il codice sorgente sembra anche ben organizzato e facile da aggirare (se hai bisogno di espandere la funzionalità o risolvere problemi minori come ho fatto io).

All'inizio, ho provato l'approccio ADO.Net (stringa di connessione di Excel), ma era pieno di attacchi dannosi - ad esempio se la seconda riga contiene un numero, restituirà ints per tutti i campi nella colonna sottostante e rilascerà silenziosamente tutti i dati non va bene.

Usiamo ClosedXML in sistemi piuttosto grandi.

• Gratuito
• Facile da installare
• Codifica diretta
• Supporto molto reattivo
• Il team di sviluppatori è estremamente aperto a nuovi suggerimenti. Spesso nuove funzionalità e correzioni di bug vengono implementate nella stessa settimana

Take.ioIl foglio di calcolo farà questo lavoro per te e gratuitamente. Dai un'occhiata a questo .

Ho appena usato ExcelLibrary per caricare un foglio di calcolo .xls in un DataSet. Ha funzionato alla grande per me.