C# para leer archivos de Excel y exportar datos a DataTable y base de datos

Los archivos de Excel siguen siendo un formato omnipresente para almacenar datos tabulares, lo que hace que la capacidad de leer y extraer información de ellos de manera eficiente sea crucial. C#, que se beneficia de la amplia funcionalidad de .NET Framework, es capaz de realizar una manipulación de datos eficiente. Utilizando C# para leer archivos de Excel y escribir sus datos en bases de datos y tablas de datos, o utilizar los datos para otros fines, es una excelente solución para que los desarrolladores manipulen datos de Excel.

Este artículo se centra en cómo utilizar C# para leer archivos de Excel. Incluye las siguientes partes:

• Ventajas y API para leer archivos de Excel en C#
• Comenzando con la lectura de archivos de Excel usando C#
• Leer archivos de Excel en texto con código C#
• Script en C# para leer archivos de Excel en DataTable
• Código C# para leer archivos de Excel e insertarlos en bases de datos
• Obtenga una licencia gratuita para la API

Ventajas y API para leer archivos de Excel en C#

Aprovechar C# para leer archivos de Excel ofrece las siguientes ventajas:

• Automatización y escalabilidad: C#, con .NET Framework y API, permite automatizar tareas de lectura de archivos Excel, posibilitando procesar grandes volúmenes de datos de manera eficiente. Los desarrolladores pueden crear scripts o aplicaciones que puedan manejar el procesamiento por lotes, tareas programadas u operaciones de importación/exportación de datos, ahorrando tiempo y esfuerzo.
• Flexibilidad y personalización: .NET Framework junto con las API proporciona un alto nivel de flexibilidad y personalización al trabajar con archivos de Excel. Los desarrolladores pueden definir una lógica personalizada para extraer y transformar datos, aplicar formatos específicos o realizar cálculos. Esto permite adaptar el proceso de lectura a requisitos específicos o reglas comerciales.

Sin embargo, leer archivos de Excel sólo con C# y .NET Framework puede ser una tarea desafiante. La biblioteca nativa proporcionada por .NET Framework para manejar archivos de Excel es Microsoft.Office.Interop.Excel. Sin embargo, el uso de esta biblioteca requiere la instalación de MS Excel, y la lógica del código para procesar archivos de Excel es extremadamente compleja, lo que dificulta la lectura eficiente de archivos de Excel. Como resultado, los desarrolladores prefieren bibliotecas de terceros para trabajar con archivos de Excel de manera eficiente y conveniente.

Spire.XLS for .NET es una API C# profesional para el procesamiento de archivos Excel. Cuenta con soporte de formato extenso y manipulación eficiente de datos de Excel, incluida la lectura de archivos de Excel y la escritura de datos en bases de datos, tablas de datos, etc. Descargue Spire.XLS for .NET desde el sitio oficial o instálelo a través de NuGet.

PM> Install-Package Spire.XLS

Comenzando con la lectura de archivos de Excel en C#

Spire.XLS for .NET permite a los desarrolladores crear, leer, escribir y manipular archivos de Excel en sus aplicaciones .NET con código simple.

Para trabajar eficazmente con Spire.XLS, interactuará con varias clases, propiedades y métodos. A continuación se muestra una tabla que resume algunos de los principales junto con sus descripciones:

El flujo de trabajo típico de usar Spire.XLS for .NET para leer archivos de Excel implica estos pasos:

1. Cargue el archivo de Excel usando el método Workbook.LoadFromFile().
2. Acceda a las hojas de trabajo a través de la propiedad Workbook.Worksheets[].
3. Acceda a las celdas a través de la propiedad Worksheet.Range[].
4. Acceda al texto mostrado en las celdas a través de la propiedad CellRange.Text o acceda al valor de las celdas (texto, números, fórmulas, etc.) a través de la propiedad CellRange.Value
5. Recupere los datos, escríbalos en archivos de texto, bases de datos, etc., o realice otras operaciones deseadas.
6. Para exportar valores de celda a una tabla de datos, los desarrolladores pueden usar directamente el método Worksheet.ExportDataTable() y devolverá un objeto DataTable.
7. Alternativamente, los desarrolladores también pueden convertir directamente el libro de trabajo utilizando el método Workbook.SaveToFile() a cualquier formato compatible.

