Lecture de fichiers Excel à partir de C #

Existe-t-il une bibliothèque gratuite ou open source pour lire les fichiers Excel (.xls) directement à partir d'un programme C #?

Il n'a pas besoin d'être trop sophistiqué, il suffit de sélectionner une feuille de calcul et de lire les données sous forme de chaînes. Jusqu'à présent, j'ai utilisé la fonction de texte Exporter vers Unicode d'Excel et analysé le fichier résultant (délimité par des tabulations), mais j'aimerais éliminer l'étape manuelle.

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

C'est ce que j'utilise habituellement. C'est un peu différent car je colle habituellement un AsEnumerable () lors de l'édition des tables:

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

car cela me permet d'utiliser LINQ pour rechercher et construire des structures à partir des champs.

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"),
                    });

S'il ne s'agit que de données simples contenues dans le fichier Excel, vous pouvez lire les données via ADO.NET. Voir les chaînes de connexion répertoriées ici:

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

-Ryan

Mise à jour: alors vous pouvez simplement lire la feuille de calcul via quelque chose comme select * from [Sheet1$]

L'approche ADO.NET est rapide et facile, mais elle a quelques bizarreries que vous devez connaître, en particulier en ce qui concerne la façon dont les DataTypes sont traités.

Cet excellent article vous aidera à éviter certains pièges courants: http://blog.lab49.com/archives/196

Voici ce que j'ai utilisé pour 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);
    }
}

Que diriez-vous d'Excel Data Reader?

http://exceldatareader.codeplex.com/

J'y ai utilisé de la colère, dans un environnement de production, pour extraire de grandes quantités de données d'une variété de fichiers Excel dans SQL Server Compact. Cela fonctionne très bien et c'est plutôt robuste.

Voici du code que j'ai écrit en C # en utilisant .NET 1.1 il y a quelques années. Je ne sais pas si ce serait exactement ce dont vous avez besoin (et ce n'est peut-être pas mon meilleur code :)).

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 est un composant open source écrit en C # qui lit et écrit des fichiers Excel.

Bien que vous ayez demandé spécifiquement .xls, impliquant les anciens formats de fichier, pour les formats OpenXML (par exemple xlsx), je recommande fortement le SDK OpenXML ( http://msdn.microsoft.com/en-us/library/bb448854.aspx )

J'ai fait beaucoup de lecture à partir de fichiers Excel en C # il y a quelque temps, et nous avons utilisé deux approches:

• L'API COM, où vous accédez directement aux objets Excel et les manipulez via des méthodes et des propriétés
• Le pilote ODBC qui permet d'utiliser Excel comme une base de données.

Cette dernière approche était beaucoup plus rapide: la lecture d'un grand tableau de 20 colonnes et 200 lignes prendrait 30 secondes via COM et une demi-seconde via ODBC. Je recommanderais donc l'approche de la base de données si vous n'avez besoin que des données.

À votre santé,

Carl

ExcelMapper est un outil open source ( http://code.google.com/p/excelmapper/ ) qui peut être utilisé pour lire des feuilles de calcul Excel en tant qu'objets fortement typés. Il prend en charge les formats xls et xlsx.

Je veux montrer une méthode simple pour lire le fichier xls / xlsx avec .NET. J'espère que ce qui suit vous sera utile.

 DataTable privé ReadExcelToTable (chemin de chaîne)    
 {

     //Chaîne de connexion

     string connstring = "Provider = Microsoft.ACE.OLEDB.12.0; Data Source =" + path + "; Extended Properties = 'Excel 8.0; HDR = NO; IMEX = 1';";  
     //Le même nom 
     // string connstring = Provider = Microsoft.JET.OLEDB.4.0; Data Source = "+ path + //"; Extended Properties = 'Excel 8.0; HDR = NO; IMEX = 1'; "; 

     en utilisant (OleDbConnection conn = new OleDbConnection (connstring))
     {
        conn.Open ();
        // Obtenir le nom de toutes les feuilles
        DataTable sheetsName = conn.GetOleDbSchemaTable (OleDbSchemaGuid.Tables, nouvel objet [] {null, null, null, "Table"});  

        // Obtenez le nom de la première feuille
        string firstSheetName = sheetsName.Rows [0] [2] .ToString (); 

        //Chaîne de requête 
        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];   
   }
 }

Le code provient de l'article: http://www.c-sharpcorner.com/uploadfile/d2dcfc/read-excel-file-with-net/ . Vous pouvez en obtenir plus de détails.

Pas gratuit, mais avec le dernier Office, il y a une très belle API d'automatisation .Net. (il y a une API depuis longtemps mais c'était méchant COM) Vous pouvez faire tout ce que vous voulez / besoin dans le code pendant que l'application Office reste un processus d'arrière-plan caché.

Pardonnez-moi si je suis hors de la base ici, mais n'est-ce pas à cela que servent les PIA Office ?

