Cómo trabajar con archivos de Excel en C#

Introducción

Trabajar con archivos de Microsoft Excel en lenguajes de programación se ha convertido en un requisito importante en el paradigma moderno de programación actual. La generación de Excel es necesaria para la automatización, el análisis de datos, la medición de la productividad, informes, etc. IronXL de Iron Software es una poderosa biblioteca C# que permite a los desarrolladores leer, escribir y manipular documentos de Excel sin necesidad de tener Microsoft Excel instalado en la máquina, en cualquier aplicación como servicios web, consola, escritorio, etc. Esto lo convierte en una excelente opción para aplicaciones que necesitan manejar datos de Excel de manera eficiente y efectiva. En este artículo, exploraremos cómo usar IronXL para trabajar con archivos de Excel en C#.

Cómo trabajar con un libro de Excel en C

1. Cree un proyecto de Visual Studio y agregue el paquete NuGet de IronXL.

2. Crea un archivo de Excel sin Interop.

3. Añadir estilo al archivo de Excel usando IronXL.

4. Leer valores de Excel y calcular.

5. Convertir Excel a HTML para uso web.

Presentamos la biblioteca IronXL

IronXL es una biblioteca robusta para .NET que simplifica el trabajo con archivos de Excel. IronXL es una potente biblioteca .NET diseñada para crear, leer y editar archivos de Excel sin esfuerzo. Cuenta con una API intuitiva que simplifica el trabajo con documentos de Excel, compatible con varios formatos como XLS, XLSX y CSV. Esta versatilidad permite una fácil manipulación de valores de celdas, fórmulas y formato. IronXL está optimizado para el rendimiento y es capaz de manejar eficientemente archivos grandes y operaciones de datos complejas, al tiempo que garantiza un uso eficiente de la memoria. Su compatibilidad multiplataforma mejora su utilidad, convirtiendo a IronXL en una herramienta invaluable para los desarrolladores en diferentes sistemas operativos. Aquí están algunas de sus características y beneficios clave:

Características principales

1. Importar y Exportar: 1. Importar Datos: Compatible con formatos XLS, XLSX, CSV y TSV.

2. Exportar datos: Puede exportar hojas de trabajo a los formatos XLS, XLSX, CSV, TSV y JSON.

3. Manipulación de Datos:

4. Integración con System.Data: Trabaja con hojas de cálculo como objetos `System.Data.DataSet` y `System.Data.DataTable`.

5. Fórmulas: Admite fórmulas de Excel, que se recalculan cada vez que se edita una hoja.

6. Estilo y Formato:

7. Estilo de celdas: personaliza la fuente, tamaño, patrón de fondo, borde, alineación y formatos numéricos.

