Lectura de archivos de Excel desde C #

¿Existe una biblioteca gratuita o de código abierto para leer archivos de Excel (.xls) directamente desde un programa C #?

No necesita ser demasiado elegante, solo seleccionar una hoja de trabajo y leer los datos como cadenas. Hasta ahora, he estado utilizando la función Exportar a texto Unicode de Excel y analizando el archivo resultante (delimitado por tabulaciones), pero me gustaría eliminar el paso 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"];

Esto es lo que suelo usar. Es un poco diferente porque generalmente pego un AsEnumerable () en la edición de las tablas:

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

ya que esto me permite usar LINQ para buscar y construir estructuras a partir de los 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"),
                    });

Si solo se trata de datos simples contenidos en el archivo Excel, puede leer los datos a través de ADO.NET. Consulte las cadenas de conexión enumeradas aquí:

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

-Ryan

Actualización: entonces puedes leer la hoja de trabajo a través de algo como select * from [Sheet1$]

El enfoque ADO.NET es rápido y fácil, pero tiene algunas peculiaridades que debe tener en cuenta, especialmente con respecto a cómo se manejan los DataTypes.

Este excelente artículo lo ayudará a evitar algunas dificultades comunes: http://blog.lab49.com/archives/196

Esto es lo que usé para 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);
    }
}

¿Qué hay de Excel Data Reader?

http://exceldatareader.codeplex.com/

He utilizado su ira, en un entorno de producción, para extraer grandes cantidades de datos de una variedad de archivos de Excel en SQL Server Compact. Funciona muy bien y es bastante robusto.

Aquí hay un código que escribí en C # usando .NET 1.1 hace unos años. No estoy seguro si esto sería exactamente lo que necesita (y puede que no sea mi mejor 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 es un componente de código abierto escrito en C # que lee y escribe archivos de Excel.