Dernièrement, en partie pour améliorer LINQ .... J'ai utilisé l'API d'automatisation d'Excel pour enregistrer le fichier en tant que feuille de calcul XML, puis obtenir le traitement de ce fichier à l'aide de LINQ to XML.

SpreadsheetGear for .NET est un composant de feuille de calcul compatible Excel pour .NET. Vous pouvez voir ce que nos clients disent des performances sur le côté droit de notre page produit . Vous pouvez l'essayer vous-même avec l' évaluation gratuite et entièrement fonctionnelle .

SmartXLS est un autre composant de feuille de calcul Excel qui prend en charge la plupart des fonctionnalités des graphiques Excel, des moteurs de formules et peut lire / écrire le format openxml excel2007.

Le composant .NET Excel Reader .NET peut répondre à vos besoins. C'est assez bon pour lire des fichiers XLSX et XLS. Essayez donc à partir de:

http://www.devtriogroup.com/ExcelReader

Je recommande la bibliothèque FileHelpers qui est une bibliothèque .NET gratuite et facile à utiliser pour importer / exporter des données depuis EXCEL, des enregistrements de longueur fixe ou délimités dans des fichiers, des chaînes ou des flux + Plus.

La section de documentation de la liaison de données Excel http://filehelpers.sourceforge.net/example_exceldatalink.html

Vous pouvez essayer d'utiliser cette solution open source qui rend le traitement d'Excel beaucoup plus propre.

http://excelwrapperdotnet.codeplex.com/

SpreadsheetGear est génial. Oui, c'est une dépense, mais par rapport au bidouillage avec ces autres solutions, cela en vaut le coût. Il est rapide, fiable, très complet et je dois dire qu'après avoir utilisé ce produit dans mon travail de logiciel à temps plein pendant plus d'un an et demi, leur support client est fantastique!

La solution que nous avons utilisée devait:

• Autoriser la lecture / écriture des fichiers produits par Excel
• Soyez rapide dans les performances (pas comme l'utilisation des COM)
• Être indépendant de MS Office (devait être utilisable sans que MS Office soit installé)
• Être libre ou open source (mais activement développé)

Il y a plusieurs choix, mais nous avons trouvé que NPoi (le port .NET du projet open source Poi de Java existant depuis longtemps ) était le meilleur: http://npoi.codeplex.com/

Il permet également de travailler avec les formats de fichiers .doc et .ppt

S'il ne s'agit que de données tabulaires. Je recommanderais les assistants de données de fichiers de Marcos Melli qui peuvent être téléchargés ici .

Tard dans la soirée, mais je suis fan de LinqToExcel

vous pouvez écrire une feuille de calcul Excel qui charge une feuille de calcul Excel donnée et l'enregistre en tant que csv (plutôt que de le faire manuellement).

alors vous pouvez automatiser cela à partir de c #.

et une fois qu'il est en csv, le programme c # peut le bloquer.

(aussi, si quelqu'un vous demande de programmer en Excel, il vaut mieux faire comme si vous ne saviez pas comment)

(modifier: ah oui, rob et ryan ont tous les deux raison)

Je sais que des gens ont créé une "extension" Excel à cet effet.
Vous faites plus ou moins un bouton dans Excel qui dit "Exporter vers le programme X", puis exportez et envoyez les données dans un format que le programme peut lire.

http://msdn.microsoft.com/en-us/library/ms186213.aspx devrait être un bon point de départ.

Bonne chance

Je viens de faire un projet de démonstration rapide qui nécessitait la gestion de certains fichiers Excel. Le composant .NET du logiciel GemBox était adéquat pour mes besoins. Il a une version gratuite avec quelques limitations.

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

Excel Package est un composant open source (GPL) pour lire / écrire des fichiers Excel 2007. Je l'ai utilisé sur un petit projet et l'API est simple. Fonctionne uniquement avec XLSX (Excel 200 et), pas avec XLS.

Le code source semble également bien organisé et facile à déplacer (si vous avez besoin d'étendre les fonctionnalités ou de résoudre des problèmes mineurs comme je l'ai fait).

Au début, j'ai essayé l'approche ADO.Net (chaîne de connexion Excel), mais elle était chargée de hacks désagréables - par exemple, si la deuxième ligne contient un nombre, elle renverra des entiers pour tous les champs de la colonne ci-dessous et supprimera silencieusement toutes les données ça ne va pas.

Nous utilisons ClosedXML dans des systèmes assez grands.

• Libre
• Facile à installer
• Codage simple
• Support très réactif
• L'équipe de développeurs est extrêmement ouverte à de nouvelles suggestions. Souvent, de nouvelles fonctionnalités et corrections de bugs sont mises en œuvre au cours de la même semaine

Take.ioLe tableur fera ce travail pour vous, et sans frais. Jetez un oeil à cela .

Je viens d'utiliser ExcelLibrary pour charger une feuille de calcul .xls dans un DataSet. A très bien fonctionné pour moi.