8. Rangos: Configuración de rangos intuitiva con `WorkSheet`["A1:B10"]`sintaxis.

9. Seguridad:

   Cifrado: Cifre y descifre archivos XLSX, XLSM y XLTX con contraseñas.5. Compatibilidad multiplataforma: 1. Funciona con .NET Framework, .NET Core, .NET Standard y Azure.2. Compatible con Windows, macOS, Linux, Docker, Azure y AWS.

Beneficios

1. No se necesita Microsoft Office: IronXL no requiere que Microsoft Office esté instalado, lo que lo hace ligero y fácil de desplegar.

2. Facilidad de uso: La API es intuitiva y fácil de usar, lo que permite a los desarrolladores integrar rápidamente la funcionalidad de Excel en sus aplicaciones. Rendimiento: IronXL está optimizado para el rendimiento, asegurando un procesamiento rápido y eficiente de archivos Excel grandes.

3. Versatilidad: Adecuado para una amplia gama de aplicaciones, incluidas soluciones web, de escritorio y basadas en la nube. Documentación completa: Documentación extensa y ejemplos disponibles, lo que facilita a los desarrolladores comenzar y encontrar soluciones a problemas comunes.

Primeros pasos

Para usar IronXL en sus proyectos .NET, debe asegurarse de que su entorno de desarrollo cumpla con los siguientes requisitos previos:

Requisitos previos

1. .NET Framework: IronXL admite tecnologías .NET Framework 4.5 y superiores.

2. .NET Core y .NET Standard: Compatible con .NET Core 2, 3, 5, 6, 7, 8 y 9. Soporta .NET Standard 2.0 y 2.1.

3. Sistemas operativos: Funciona en Windows, macOS y Linux. Compatible con entornos Docker, Azure y AWS.

4. No se necesita Microsoft Office: IronXL no requiere que Microsoft Office o Excel Interop estén instalados.

5. Editor de código: Cualquier editor de código c# visual como Visual Studio, etc.

Instalación

Puedes instalar IronXL a través del Administrador de Paquetes NuGet en Visual Studio o utilizando la Consola del Administrador de Paquetes con el siguiente comando:

dotnet add package IronXL.Excel --version 2024.8.5

dotnet add package IronXL.Excel --version 2024.8.5

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronXL.Excel --version 2024.8.5

Cómo trabajar con un libro de Excel en C

Para comenzar a trabajar con un archivo de Excel, primero, desarrollemos un proyecto de Visual Studio y agreguemos la biblioteca IronXL.

Paso 1: Crea un proyecto de Visual Studio y agrega el paquete NuGet de IronXL

Abre Microsoft Visual Studio y selecciona la opción 'Crear un nuevo proyecto' para comenzar a crear el proyecto.

Seleccione la plantilla de proyecto de su elección, aquí hemos seleccionado la aplicación de consola por simplicidad.

Ahora ingrese el nombre y la ubicación del proyecto.

Seleccione la versión de .NET Framework que prefiera. Hemos seleccionado la última disponible en nuestra máquina.

Una vez que se haga clic en el botón Crear, el proyecto se creará y estará listo para su uso. Abra el Explorador de Soluciones para verificar los archivos del proyecto.

Ahora, instalemos la biblioteca IronXL desde el administrador de paquetes NuGet como se muestra arriba.

Paso 2: Crear un archivo Excel sin Interop

Ahora, vamos a crear un archivo Excel sin utilizar la biblioteca Microsoft Interop.

using IronXL;
namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create new Excel WorkBook Object
            WorkBook workBook = WorkBook.Create();
            // Create WorkSheet
            WorkSheet workSheet = workBook.CreateWorkSheet("newXlDemo");
            // Add data in new worksheet
            workSheet["A1"].Value = "IronXL is the best Excel library";           
            // Save the Excel file as XLSX
            workBook.SaveAs("myIronXlDemo.xlsx");
        }
    }
}

using IronXL;
namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create new Excel WorkBook Object
            WorkBook workBook = WorkBook.Create();
            // Create WorkSheet
            WorkSheet workSheet = workBook.CreateWorkSheet("newXlDemo");
            // Add data in new worksheet
            workSheet["A1"].Value = "IronXL is the best Excel library";           
            // Save the Excel file as XLSX
            workBook.SaveAs("myIronXlDemo.xlsx");
        }
    }
}

Imports IronXL
Namespace WorkingWithIronXL
	Public Class Program
		Public Shared Sub Main()
			' Create new Excel WorkBook Object
			Dim workBook As WorkBook = WorkBook.Create()
			' Create WorkSheet
			Dim workSheet As WorkSheet = workBook.CreateWorkSheet("newXlDemo")
			' Add data in new worksheet
			workSheet("A1").Value = "IronXL is the best Excel library"
			' Save the Excel file as XLSX
			workBook.SaveAs("myIronXlDemo.xlsx")
		End Sub
	End Class
End Namespace

Explicación del código

1. Agregamos el espacio de nombres de IronXL para comenzar a trabajar con la biblioteca.

2. Luego creamos un objeto Excel para crear un archivo XLSX con WorkBook.Create.();

3. Luego se llama al método CreateWorkSheet para crear una hoja de cálculo dentro del libro de trabajo.

4. Agregar valores a la celda usando workSheet["A1"]

5. Luego, guarde el Excel utilizando workBook.SaveAs proporcionando un nombre para el archivo.

   Archivo Excel de salida

   

Paso 3: Agregar estilo al archivo Excel usando IronXL

Ahora veamos cómo agregar estilos a las celdas de Excel.

using IronXL;
namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
         {
            // Create a new workbook
            WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
            // Create a new worksheet
            WorkSheet workSheet = workBook.CreateWorkSheet("StyledSheet");
            // Add multiple values to cells
            workSheet["A1"].Value = "This Styled Text with Awesome IronXL library";
            workSheet["A2"].Value = 999999;
            // Apply styles to cells
            workSheet["A1"].Style.Font.Bold = true;
            workSheet["A1"].Style.Font.Italic = true;
            workSheet["A1"].Style.Font.Height = 14;
            workSheet["A1"].Style.Font.Color = "#FF0000"; // Red color
            workSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Double;
            workSheet["A2"].Style.BottomBorder.SetColor("#00FF00"); // Green color
            // Save the workbook
            workBook.SaveAs("myIronXlWriteDemo.xlsx");
        }
    }
}

using IronXL;
namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
         {
            // Create a new workbook
            WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
            // Create a new worksheet
            WorkSheet workSheet = workBook.CreateWorkSheet("StyledSheet");
            // Add multiple values to cells
            workSheet["A1"].Value = "This Styled Text with Awesome IronXL library";
            workSheet["A2"].Value = 999999;
            // Apply styles to cells
            workSheet["A1"].Style.Font.Bold = true;
            workSheet["A1"].Style.Font.Italic = true;
            workSheet["A1"].Style.Font.Height = 14;
            workSheet["A1"].Style.Font.Color = "#FF0000"; // Red color
            workSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Double;
            workSheet["A2"].Style.BottomBorder.SetColor("#00FF00"); // Green color
            // Save the workbook
            workBook.SaveAs("myIronXlWriteDemo.xlsx");
        }
    }
}

Imports IronXL
Namespace WorkingWithIronXL
	Public Class Program
		Public Shared Sub Main()
			' Create a new workbook
			Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
			' Create a new worksheet
			Dim workSheet As WorkSheet = workBook.CreateWorkSheet("StyledSheet")
			' Add multiple values to cells
			workSheet("A1").Value = "This Styled Text with Awesome IronXL library"
			workSheet("A2").Value = 999999
			' Apply styles to cells
			workSheet("A1").Style.Font.Bold = True
			workSheet("A1").Style.Font.Italic = True
			workSheet("A1").Style.Font.Height = 14
			workSheet("A1").Style.Font.Color = "#FF0000" ' Red color
			workSheet("A2").Style.BottomBorder.Type = IronXL.Styles.BorderType.Double
			workSheet("A2").Style.BottomBorder.SetColor("#00FF00") ' Green color
			' Save the workbook
			workBook.SaveAs("myIronXlWriteDemo.xlsx")
		End Sub
	End Class
End Namespace

Explicación del código

1. Crea un archivo Excel usando WorkBook.Create

2. Crea una hoja de trabajo utilizando workBook.CreateWorkSheet

3. Agregar valores a celdas usando workSheet["A1"].Valor

4. Agrega estilos a cada celda usando las propiedades de la celda como workSheet["A1"].Style.Font.Bold

5. Guarde el libro de trabajo utilizando workBook.SaveAs

   Archivo Excel de Salida

   

Paso 4: Leer valores de Excel y calcular

Ahora que hemos visto cómo crear archivos Excel, veamos el siguiente código sobre cómo podemos leer archivos Excel usando IronXL y realizar algunos cálculos en memoria.

using IronXL;
namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ReadData()
        {
            // Load the Excel worksheet
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            // Select the first worksheet
            WorkSheet workSheet = workBook.WorkSheets[0];
            // Read a specific cell value
            int cellValue = workSheet["A2"].IntValue;
            Console.WriteLine($"Value in A2: {cellValue}");
            // Read a range of cells
            foreach (var cell in workSheet["A1:H10"])
            {
                //Console.WriteLine($"Cell {cell.AddressString} has value '{cell.Text}'");
                Console.Write($"{cell.Text}\t");
                if(cell.AddressString.Contains("H"))
                {
                    Console.WriteLine();
                }
            }
            // Calculate aggregate values
            decimal sum = workSheet["F2:F10"].Sum();
            Console.WriteLine($"Sum of F2:F10: {sum}");
        }
}

using IronXL;
namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ReadData()
        {
            // Load the Excel worksheet
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            // Select the first worksheet
            WorkSheet workSheet = workBook.WorkSheets[0];
            // Read a specific cell value
            int cellValue = workSheet["A2"].IntValue;
            Console.WriteLine($"Value in A2: {cellValue}");
            // Read a range of cells
            foreach (var cell in workSheet["A1:H10"])
            {
                //Console.WriteLine($"Cell {cell.AddressString} has value '{cell.Text}'");
                Console.Write($"{cell.Text}\t");
                if(cell.AddressString.Contains("H"))
                {
                    Console.WriteLine();
                }
            }
            // Calculate aggregate values
            decimal sum = workSheet["F2:F10"].Sum();
            Console.WriteLine($"Sum of F2:F10: {sum}");
        }
}

Imports Microsoft.VisualBasic
Imports IronXL
Namespace WorkingWithIronXL
	Friend Class IronXlDemo
		Public Shared Sub ReadData()
			' Load the Excel worksheet
			Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
			' Select the first worksheet
			Dim workSheet As WorkSheet = workBook.WorkSheets(0)
			' Read a specific cell value
			Dim cellValue As Integer = workSheet("A2").IntValue
			Console.WriteLine($"Value in A2: {cellValue}")
			' Read a range of cells
			For Each cell In workSheet("A1:H10")
				'Console.WriteLine($"Cell {cell.AddressString} has value '{cell.Text}'");
				Console.Write($"{cell.Text}" & vbTab)
				If cell.AddressString.Contains("H") Then
					Console.WriteLine()
				End If
			Next cell
			' Calculate aggregate values
			Dim sum As Decimal = workSheet("F2:F10").Sum()
			Console.WriteLine($"Sum of F2:F10: {sum}")
		End Sub
	End Class

Código Explicación

1. Aquí tenemos los datos de los empleados guardados en el modelo de objetos de Excel, como se muestra a continuación.

2. Usando IronXL cargamos el archivo Excel en la memoria y leemos la primera hoja.

3. Luego iteramos a través de cada celda para obtener los valores y mostrarlos en la consola.

4. Luego calculamos la suma de las edades usando las celdas F2-F10 y luego la mostramos en la consola.

   Entrada de Excel

   

   Salida

   

Paso 5: Convertir Excel a HTML para uso web

Ahora que sabemos cómo generar, leer y escribir archivos Excel, veamos cómo convertir Excel a HTML para su uso en la web.

using IronXL;
using IronXL.Options;
namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ConvertToHtml()
        {
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            var options = new HtmlExportOptions()
            {
                // Set row/column numbers visible in HTML document
                OutputRowNumbers = true,
                OutputColumnHeaders = true,
                // Set hidden rows/columns visible in HTML document
                OutputHiddenRows = true,
                OutputHiddenColumns = true,
                // Set leading spaces as non-breaking
                OutputLeadingSpacesAsNonBreaking = true
            };
            // Export workbook to the HTML file
            workBook.ExportToHtml("workBook.html", options);
        }
}

using IronXL;
using IronXL.Options;
namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ConvertToHtml()
        {
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            var options = new HtmlExportOptions()
            {
                // Set row/column numbers visible in HTML document
                OutputRowNumbers = true,
                OutputColumnHeaders = true,
                // Set hidden rows/columns visible in HTML document
                OutputHiddenRows = true,
                OutputHiddenColumns = true,
                // Set leading spaces as non-breaking
                OutputLeadingSpacesAsNonBreaking = true
            };
            // Export workbook to the HTML file
            workBook.ExportToHtml("workBook.html", options);
        }
}

Imports IronXL
Imports IronXL.Options
Namespace WorkingWithIronXL
	Friend Class IronXlDemo
		Public Shared Sub ConvertToHtml()
			Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
			Dim options = New HtmlExportOptions() With {
				.OutputRowNumbers = True,
				.OutputColumnHeaders = True,
				.OutputHiddenRows = True,
				.OutputHiddenColumns = True,
				.OutputLeadingSpacesAsNonBreaking = True
			}
			' Export workbook to the HTML file
			workBook.ExportToHtml("workBook.html", options)
		End Sub
	End Class

Explicación del código

1. Aquí estamos cargando el Excel "sampleEmployeeData.xlsx" usando el método Load.

2. Luego configure las opciones para convertir a HTML usando HtmlExportOptions.

3. Luego usamos el método ExportToHtml para convertir a HTML.

   Entrada

   

   Salida

   

Casos prácticos reales

IronXL es una biblioteca .NET versátil con una amplia gama de aplicaciones del mundo real, incluyendo:

1. Informes Empresariales:

1. Automatización de la generación de informes periódicos, como resúmenes de ventas, estados financieros y métricas de rendimiento.

2. Crear paneles personalizados que extraen datos de diversas fuentes y los presentan en un formato de Excel.

   2. Análisis de Datos:

3. Procesamiento de grandes conjuntos de datos para realizar análisis estadísticos, limpieza de datos y transformación de datos.

4. Exportar datos analizados a Excel para un examen adicional y compartirlos con las partes interesadas.

   3. Gestión de Inventario:

5. Gestionar los inventarios de productos creando y actualizando hojas de Excel con niveles de stock, detalles de proveedores y puntos de reorden.

6. Generar informes de inventario para rastrear el movimiento de stock e identificar tendencias.

   4. Gestión de la Relación con el Cliente (CRM):

7. Exportar datos de clientes desde sistemas CRM a Excel para un análisis detallado e informes.

8. Actualización de registros de CRM mediante la importación de datos modificados desde archivos Excel.

   5. Instituciones Educativas:

9. Creación y mantenimiento de libros de calificaciones de estudiantes, registros de asistencia e informes de progreso.

10. Generación de resultados de exámenes y análisis detallado del rendimiento para profesores y estudiantes.

    6. Servicios Financieros:

11. Automatización de la creación de modelos financieros, presupuestos y previsiones en Excel.

12. Consolidar datos financieros de múltiples fuentes para un informe financiero integral.

    7. Recursos Humanos:

13. Gestión de datos de empleados, incluyendo detalles de contacto, información de nómina y evaluaciones de rendimiento.

14. Generación de informes sobre métricas de recursos humanos, como la plantilla, las tasas de rotación y la demografía de los empleados.

    8. Gestión de Proyectos:

15. Seguimiento de cronogramas de proyectos, hitos y asignación de recursos utilizando hojas de Excel.

16. Creando diagramas de Gantt y otras herramientas de gestión de proyectos directamente en Excel.

    9. Comercio electrónico:

17. Exportar detalles de pedidos, información de clientes y datos de ventas desde plataformas de comercio electrónico a Excel.

18. Analizando las tendencias de ventas, el comportamiento del cliente y el rendimiento del producto.

    10. Salud:

19. Administrar registros de pacientes, horarios de citas y planes de tratamiento en Excel.

20. Analizar datos de atención médica para identificar patrones y mejorar la atención al paciente.

Licenciamiento de IronXL

IronXL es una biblioteca empresarial que forma parte de la Iron Suite de productos de Iron Software. Requiere una licencia para funcionar. Los usuarios pueden descargar una licencia de prueba para trabajar usando su ID de correo electrónico desde aquí. Una vez que se ingresan los datos, la licencia se entrega al ID de correo electrónico proporcionado. Esta licencia debe colocarse al principio del código, antes de usar la biblioteca IronXL como se muestra a continuación.

License.LicenseKey = "your Key Here"

License.LicenseKey = "your Key Here"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'License.LicenseKey = "your Key Here"

Conclusión

IronXL es una potente biblioteca .NET para crear, leer y editar archivos de Excel, que ofrece una API intuitiva que simplifica el proceso de trabajar con documentos de Excel. Admite una amplia gama de formatos de Excel, incluidos XLS, XLSX y CSV, lo que lo hace versátil para diversos casos de uso. IronXL permite la manipulación sencilla de valores de celdas, fórmulas y formato, y está optimizado para el rendimiento, manejando de manera eficiente archivos grandes y operaciones complejas. Su gestión eficiente de memoria garantiza aplicaciones receptivas, y su compatibilidad multiplataforma lo convierte en una herramienta valiosa para los desarrolladores que trabajan en diferentes sistemas operativos.