En resumen, esta API proporciona clases y propiedades que permiten a los desarrolladores cargar archivos de Excel y leer su contenido usando código sencillo, lo que hace que la lectura de archivos de Excel con C# sea eficiente y sencilla. Además, permite dirigir conversión de libros y hojas de trabajo a PDF, HTML, XML y otros formatos de archivo.

C# para leer archivos de Excel en texto

Pasos para leer archivos de Excel y escribir los datos en archivos de texto con C#:

1. Importe los espacios de nombres necesarios.
2. Cree un objeto de la clase Workbook y cargue un archivo de Excel usando el método Workbook.LoadFromFile().
3. Obtenga la primera hoja de trabajo a través de la propiedad Workbook.Worksheets[].
4. Cree un archivo de texto para escribir los datos en la hoja de trabajo.
5. Itere a través de las filas y columnas asignadas, acceda a las celdas a través de la propiedad Worksheet.Range[], obtenga el texto mostrado de cada celda a través de la propiedad CellRange.Text y escríbalo en el archivo de texto.
6. Liberar recursos.

Ejemplo de código:

using Spire.Xls;
    using System.IO;
    
    class Program
    {
        static void Main(string[] args)
        {
            // Load the Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile("Sample.xlsx");
    
            // Get the first worksheet
            Worksheet worksheet = workbook.Worksheets[0];
    
            // Create an output text file
            string outputFile = "Output.txt";
            StreamWriter writer = new StreamWriter(outputFile);
    
            // Iterate through the rows and columns of the worksheet and write the data to the text file
            for (int row = 1; row <= worksheet.LastRow; row++)
            {
                for (int col = 1; col <= worksheet.LastColumn; col++)
                {
                    CellRange range = worksheet.Range[row, col];
                    string cellValue = range.Text == null ? string.Empty : range.Text.ToString();
                    writer.Write(cellValue + "\t"); // Separate cell data using a tab character
                }
                writer.WriteLine(); // Write a line break
            }
    
            // Close the writer and save the text file
            writer.Close();
    
            // Release resources
            workbook.Dispose();
        }
    }

The reading result:

Código en C Sharp para leer archivos de Excel en tablas de datos

DataTable es un objeto que representa una tabla de datos en .NET Framework. Se utiliza para almacenar y manipular datos en la memoria y puede realizar operaciones como ordenar, filtrar, modificar y exportar. Los desarrolladores pueden usar C# para leer datos de archivos de Excel y escribirlos en el objeto DataTable, lo que facilita el procesamiento posterior de los datos. Los siguientes son los pasos:

1. Importe los espacios de nombres necesarios.
2. Cree un objeto de la clase Workbook y cargue un archivo de Excel usando el método Workbook.LoadFromFile().
3. Obtenga la primera hoja de trabajo a través de la propiedad Workbook.Worksheets[].
4. Exporte los datos de la hoja de trabajo a un objeto DataTable utilizando el método Worksheet.ExportDataTable().
5. Liberar recursos.

Ejemplo de código:

using Spire.Xls;
    using System.Data;
    
    namespace ExcelToAccess
    {
        class Program
        {
            static void Main(string[] args)
            {
                // Create an object of Workbook class
                Workbook workbook = new Workbook();
    
                // Load an Excel file
                workbook.LoadFromFile("Sample.xlsx");
    
                // Get the first worksheet
                Worksheet worksheet = workbook.Worksheets[0];
    
                // Export the data from the worksheet to a DataTable object
                DataTable dataTable = worksheet.ExportDataTable();
    
                workbook.Dispose();
            }
        }
    }

Código C# para leer archivos de Excel e insertarlos en bases de datos

Este ejemplo muestra cómo usar código C# para escribir datos de una hoja de cálculo de Excel en una base de datos usando una base de datos de Access. Este método también requiere el espacio de nombres System.Data.OleDB. Si el .NET Framework que estás utilizando no lo tiene, puedes instalarlo ingresando el siguiente código en la Consola de administración de paquetes:

Install-Package System.Data.OleDb

Los pasos para leer un archivo Excel e insertarlo en una base de datos son los siguientes:

1. Importe los espacios de nombres necesarios.
2. Cree un objeto de la clase Workbook y cargue un archivo de Excel usando el método Workbook.LoadFromFile().
3. Recupere la primera hoja de trabajo con la propiedad Workbook.Worksheets[].
4. Obtenga el nombre de la hoja de trabajo como nombre de la tabla accediendo a la propiedad Worksheet.Name.
5. Recupere la primera fila como nombres de columna accediendo al objeto CellRange de la primera fila con la propiedad Worksheet.Rows[] y almacenando el valor de cada columna en una matriz de cadenas.
6. Conéctese a la base de datos de Access utilizando OleDbConnection especificando la cadena de conexión y la ruta del archivo de la base de datos.
7. Cree la tabla de datos generando dinámicamente una cadena de consulta SQL para crear la tabla, incluido el nombre de la tabla, los nombres de las columnas y los tipos de datos.
8. Ejecute la consulta de creación de tabla utilizando un objeto OleDbCommand y el método ExecuteNonQuery.
9. Inserte los datos iterando a través de cada fila de la hoja de cálculo de Excel (comenzando desde la segunda fila) y construyendo una declaración de inserción con consultas parametrizadas. Inserte cada fila de datos en la tabla de la base de datos de Access.
10. Cierre la conexión de la base de datos y libere recursos.

Ejemplo de código:

using Spire.Xls;
    using System.Data.OleDb;
    
    class Program
    {
        static void Main(string[] args)
        {
            // Set the Excel file path
            string excelFilePath = "Sample.xlsx";
            // Set the Access database file path
            string accessDbFilePath = "Sample.accdb";
    
            // Load the Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile(excelFilePath);
    
            // Get the first worksheet
            Worksheet worksheet = workbook.Worksheets[0];
    
            // Use the worksheet name as the table name
            string tableName = worksheet.Name;
    
            // Get the first row as column names
            CellRange headerRange = worksheet.Rows[0];
            string[] columnNames = new string[headerRange.Columns.Length];
            for (int i = 0; i < headerRange.Columns.Length; i++)
            {
                columnNames[i] = headerRange.Columns[i].Value.Replace(" ", "_");
            }
    
            // Connect to the Access database
            string connectionString = $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={accessDbFilePath};Persist Security Info=False;";
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                connection.Open();
    
                // Create the table
                string createTableQuery = $"CREATE TABLE [{tableName}] ({string.Join(", ", columnNames.Select(c => $"[{c}] Memo"))})";
                using (OleDbCommand createTableCommand = new OleDbCommand(createTableQuery, connection))
                {
                    createTableCommand.ExecuteNonQuery();
                }
    
                // Insert data
                string insertQuery = $"INSERT INTO [{tableName}] ({string.Join(", ", columnNames.Select(c => $"[{c}]"))}) VALUES ({string.Join(", ", columnNames.Select(c => $"@{c}"))})";
                using (OleDbCommand insertCommand = new OleDbCommand(insertQuery, connection))
                {
                    foreach (CellRange row in worksheet.Rows.Cast().Skip(1))
                    {
                        for (int i = 0; i < row.Columns.Length; i++)
                        {
                            insertCommand.Parameters.AddWithValue($"@{columnNames[i]}", row.Columns[i].Value);
                        }
    
                        insertCommand.ExecuteNonQuery();
                        insertCommand.Parameters.Clear();
                    }
                }
    
                connection.Close();
                workbook.Dispose();
            }
        }
    }

El resultado de la lectura e inserción:

Obtenga una licencia gratuita para la API

Spire.XLS for .NET proporciona una licencia de prueba gratuita que permite a los desarrolladores, empresas y usuarios individuales explorar sus potentes capacidades de procesamiento de archivos Excel sin restricciones de uso ni marcas de agua. Por obtener una licencia gratuita, Los usuarios pueden maximizar el potencial de Spire.XLS for .NET, ampliar sus capacidades de manejo de archivos y mejorar significativamente su eficiencia en el procesamiento de archivos Excel.

Conclusión

En este artículo, exploramos cómo use C# para leer archivos de Excel y extraer datos para diversos fines. Al aprovechar las poderosas funciones de Spire.XLS for .NET, los desarrolladores pueden manipular eficientemente datos de Excel, exportarlos a diferentes formatos y mejorar las aplicaciones basadas en datos. Con instrucciones paso a paso, ejemplos de código y presentaciones gráficas de los resultados del procesamiento, esta guía ayuda a optimizar la eficiencia del procesamiento de archivos y desbloquear todo el potencial del análisis de datos en proyectos de C#.

• Extraiga texto de imágenes o PDF escaneado con C#
• Convertir PDF a HTML con código Python
• Aplicar formato condicional en Excel con Python
• Convierta PDF a texto sin esfuerzo con código Python