Si bien solicitó específicamente .xls, lo que implica los formatos de archivo más antiguos, para los formatos OpenXML (por ejemplo, xlsx), le recomiendo el SDK de OpenXML ( http://msdn.microsoft.com/en-us/library/bb448854.aspx )

Leí mucho de los archivos de Excel en C # hace un tiempo, y usamos dos enfoques:

• La API COM, donde accede a los objetos de Excel directamente y los manipula a través de métodos y propiedades
• El controlador ODBC que permite usar Excel como una base de datos.

El último enfoque fue mucho más rápido: leer una tabla grande con 20 columnas y 200 líneas tomaría 30 segundos a través de COM y medio segundo a través de ODBC. Por lo tanto, recomendaría el enfoque de la base de datos si todo lo que necesita son los datos.

Salud,

Carl

ExcelMapper es una herramienta de código abierto ( http://code.google.com/p/excelmapper/ ) que se puede usar para leer hojas de cálculo de Excel como objetos fuertemente tipados. Es compatible con los formatos xls y xlsx.

Quiero mostrar un método simple para leer el archivo xls / xlsx con .NET. Espero que lo siguiente le sea útil.

 DataTable privado ReadExcelToTable (ruta de cadena)    
 {

     //Cadena de conexión

     string connstring = "Proveedor = Microsoft.ACE.OLEDB.12.0; Fuente de datos =" + ruta + "; Propiedades extendidas = 'Excel 8.0; HDR = NO; IMEX = 1';";  
     //el mismo nombre 
     // string connstring = Provider = Microsoft.JET.OLEDB.4.0; Data Source = "+ path + //"; Extended Properties = 'Excel 8.0; HDR = NO; IMEX = 1'; "; 

     utilizando (OleDbConnection conn = new OleDbConnection (connstring))
     {
        conn.Open ();
        // Obtener el nombre de todas las hojas
        DataTable sheetName = conn.GetOleDbSchemaTable (OleDbSchemaGuid.Tables, nuevo objeto [] {null, null, null, "Table"});  

        // Obtenga el nombre de la primera hoja
        string firstSheetName = sheetName.Rows [0] [2] .ToString (); 

        // Cadena de consulta 
        string sql = string.Format ("SELECT * FROM [{0}]", firstSheetName); 
        OleDbDataAdapter ada = new OleDbDataAdapter (sql, connstring);
        Conjunto de conjunto de datos = nuevo conjunto de datos ();
        ada.Fill (conjunto);
        conjunto de retorno. Tablas [0];   
   }
 }

El código es del artículo: http://www.c-sharpcorner.com/uploadfile/d2dcfc/read-excel-file-with-net/ . Puede obtener más detalles al respecto.

No es gratis, pero con la última versión de Office hay una muy buena automatización .Net API. (ha habido una API durante mucho tiempo pero fue una COM desagradable) Puede hacer todo lo que quiera / necesite en el código todo mientras la aplicación de Office siga siendo un proceso oculto en segundo plano.

Perdóname si estoy fuera de la base aquí, pero ¿no es esto para lo que son los PIA de Office ?

Últimamente, en parte para mejorar en LINQ ... He estado usando la API de automatización de Excel para guardar el archivo como hoja de cálculo XML y luego procesar ese archivo usando LINQ to XML.

SpreadsheetGear for .NET es un componente de hoja de cálculo compatible con Excel para .NET. Puede ver lo que dicen nuestros clientes sobre el rendimiento en el lado derecho de nuestra página de productos . Puede probarlo usted mismo con la evaluación gratuita y totalmente funcional .

SmartXLS es otro componente de hoja de cálculo de Excel que admite la mayoría de las características de Gráficos de Excel, motores de fórmulas y puede leer / escribir el formato opencel de Excel2007.

El componente .NET Excel Reader .NET puede satisfacer sus requisitos. Es lo suficientemente bueno para leer archivos XLSX y XLS. Así que pruébalo desde:

http://www.devtriogroup.com/ExcelReader

Recomiendo FileHelpers Library, que es una biblioteca .NET gratuita y fácil de usar para importar / exportar datos desde EXCEL, longitud fija o registros delimitados en archivos, cadenas o secuencias + Más.

La sección de documentación del enlace de datos de Excel http://filehelpers.sourceforge.net/example_exceldatalink.html

Puede intentar usar esta solución de código abierto que hace que tratar con Excel sea mucho más limpio.

http://excelwrapperdotnet.codeplex.com/

SpreadsheetGear es asombroso. Sí, es un gasto, pero en comparación con jugar con estas otras soluciones, vale la pena el costo. Es rápido, confiable, muy completo, y debo decir que después de usar este producto en mi trabajo de software a tiempo completo durante más de un año y medio, ¡su atención al cliente es fantástica!

La solución que utilizamos necesitaba:

• Permitir lectura / escritura de archivos producidos en Excel
• Sea rápido en rendimiento (no como usar COM)
• Sea independiente de MS Office (debe ser utilizable sin clientes que tengan instalado MS Office)
• Ser libre o de código abierto (pero desarrollado activamente)

Hay varias opciones, pero encontramos que NPoi (puerto .NET del proyecto de código abierto Poi existente de Java ) es el mejor: http://npoi.codeplex.com/

También permite trabajar con formatos de archivo .doc y .ppt

Si solo se trata de datos tabulares. Recomendaría los ayudantes de datos de archivos de Marcos Melli que se pueden descargar aquí .

Tarde a la fiesta, pero soy fanático de LinqToExcel

podría escribir una hoja de cálculo de Excel que cargue una hoja de cálculo de Excel dada y la guarde como csv (en lugar de hacerlo manualmente).

entonces podrías automatizar eso desde c #.

y una vez que está en csv, el programa c # puede asimilar eso.

(también, si alguien le pide que programe en Excel, es mejor fingir que no sabe cómo)

(Editar: ah sí, Rob y Ryan tienen razón)

Sé que la gente ha estado haciendo una "extensión" de Excel para este propósito.
Más o menos crea un botón en Excel que dice "Exportar al programa X", y luego exporta y envía los datos en un formato que el programa pueda leer.

http://msdn.microsoft.com/en-us/library/ms186213.aspx debería ser un buen lugar para comenzar.

Buena suerte

Acabo de hacer un proyecto de demostración rápida que requería administrar algunos archivos de Excel. El componente .NET del software GemBox fue adecuado para mis necesidades. Tiene una versión gratuita con algunas limitaciones.

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

Excel Package es un componente de código abierto (GPL) para leer / escribir archivos de Excel 2007. Lo utilicé en un proyecto pequeño y la API es sencilla. Funciona solo con XLSX (Excel 200 y), no con XLS.

El código fuente también parece estar bien organizado y es fácil de manejar (si necesita ampliar la funcionalidad o solucionar problemas menores como lo hice yo).

Al principio, probé el enfoque ADO.Net (cadena de conexión de Excel), pero estaba lleno de trucos desagradables; por ejemplo, si la segunda fila contiene un número, devolverá entradas para todos los campos de la columna a continuación y soltará silenciosamente cualquier dato Eso no encaja.

Usamos ClosedXML en sistemas bastante grandes.

• Gratis
• Fácil de instalar
• Codificación directa
• Soporte muy receptivo
• El equipo de desarrolladores está extremadamente abierto a nuevas sugerencias. A menudo, las nuevas funciones y correcciones de errores se implementan en la misma semana.

Take.ioLa hoja de cálculo hará este trabajo por usted, y sin cargo. Solo mira esto .

Acabo de usar ExcelLibrary para cargar una hoja de cálculo .xls en un DataSet. Funcionó muy bien para mí.