COMPARACIóN CON OTROS COMPONENTES

Comparación entre IronXL y Epplus

Actualizado 23 de marzo, 2022
Compartir:

En este artículo examinamos las similitudes y diferencias entre los programas IronXL y EPPlus.

Para la mayoría de las organizaciones, Microsoft Excel ha demostrado ser una herramienta extremadamente útil. Los archivos de Excel, como las bases de datos, contienen datos en celdas, lo que facilita la gestión de los datos que deben almacenarse.

Excel también utiliza los formatos de archivo.xls y.xlsx. El lenguaje C# puede dificultar la gestión de archivos Excel. Sin embargo, los programas IronXL y EPPlus facilitan la gestión de estos procesos.

Este software no requiere Microsoft Office.

Tenga en cuenta que puede leer y crear archivos Excel en C# sin tener que instalar Microsoft Office. Hoy, vamos a ver algunas opciones diferentes que son fáciles de implementar.

¿Qué es el software EPPlus?

EPPlus es una biblioteca basada en NuGet .NET Framework/.NET Core para el manejo de hojas de cálculo Office Open XML. La versión 5 es compatible con .NET Framework 3.5 y .NET Core 2.0. EPPlus no depende de ninguna otra biblioteca, como Microsoft Excel.

EPPlus dispone de una API que permite trabajar con documentos de Office Excel. EPPlus es una biblioteca .NET que lee y escribe archivos Excel con formato Office OpenXML. Esta biblioteca está disponible como paquete en NuGet.

La biblioteca se creó pensando en los programadores. El objetivo siempre ha sido que un desarrollador familiarizado con Excel u otra biblioteca de hojas de cálculo pueda aprender rápidamente la API. Alternativamente, como alguien dijo, "IntelliSense su camino a la victoria!"

Instalación de EPPlus

Para instalar EPPlus desde Visual Studio, vaya a Ver > Otras ventanas > Consola del gestor de paquetes y escriba el siguiente comando:

PM> Install-Package EPPlus

Si prefiere utilizar la CLI de .NET, ejecute el siguiente comando desde un símbolo del sistema elevado o un símbolo de PowerShell:

PM> dotnet add paquete EPPlus

EPPlus es un paquete dotnet que puede añadir a su proyecto.

¿Qué es IronXL?

IronXL es una sencilla API de Excel para C# y VB que permite leer, editar y crear archivos de hojas de cálculo de Excel en .NET a la velocidad del rayo. No es necesario instalar Microsoft Office o incluso Excel Interop. Esta biblioteca también se puede utilizar para trabajar con archivos de Excel.

IronXL es compatible con .NET Core, .NET Framework, Xamarin, Mobile, Linux, macOS y Azure.

Hay varias formas de leer y escribir datos en una hoja de cálculo.

Adición de IronXL mediante el paquete NuGet

Podemos añadir el paquete IronXL a su cuenta de una de estas tres formas, para que pueda elegir la que mejor se adapte a sus necesidades.

  • Utilizando la Consola del Gestor de Paquetes para instalar IronXL

    Utilice el siguiente comando para abrir la consola del gestor de paquetes en su proyecto:

    Para acceder a la Consola del Gestor de Paquetes, ve a Herramientas => Gestor de Paquetes NuGet => Consola del Gestor de Paquetes.

    Accederá a la consola del gestor de paquetes. A continuación, en el terminal del Gestor de paquetes, escriba el siguiente comando:

PM > Install-Package IronXL.Excel

  • Uso del gestor de paquetes NuGet para instalar IronXL.

    Este es un enfoque diferente para conseguir el NuGet Package Manager instalado. No necesitará utilizar este método si ya ha completado la instalación con el método anterior.

    Para acceder al Gestor de Paquetes NuGet, ve a Herramientas > Gestor de Paquetes NuGet => Selecciona Gestionar Paquetes NuGet para Solución en el menú desplegable.

    Esto lanzará la solución NuGet; seleccione "Examinar" y busque IronXL.

    En la barra de búsqueda, escriba Excel:

    IronXL se instalará cuando haga clic en el botón "Instalar". Después de instalar IronXL puede ir a su formulario y comenzar a desarrollarlo.

Creación de un archivo Excel con IronXL

Crear un nuevo Libro de Excel con IronXL no podría ser más fácil! Es sólo una línea de código! Sí, es cierto:

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
VB   C#

IronXL puede crear archivos en XLS (la versión anterior del archivo Excel) y XLSX (versión actual y más reciente del archivo Excel) formatos.

  • **Establecer una hoja de cálculo por defecto

    Es aún más fácil configurar una hoja de cálculo por defecto:

    var hoja = libro.CrearHojaTrabajo("Presupuesto 2020");

    La hoja de cálculo está representada por "Hoja" en el fragmento de código anterior, y puede utilizarla para establecer valores de celda y hacer prácticamente todo lo que Excel puede hacer. También puede codificar su documento Excel en un archivo de sólo lectura y realizar operaciones de borrado. También puedes vincular tus hojas de cálculo, como hace Excel.

    Permíteme aclarar la diferencia entre un libro de trabajo y una hoja de cálculo por si no estás seguro.

    Las hojas de trabajo están contenidas en un libro de trabajo. Esto significa que puedes poner tantas hojas de trabajo dentro de un libro como quieras. Explicaré cómo hacerlo en un artículo posterior. Las filas y columnas forman una hoja de cálculo. La intersección de una fila y una columna se conoce como celda, y es con ella con la que interactuará dentro de Excel.

Creación de un archivo Excel con Epplus Software AB

EPPlus puede utilizarse para crear archivos Excel y realizar operaciones como la creación de tablas dinámicas, áreas dinámicas e incluso el formato condicional y el cambio de fuentes. Sin más preámbulos, aquí está todo el código fuente para convertir un DataTable normal en un archivo XLSX de Excel y enviarlo al usuario para su descarga:

public ActionResult ConvertToXLSX()
{
    byte [] fileData = null;

    //  sustituya el método GetDataTable() por su código de obtención del DBMS.
    using (DataTable dt = GetDataTable())
    {
        //  crear una hoja de cálculo vacía
        using (var p = new ExcelPackage())
        {
            //  añadir una hoja de cálculo a la hoja de cálculo
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            //  Inicializa los contadores de filas y columnas: ¡ten en cuenta que están basados en 1!
            var row = 1;
            var col = 1;

            //  Cree los nombres de las columnas en la primera línea.
            //  En este ejemplo sólo utilizaremos los nombres de las columnas de DataTable
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            //  Insertar las filas de la DataTable en el archivo XLS
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r [dc].ToString());
                }

                //  alterne el color gris claro para las filas desiguales (3, 5, 7, 9)...
                if (row % 2 != 0)
                {
                    ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                }
            }

            //  salida del archivo XLSX
            using (var ms = new MemoryStream())
            {
                p.SaveAs(ms);
                ms.Seek(0, SeekOrigin.Begin);
                fileData = ms.ToArray();
            }
        }
    }

    string fileName = "ConvertedFile.xlsx";
    string contentType = System.Web.MimeMapping.GetMimeMapping(fileName);
    Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
    return File(fileData, contentType);
}
public ActionResult ConvertToXLSX()
{
    byte [] fileData = null;

    //  sustituya el método GetDataTable() por su código de obtención del DBMS.
    using (DataTable dt = GetDataTable())
    {
        //  crear una hoja de cálculo vacía
        using (var p = new ExcelPackage())
        {
            //  añadir una hoja de cálculo a la hoja de cálculo
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            //  Inicializa los contadores de filas y columnas: ¡ten en cuenta que están basados en 1!
            var row = 1;
            var col = 1;

            //  Cree los nombres de las columnas en la primera línea.
            //  En este ejemplo sólo utilizaremos los nombres de las columnas de DataTable
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            //  Insertar las filas de la DataTable en el archivo XLS
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r [dc].ToString());
                }

                //  alterne el color gris claro para las filas desiguales (3, 5, 7, 9)...
                if (row % 2 != 0)
                {
                    ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                }
            }

            //  salida del archivo XLSX
            using (var ms = new MemoryStream())
            {
                p.SaveAs(ms);
                ms.Seek(0, SeekOrigin.Begin);
                fileData = ms.ToArray();
            }
        }
    }

    string fileName = "ConvertedFile.xlsx";
    string contentType = System.Web.MimeMapping.GetMimeMapping(fileName);
    Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
    return File(fileData, contentType);
}
Public Function ConvertToXLSX() As ActionResult
	Dim fileData() As Byte = Nothing

	'  sustituya el método GetDataTable() por su código de obtención del DBMS.
	Using dt As DataTable = GetDataTable()
		'  crear una hoja de cálculo vacía
		Using p = New ExcelPackage()
			'  añadir una hoja de cálculo a la hoja de cálculo
			Dim ws As ExcelWorksheet = p.Workbook.Worksheets.Add(dt.TableName)

			'  Inicializa los contadores de filas y columnas: ¡ten en cuenta que están basados en 1!
			Dim row = 1
			Dim col = 1

			'  Cree los nombres de las columnas en la primera línea.
			'  En este ejemplo sólo utilizaremos los nombres de las columnas de DataTable
			row = 1
			col = 0
			For Each dc As DataColumn In dt.Columns
				col += 1
				ws.SetValue(row, col, dc.ColumnName)
			Next dc

			'  Insertar las filas de la DataTable en el archivo XLS
			For Each r As DataRow In dt.Rows
				row += 1
				col = 0
				For Each dc As DataColumn In dt.Columns
					col += 1
					ws.SetValue(row, col, r (dc).ToString())
				Next dc

				'  alterne el color gris claro para las filas desiguales (3, 5, 7, 9)...
				If row Mod 2 <> 0 Then
					ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid
					ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray)
				End If
			Next r

			'  salida del archivo XLSX
			Using ms = New MemoryStream()
				p.SaveAs(ms)
				ms.Seek(0, SeekOrigin.Begin)
				fileData = ms.ToArray()
			End Using
		End Using
	End Using

	Dim fileName As String = "ConvertedFile.xlsx"
	Dim contentType As String = System.Web.MimeMapping.GetMimeMapping(fileName)
	Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName))
	Return File(fileData, contentType)
End Function
VB   C#

Como puede ver, se trata de un método ActionResult que puede utilizarse en cualquier controlador MVC de ASP.NET; si no utiliza ASP.NET MVC, simplemente copie el contenido del método y péguelo donde lo necesite (ASP.NET clásico, aplicación de consola, Windows Forms, etc.).

El código se explica por sí mismo, con suficientes comentarios para ayudarle a entender los distintos procesos de tratamiento. Pero primero, un breve resumen de lo que estamos haciendo aquí:

  • Usando un método personalizado de Data Provider, obtenemos un objeto DataTable.
  • Construimos un objeto ExcelPackage, que es el contenedor primario de EPPlus para el archivo XLSX.
  • Añadimos una ExcelWorksheet al ExcelPackage, que será la hoja de trabajo donde se introducirán los datos.
  • Para crear nuestra fila de cabecera, iteramos las columnas de DataTable, añadiéndolas a la primera fila de nuestra hoja de cálculo.
  • Recorremos las filas de DataTable, añadiendo cada una de ellas a nuestra hoja de cálculo fila por fila (empezando por la fila 2) para que cada fila de DataTable corresponda a una fila de la hoja de cálculo.
  • Construimos un MemoryStream para almacenar los datos binarios de ExcelPackage cuando se completa la conversión de DataTable a ExcelPackage y luego lo convertimos en un array de bytes.
  • Creamos la respuesta HTML y enviamos el archivo XLSX al usuario con un adjunto Content-Disposition, haciendo que el navegador descargue el archivo automáticamente.

    IronXL gana en este caso porque el proceso de creación es muy fácil - sólo necesitas una línea de código y ya estás dentro; esto ayuda a ahorrar tiempo y con la depuración, mientras que EPPlus ofrece líneas de código que son aburridas de revisar y difíciles de depurar.

Cómo escribe EPPlus Software AB los archivos Excel

EPPlus permite trabajar con archivos Excel. Es una librería .net que lee y escribe ficheros Excel.

  • **Lectura de archivos Excel

    Para ello, primero debe instalar el paquete EPPlus: vaya a "Herramientas"-> "Gestor de paquetes NuGet"-> "Gestionar NuGet para esta solución" -> "Instalar EPPlus" -> "Instalar EPPlus" -> "Instalar EPPlus" -> "Instalar EPPlus" -> "Instalar EPPlus" -> "Instalar EP" -> Instalar EP Busque "EPPlus" en la pestaña "Examinar" y, a continuación, instale el paquete NuGet.

    Puede utilizar el siguiente código en su aplicación de consola "Program.cs" una vez que haya instalado el paquete.

using OfficeOpenXml;
using System;
using System.IO;

namespace ReadExcelInCsharp
{
    class Program
    {
        static void Main(string [] args)
        {
            //indique la ruta del archivo
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            //utilizar EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                //obtener la primera hoja de cálculo del libro de trabajo
                ExcelWorksheet worksheet = package.Workbook.Worksheets [1];
                int colCount = worksheet.Dimension.End.Column;  //obtener el recuento de columnas
                int rowCount = worksheet.Dimension.End.Row;     //obtener el recuento de filas
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        //Imprimir datos en función de la posición de las filas y columnas
                        Console.WriteLine(" Row:" + row + " column:" + col + " Value:" + worksheet.Cells [row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}
using OfficeOpenXml;
using System;
using System.IO;

namespace ReadExcelInCsharp
{
    class Program
    {
        static void Main(string [] args)
        {
            //indique la ruta del archivo
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            //utilizar EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                //obtener la primera hoja de cálculo del libro de trabajo
                ExcelWorksheet worksheet = package.Workbook.Worksheets [1];
                int colCount = worksheet.Dimension.End.Column;  //obtener el recuento de columnas
                int rowCount = worksheet.Dimension.End.Row;     //obtener el recuento de filas
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        //Imprimir datos en función de la posición de las filas y columnas
                        Console.WriteLine(" Row:" + row + " column:" + col + " Value:" + worksheet.Cells [row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
VB   C#

A continuación se muestra un ejemplo de salida de una aplicación de consola con un archivo excel de ejemplo (.xlsx) con los que estamos trabajando. Aquí tiene un archivo xlsx para leer en C# utilizando EPPlus.

Mediante la propiedad "celdas" se puede acceder a las siguientes formas de cargar datos de varias fuentes (ExcelRango):

  • Leer un archivo de texto CSV y cargar los datos en un rango de una hoja de cálculo con LoadFromText y LoadFromTextAsync.
  • LoadFromDataReaderAsync y LoadFromDataReader - carga campos de datos de un DataReader en un rango.
  • LoadFromDataTable - carga datos de una DataTable en un rango. Puede importar datos de diversas fuentes, como XML (se proporciona un ejemplo) y bases de datos.
  • LoadFromCollection - carga de forma reflexiva datos de un IEnumerable en un rango.
  • LoadFromCollection with attributes - carga de forma reflexiva datos de un IEnumerable en un rango o tabla. Los estilos, formatos numéricos, fórmulas y otras propiedades se especifican mediante atributos.
  • LoadFromDictionaries - carga datos de un IEnumerable de ExpandoObject/objetos dinámicos (a través de su interfaz IDictionarystring, object>.) en un rango. Esto es útil para importar datos JSON, y hay un ejemplo incluido.
  • LoadFromArrays - carga datos de una IEnumerable de objeto [] en un rango, en el que cada matriz de objetos corresponde a una fila de la hoja de cálculo.

    Al utilizar estos métodos puede dar opcionalmente un parámetro para generar una tabla Excel. Las muestras 4 y 5 del proyecto de ejemplo Sample-.NET Framework o Sample-.NET Framework contienen ejemplos más extensos.

  • Escribir archivos Excel

    A continuación, vamos a ver si podemos exportar los datos a un nuevo archivo Excel.

    He aquí algunos datos/objetos de ejemplo que nos gustaría guardar como documento Excel.

List<UserDetails> persons = new List<UserDetails>()
            {
                new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
                new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
                new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
                new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
           };
List<UserDetails> persons = new List<UserDetails>()
            {
                new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
                new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
                new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
                new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
           };
Dim persons As New List(Of UserDetails)() From {
	New UserDetails() With {
		.ID="9999",
		.Name="ABCD",
		.City ="City1",
		.Country="USA"
	},
	New UserDetails() With {
		.ID="8888",
		.Name="PQRS",
		.City ="City2",
		.Country="INDIA"
	},
	New UserDetails() With {
		.ID="7777",
		.Name="XYZZ",
		.City ="City3",
		.Country="CHINA"
	},
	New UserDetails() With {
		.ID="6666",
		.Name="LMNO",
		.City ="City4",
		.Country="UK"
	}
}
VB   C#

Para crear un nuevo archivo Excel con la información esencial, debemos utilizar la clase ExcelPackage. Escribir datos en un archivo y producir una nueva hoja de cálculo Excel sólo requiere unas pocas líneas de código. Tenga en cuenta la línea siguiente que realiza la magia de cargar DataTables en una hoja de Excel.

Para simplificar las cosas, voy a generar un nuevo archivo de hoja de cálculo en la misma carpeta del proyecto (el archivo Excel se generará en la carpeta "bin" del proyecto). El código fuente está más abajo:

private static void WriteToExcel(string path)
        {
            //Utilicemos los siguientes datos de prueba para escribirlos en Excel
            List<UserDetails> persons = new List<UserDetails>()
            {
                new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
                new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
                new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
                new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
           };

            //  vamos a convertir nuestros datos de objeto a Datatable para una lógica simplificada.
            //  Datatable es la forma más sencilla de manejar tipos de datos complejos para facilitar su lectura y formateo. 
            DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
            FileInfo filePath = new FileInfo(path);
            using (var excelPack = new ExcelPackage(filePath))
            {
                var ws = excelPack.Workbook.Worksheets.Add("WriteTest");
                ws.Cells.LoadFromDataTable(table, true, OfficeOpenXml.Table.TableStyles.Light8);
                excelPack.Save();
            }
        }
private static void WriteToExcel(string path)
        {
            //Utilicemos los siguientes datos de prueba para escribirlos en Excel
            List<UserDetails> persons = new List<UserDetails>()
            {
                new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
                new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
                new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
                new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
           };

            //  vamos a convertir nuestros datos de objeto a Datatable para una lógica simplificada.
            //  Datatable es la forma más sencilla de manejar tipos de datos complejos para facilitar su lectura y formateo. 
            DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
            FileInfo filePath = new FileInfo(path);
            using (var excelPack = new ExcelPackage(filePath))
            {
                var ws = excelPack.Workbook.Worksheets.Add("WriteTest");
                ws.Cells.LoadFromDataTable(table, true, OfficeOpenXml.Table.TableStyles.Light8);
                excelPack.Save();
            }
        }
Private Shared Sub WriteToExcel(ByVal path As String)
			'Utilicemos los siguientes datos de prueba para escribirlos en Excel
			Dim persons As New List(Of UserDetails)() From {
				New UserDetails() With {
					.ID="9999",
					.Name="ABCD",
					.City ="City1",
					.Country="USA"
				},
				New UserDetails() With {
					.ID="8888",
					.Name="PQRS",
					.City ="City2",
					.Country="INDIA"
				},
				New UserDetails() With {
					.ID="7777",
					.Name="XYZZ",
					.City ="City3",
					.Country="CHINA"
				},
				New UserDetails() With {
					.ID="6666",
					.Name="LMNO",
					.City ="City4",
					.Country="UK"
				}
			}

			'  vamos a convertir nuestros datos de objeto a Datatable para una lógica simplificada.
			'  Datatable es la forma más sencilla de manejar tipos de datos complejos para facilitar su lectura y formateo. 
			Dim table As DataTable = CType(JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (GetType(DataTable))), DataTable)
			Dim filePath As New FileInfo(path)
			Using excelPack = New ExcelPackage(filePath)
				Dim ws = excelPack.Workbook.Worksheets.Add("WriteTest")
				ws.Cells.LoadFromDataTable(table, True, OfficeOpenXml.Table.TableStyles.Light8)
				excelPack.Save()
			End Using
End Sub
VB   C#

Tras la mencionada llamada a la API para la validación de datos, se creará un nuevo archivo de Excel con la transformación del objeto personalizado anterior en las columnas y filas de Excel adecuadas, para mostrar el valor que aparece a continuación.

La anterior API lista para usar puede utilizarse en la consola.NET Core, en un proyecto de prueba o en una aplicación ASP.NET Core, y la lógica puede modificarse para adaptarla a sus necesidades.

Se puede acceder a estas técnicas mediante la propiedad "celdas". (ExcelRango):

  • ToText y ToTextAsync - crea una cadena CSV a partir de un rango.
  • Escribir un rango en un archivo CSV con SaveToText y SaveToTextAsync.
  • Exportar datos de un rango a un Sistema utilizando el método ToDataTable.Data. Tabla de datos
  • GetValueT> - muestra un valor con la opción de un tipo de dato.
  • Valor - devuelve o establece el valor del rango.

    Los métodos GetValue y SetValue también pueden utilizarse directamente en el objeto de hoja de cálculo. (Esto proporcionará resultados ligeramente mejores que leer/escribir en el campo de tiro.):

  • GetValueT> - obtiene el valor de una sola celda, con la opción de especificar un tipo de dato.
  • SetValue - cambia el valor de una sola celda.

    Linq puede utilizarse para consultar datos de una hoja de cálculo porque la propiedad cell implementa la interfaz IEnumerable.

Abrir y escribir Office Open XML Formato XLSX con IronXL

IronXL es una biblioteca NET que permite a los desarrolladores de C# trabajar con Excel, tablas dinámicas y otros archivos de hojas de cálculo de forma rápida y sencilla.

Office Interop no es necesario. No hay dependencias particulares ni necesidad de instalar Microsoft Office en Core o Azure.

IronXL es una renombrada biblioteca de hojas de cálculo xl de C# y VB.NET para .NET core y .NET framework.

  • **Lectura de archivos Excel
  • Hoja de trabajo a cargar

    Una hoja Excel está representada por la clase WorkBook. Utilizamos WorkBook para abrir un archivo Excel en C# que contiene incluso tablas dinámicas. Cargue el archivo Excel y elija su ubicación (.xlsx).

/**
Load WorkBook
anchor-load-a-workbook
**/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
/**
Load WorkBook
anchor-load-a-workbook
**/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
'''
'''Load WorkBook
'''anchor-load-a-workbook
'''*
Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")
VB   C#

Los objetos WorkSheet pueden encontrarse en numerosos WorkBooks. Son las hojas de cálculo del documento Excel. Si la hoja contiene hojas de trabajo, utilice el nombre Libro de Trabajo para encontrarlas. GetWorkSheet.

var worksheet = workbook.GetWorkSheet("GDPByCountry");
var worksheet = workbook.GetWorkSheet("GDPByCountry");
Dim worksheet = workbook.GetWorkSheet("GDPByCountry")
VB   C#
  • **Haz tu propio cuaderno de ejercicios.

    Construye un nuevo Libro de Trabajo con el tipo de hoja para generar un nuevo Libro de Trabajo en memoria.

/**
Create WorkBook
anchor-create-a-workbook
**/
var workbook = new WorkBook(ExcelFileFormat.XLSX);
/**
Create WorkBook
anchor-create-a-workbook
**/
var workbook = new WorkBook(ExcelFileFormat.XLSX);
'''
'''Create WorkBook
'''anchor-create-a-workbook
'''*
Dim workbook As New WorkBook(ExcelFileFormat.XLSX)
VB   C#

Para hojas de cálculo de Microsoft Excel antiguas, utilice ExcelFileFormat.XLS (95 y anteriores).

**Haz una hoja de trabajo si aún no tienes una.

Puede haber numerosas "WorkSheets" en cada "WorkBook". Una "WorkSheet" es una única hoja de datos, mientras que un "WorkBook" es una colección de WorkSheets. En Excel, este es el aspecto de un libro con dos hojas de cálculo.

El WorkBook es el nombre de una nueva WorkSheet que puede construir.

var worksheet = workbook.CreateWorkSheet("Countries");
var worksheet = workbook.CreateWorkSheet("Countries");
Dim worksheet = workbook.CreateWorkSheet("Countries")
VB   C#

Pase el nombre de la hoja de trabajo a CreateWorkSheet.

Obtener el rango celular

Una colección bidimensional de objetos "Cell" está representada por la clase "Range". Denota un rango específico de celdas de Excel. Utilizando el indexador de cadenas en un objeto WorkSheet, puede obtener rangos.

var range = worksheet ["D2:D101"];
var range = worksheet ["D2:D101"];
Dim range = worksheet ("D2:D101")
VB   C#

El argumento texto puede ser la coordenada de una celda (por ejemplo, "A1") o un rango de celdas de izquierda a derecha, de arriba a abajo (Por ejemplo, "B2:E5".). GetRange también se puede llamar desde una WorkSheet.

  • Dentro de un Rango, Editar Valores de Celda

    Los valores de las celdas dentro de un Rango pueden ser leídos o editados de varias maneras. Utilice un bucle For si se conoce el recuento. Desde aquí también puede estilizar las celdas.

/**
Edit Cell Values in Range
anchor-edit-cell-values-within-a-range
**/
//Iterar por las filas
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    //Obtener todas las celdas de la persona
    var cells = worksheet [$"A{y}:E{y}"].ToList();

    //Validar el número de teléfono (1 = B)
    var phoneNumber = cells [1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    //Validar la dirección de correo electrónico (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells [3].Value);

    //Obtener la fecha sin procesar en el formato Mes Día [sufijo], Año (4 = E)
    var rawDate = (string)cells [4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}
/**
Edit Cell Values in Range
anchor-edit-cell-values-within-a-range
**/
//Iterar por las filas
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    //Obtener todas las celdas de la persona
    var cells = worksheet [$"A{y}:E{y}"].ToList();

    //Validar el número de teléfono (1 = B)
    var phoneNumber = cells [1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    //Validar la dirección de correo electrónico (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells [3].Value);

    //Obtener la fecha sin procesar en el formato Mes Día [sufijo], Año (4 = E)
    var rawDate = (string)cells [4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}
'''
'''Edit Cell Values in Range
'''anchor-edit-cell-values-within-a-range
'''*
'Iterar por las filas
For y = 2 To 101
	Dim result = New PersonValidationResult With {.Row = y}
	results.Add(result)

	'Obtener todas las celdas de la persona
	Dim cells = worksheet ($"A{y}:E{y}").ToList()

	'Validar el número de teléfono (1 = B)
	Dim phoneNumber = cells (1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	'Validar la dirección de correo electrónico (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells (3).Value))

	'Obtener la fecha sin procesar en el formato Mes Día [sufijo], Año (4 = E)
	Dim rawDate = CStr(cells (4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next y
VB   C#

Validar datos en hojas de cálculo

Para validar una hoja de datos, utilice IronXL. La muestra DataValidation valida números de teléfono con libphonenumber-CSharp, y direcciones de correo electrónico y fechas con las API convencionales de C#.

/**
Validate Spreadsheet Data
anchor-validate-spreadsheet-data
**/
//Iterar por las filas
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    //Obtener todas las celdas de la persona
    var cells = worksheet [$"A{i}:E{i}"].ToList();

    //Validar el número de teléfono (1 = B)
    var phoneNumber = cells [1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    //Validar la dirección de correo electrónico (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells [3].Value);

    //Obtener la fecha sin procesar en el formato Mes Día [sufijo], Año (4 = E)
    var rawDate = (string)cells [4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}
/**
Validate Spreadsheet Data
anchor-validate-spreadsheet-data
**/
//Iterar por las filas
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    //Obtener todas las celdas de la persona
    var cells = worksheet [$"A{i}:E{i}"].ToList();

    //Validar el número de teléfono (1 = B)
    var phoneNumber = cells [1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    //Validar la dirección de correo electrónico (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells [3].Value);

    //Obtener la fecha sin procesar en el formato Mes Día [sufijo], Año (4 = E)
    var rawDate = (string)cells [4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}
'''
'''Validate Spreadsheet Data
'''anchor-validate-spreadsheet-data
'''*
'Iterar por las filas
For i = 2 To 101
	Dim result = New PersonValidationResult With {.Row = i}
	results.Add(result)

	'Obtener todas las celdas de la persona
	Dim cells = worksheet ($"A{i}:E{i}").ToList()

	'Validar el número de teléfono (1 = B)
	Dim phoneNumber = cells (1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	'Validar la dirección de correo electrónico (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells (3).Value))

	'Obtener la fecha sin procesar en el formato Mes Día [sufijo], Año (4 = E)
	Dim rawDate = CStr(cells (4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next i
VB   C#

El código anterior recorre las filas de la hoja de cálculo, tomando las celdas como una lista. Cada método validado verifica el valor de una celda y devuelve un error si el valor es incorrecto.

Este código crea una nueva hoja, especifica las cabeceras y produce los resultados del mensaje de error para que se pueda guardar un registro de datos incorrectos.

var resultsSheet = workbook.CreateWorkSheet("Results");

resultsSheet ["A1"].Value = "Row";
resultsSheet ["B1"].Value = "Valid";
resultsSheet ["C1"].Value = "Phone Error";
resultsSheet ["D1"].Value = "Email Error";
resultsSheet ["E1"].Value = "Date Error";

for (var i = 0; i < results.Count; i++)
{
    var result = results [i];
    resultsSheet [$"A{i + 2}"].Value = result.Row;
    resultsSheet [$"B{i + 2}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet [$"C{i + 2}"].Value = result.PhoneNumberErrorMessage;
    resultsSheet [$"D{i + 2}"].Value = result.EmailErrorMessage;
    resultsSheet [$"E{i + 2}"].Value = result.DateErrorMessage;
}

workbook.SaveAs(@"Spreadsheets\\PeopleValidated.xlsx");
var resultsSheet = workbook.CreateWorkSheet("Results");

resultsSheet ["A1"].Value = "Row";
resultsSheet ["B1"].Value = "Valid";
resultsSheet ["C1"].Value = "Phone Error";
resultsSheet ["D1"].Value = "Email Error";
resultsSheet ["E1"].Value = "Date Error";

for (var i = 0; i < results.Count; i++)
{
    var result = results [i];
    resultsSheet [$"A{i + 2}"].Value = result.Row;
    resultsSheet [$"B{i + 2}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet [$"C{i + 2}"].Value = result.PhoneNumberErrorMessage;
    resultsSheet [$"D{i + 2}"].Value = result.EmailErrorMessage;
    resultsSheet [$"E{i + 2}"].Value = result.DateErrorMessage;
}

workbook.SaveAs(@"Spreadsheets\\PeopleValidated.xlsx");
Dim resultsSheet = workbook.CreateWorkSheet("Results")

resultsSheet ("A1").Value = "Row"
resultsSheet ("B1").Value = "Valid"
resultsSheet ("C1").Value = "Phone Error"
resultsSheet ("D1").Value = "Email Error"
resultsSheet ("E1").Value = "Date Error"

For i = 0 To results.Count - 1
	Dim result = results (i)
	resultsSheet ($"A{i + 2}").Value = result.Row
	resultsSheet ($"B{i + 2}").Value = If(result.IsValid, "Yes", "No")
	resultsSheet ($"C{i + 2}").Value = result.PhoneNumberErrorMessage
	resultsSheet ($"D{i + 2}").Value = result.EmailErrorMessage
	resultsSheet ($"E{i + 2}").Value = result.DateErrorMessage
Next i

workbook.SaveAs("Spreadsheets\\PeopleValidated.xlsx")
VB   C#

Utilización de Entity Framework para exportar datos

Utilice IronXL para convertir una hoja de cálculo de Excel en una base de datos o para exportar datos a una base de datos. El ejemplo ExcelToDB lee una hoja de cálculo que contiene el PIB por país y lo exporta a SQLite.

Crea la base de datos con EntityFramework y luego exporta los datos línea por línea.

Los paquetes NuGet de SQLite Entity Framework deben estar instalados.

Puede utilizar EntityFramework para construir un objeto modelo que pueda exportar datos a una base de datos.

public class Country
{
    [Key]
    public Guid Key { get; set; }
    public string Name { get; set; }
    public decimal GDP { get; set; }
}
public class Country
{
    [Key]
    public Guid Key { get; set; }
    public string Name { get; set; }
    public decimal GDP { get; set; }
}
Public Class Country
	<Key>
	Public Property Key() As Guid
	Public Property Name() As String
	Public Property GDP() As Decimal
End Class
VB   C#

Para utilizar una base de datos diferente, instale el paquete NuGet adecuado y busque el equivalente UseSqLite ().

/**
Export Data using Entity Framework
anchor-export-data-using-entity-framework
**/
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    public CountryContext()
    {
        //TODO: Hacer async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configurar el contexto para utilizar Sqlite
    /// </summary>
    /// <param name="optionsBuilder"></param>
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connection = new SqliteConnection($"Data Source=Country.db");
        connection.Open();

        var command = connection.CreateCommand();

        //Crear la base de datos si aún no existe
        command.CommandText = $"PRAGMA foreign_keys = ON;";
        command.ExecuteNonQuery();

        optionsBuilder.UseSqlite(connection);

        base.OnConfiguring(optionsBuilder);
    }

}
/**
Export Data using Entity Framework
anchor-export-data-using-entity-framework
**/
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    public CountryContext()
    {
        //TODO: Hacer async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configurar el contexto para utilizar Sqlite
    /// </summary>
    /// <param name="optionsBuilder"></param>
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connection = new SqliteConnection($"Data Source=Country.db");
        connection.Open();

        var command = connection.CreateCommand();

        //Crear la base de datos si aún no existe
        command.CommandText = $"PRAGMA foreign_keys = ON;";
        command.ExecuteNonQuery();

        optionsBuilder.UseSqlite(connection);

        base.OnConfiguring(optionsBuilder);
    }

}
'''
'''Export Data using Entity Framework
'''anchor-export-data-using-entity-framework
'''*
Public Class CountryContext
	Inherits DbContext

	Public Property Countries() As DbSet(Of Country)

	Public Sub New()
		'TODO: Hacer async
		Database.EnsureCreated()
	End Sub

	''' <summary>
	''' Configurar el contexto para utilizar Sqlite
	''' </summary>
	''' <param name="optionsBuilder"></param>
	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		Dim connection = New SqliteConnection($"Data Source=Country.db")
		connection.Open()

		Dim command = connection.CreateCommand()

		'Crear la base de datos si aún no existe
		command.CommandText = $"PRAGMA foreign_keys = ON;"
		command.ExecuteNonQuery()

		optionsBuilder.UseSqlite(connection)

		MyBase.OnConfiguring(optionsBuilder)
	End Sub

End Class
VB   C#

Produce un CountryContext, luego itera a través del rango para crear cada entrada antes de guardar los datos en la base de datos con SaveAsync.

public async Task ProcessAsync()
{
    //Obtener la primera hoja de cálculo
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    //Crear la conexión a la base de datos
    using (var countryContext = new CountryContext())
    {
        //Iterar a través de todas las celdas
        for (var i = 2; i <= 213; i++)
        {
            //Obtener la gama de A-B
            var range = worksheet [$"A{i}:B{i}"].ToList();

            //Crear una entidad País para guardarla en la base de datos
            var country = new Country
            {
                Name = (string)range [0].Value,
                GDP = (decimal)(double)range [1].Value
            };

            //Añadir la entidad 
            await countryContext.Countries.AddAsync(country);
        }

        //Confirmar los cambios en la base de datos
        await countryContext.SaveChangesAsync();
    }
}
public async Task ProcessAsync()
{
    //Obtener la primera hoja de cálculo
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    //Crear la conexión a la base de datos
    using (var countryContext = new CountryContext())
    {
        //Iterar a través de todas las celdas
        for (var i = 2; i <= 213; i++)
        {
            //Obtener la gama de A-B
            var range = worksheet [$"A{i}:B{i}"].ToList();

            //Crear una entidad País para guardarla en la base de datos
            var country = new Country
            {
                Name = (string)range [0].Value,
                GDP = (decimal)(double)range [1].Value
            };

            //Añadir la entidad 
            await countryContext.Countries.AddAsync(country);
        }

        //Confirmar los cambios en la base de datos
        await countryContext.SaveChangesAsync();
    }
}
Public Async Function ProcessAsync() As Task
	'Obtener la primera hoja de cálculo
	Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")
	Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

	'Crear la conexión a la base de datos
	Using countryContext As New CountryContext()
		'Iterar a través de todas las celdas
		For i = 2 To 213
			'Obtener la gama de A-B
			Dim range = worksheet ($"A{i}:B{i}").ToList()

			'Crear una entidad País para guardarla en la base de datos
			Dim country As New Country With {
				.Name = CStr(range (0).Value),
				.GDP = CDec(CDbl(range (1).Value))
			}

			'Añadir la entidad 
			Await countryContext.Countries.AddAsync(country)
		Next i

		'Confirmar los cambios en la base de datos
		Await countryContext.SaveChangesAsync()
	End Using
End Function
VB   C#

Incorporar una fórmula a una hoja de cálculo

La propiedad Fórmula puede utilizarse para establecer la fórmula de una celda.

//Iterar a través de todas las filas con un valor
for (var y = 2; y < i; y++)
{
    //Obtener la célula C
    var cell = sheet [$"C{y}"].First();

    //Establezca la fórmula de la columna Porcentaje del total
    cell.Formula = $"=B{y}/B{i}";
}
//Iterar a través de todas las filas con un valor
for (var y = 2; y < i; y++)
{
    //Obtener la célula C
    var cell = sheet [$"C{y}"].First();

    //Establezca la fórmula de la columna Porcentaje del total
    cell.Formula = $"=B{y}/B{i}";
}
'Iterar a través de todas las filas con un valor
Dim y = 2
Do While y < i
	'Obtener la célula C
	Dim cell = sheet ($"C{y}").First()

	'Establezca la fórmula de la columna Porcentaje del total
	cell.Formula = $"=B{y}/B{i}"
	y += 1
Loop
VB   C#

El código de la columna C itera por cada estado y calcula un porcentaje total.

**Los datos de una API pueden descargarse en una hoja de cálculo.

RestClient.Net se utiliza en la siguiente llamada para realizar una llamada REST. Descarga JSON y lo convierte en una "Lista" de tipo RestCountry. A continuación, los datos de la API REST pueden guardarse fácilmente en un archivo Excel iterando por cada país.

/**
Data API to Spreadsheet
anchor-download-data-from-an-api-to-spreadsheet
**/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();
/**
Data API to Spreadsheet
anchor-download-data-from-an-api-to-spreadsheet
**/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();
'''
'''Data API to Spreadsheet
'''anchor-download-data-from-an-api-to-spreadsheet
'''*
Dim client As New Client(New Uri("https://restcountries.eu/rest/v2/"))
Dim countries As List(Of RestCountry) = Await client.GetAsync(Of List(Of RestCountry))()
VB   C#

Los datos JSON de la API tienen este aspecto:

El siguiente código recorre los países y rellena la hoja de cálculo con el nombre, la población, la región, el código numérico y los tres idiomas principales.

for (var i = 2; i < countries.Count; i++)
{
    var country = countries [i];

    //Establecer los valores básicos
    worksheet [$"A{i}"].Value = country.name;
    worksheet [$"B{i}"].Value = country.population;
    worksheet [$"G{i}"].Value = country.region;
    worksheet [$"H{i}"].Value = country.numericCode;

    //Iterar por idiomas
    for (var x = 0; x < 3; x++)
    {
        if (x > (country.languages.Count - 1)) break;

        var language = country.languages [x];

        //Obtener la letra de la columna
        var columnLetter = GetColumnLetter(4 + x);

        //Establecer el nombre del idioma
        worksheet [$"{columnLetter}{i}"].Value = language.name;
    }
}
for (var i = 2; i < countries.Count; i++)
{
    var country = countries [i];

    //Establecer los valores básicos
    worksheet [$"A{i}"].Value = country.name;
    worksheet [$"B{i}"].Value = country.population;
    worksheet [$"G{i}"].Value = country.region;
    worksheet [$"H{i}"].Value = country.numericCode;

    //Iterar por idiomas
    for (var x = 0; x < 3; x++)
    {
        if (x > (country.languages.Count - 1)) break;

        var language = country.languages [x];

        //Obtener la letra de la columna
        var columnLetter = GetColumnLetter(4 + x);

        //Establecer el nombre del idioma
        worksheet [$"{columnLetter}{i}"].Value = language.name;
    }
}
For i = 2 To countries.Count - 1
	Dim country = countries (i)

	'Establecer los valores básicos
	worksheet ($"A{i}").Value = country.name
	worksheet ($"B{i}").Value = country.population
	worksheet ($"G{i}").Value = country.region
	worksheet ($"H{i}").Value = country.numericCode

	'Iterar por idiomas
	For x = 0 To 2
		If x > (country.languages.Count - 1) Then
			Exit For
		End If

		Dim language = country.languages (x)

		'Obtener la letra de la columna
		Dim columnLetter = GetColumnLetter(4 + x)

		'Establecer el nombre del idioma
		worksheet ($"{columnLetter}{i}").Value = language.name
	Next x
Next i
VB   C#

Abrir archivos Excel con IronXL

Después de lanzar el fichero Excel, añade las primeras líneas que leen la 1ª celda de la 1ª hoja, e imprime.

static void Main(string [] args)
{
    var workbook = IronXL.WorkBook.Load($@"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx");
    var sheet = workbook.WorkSheets.First();
    var cell = sheet ["A1"].StringValue;
    Console.WriteLine(cell);
}
static void Main(string [] args)
{
    var workbook = IronXL.WorkBook.Load($@"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx");
    var sheet = workbook.WorkSheets.First();
    var cell = sheet ["A1"].StringValue;
    Console.WriteLine(cell);
}
Shared Sub Main(ByVal args() As String)
	Dim workbook = IronXL.WorkBook.Load($"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx")
	Dim sheet = workbook.WorkSheets.First()
	Dim cell = sheet ("A1").StringValue
	Console.WriteLine(cell)
End Sub
VB   C#

Usando IronXL, cree un nuevo archivo Excel.

/**
Create Excel File
anchor-create-a-new-excel-file
**/
static void Main(string [] args)
{
    var newXLFile = WorkBook.Create(ExcelFileFormat.XLSX);
    newXLFile.Metadata.Title = "IronXL New File";
    var newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet");
    newWorkSheet ["A1"].Value = "Hello World";
    newWorkSheet ["A2"].Style.BottomBorder.SetColor("#ff6600");
    newWorkSheet ["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Dashed;
}
/**
Create Excel File
anchor-create-a-new-excel-file
**/
static void Main(string [] args)
{
    var newXLFile = WorkBook.Create(ExcelFileFormat.XLSX);
    newXLFile.Metadata.Title = "IronXL New File";
    var newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet");
    newWorkSheet ["A1"].Value = "Hello World";
    newWorkSheet ["A2"].Style.BottomBorder.SetColor("#ff6600");
    newWorkSheet ["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Dashed;
}
'''
'''Create Excel File
'''anchor-create-a-new-excel-file
'''*
Shared Sub Main(ByVal args() As String)
	Dim newXLFile = WorkBook.Create(ExcelFileFormat.XLSX)
	newXLFile.Metadata.Title = "IronXL New File"
	Dim newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet")
	newWorkSheet ("A1").Value = "Hello World"
	newWorkSheet ("A2").Style.BottomBorder.SetColor("#ff6600")
	newWorkSheet ("A2").Style.BottomBorder.Type = IronXL.Styles.BorderType.Dashed
End Sub
VB   C#

Después de esto, puede guardar en CSV, JSON o XML utilizando sus respectivos códigos.

Por ejemplo, para Guardar en XML ".xml"

Para guardar en XML utilice SaveAsXml como se indica a continuación:

newXLFile.SaveAsXml($@"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML");
newXLFile.SaveAsXml($@"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML");
newXLFile.SaveAsXml($"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML")
VB   C#

El resultado es el siguiente:

<?xml version="1.0" standalone="yes"?>
<_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Hola Mundo</Columna1>
  </_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" />
  </_x0031_stWorkSheet>
</_x0031_stWorkSheet>
XML

La lectura de archivos Excel es más fácil con IronXL que con EPPlus. IronXL tiene códigos más abreviados que abarcan todo lo necesario para acceder a todas las columnas, filas y celdas de un libro de trabajo, mientras que con EPPlus necesitará una línea de código específica para leer columnas y filas.

IronXL es más inteligente cuando se trata de manipular documentos de Excel. Le da ventaja para crear más hojas en cualquier momento, así como para leer datos de múltiples hojas de cálculo y libros de trabajo, mientras que EPPlus se ocupa de una hoja de cálculo cada vez. Con IronXL, también puedes rellenar una base de datos con los datos de tu libro de Excel.

Licencias y precios de EPPlus e IronXL

Modelo de licencia y precio de EPPlus

EPPlus puede utilizarse bajo dos modelos de licencia, un modelo de licencia no comercial o un modelo de licencia comercial de Polyform.

**Licencias comerciales

Están disponibles en formato perpetuo y de suscripción, con plazos que van de un mes a dos años.

Para todas las categorías de licencias, el soporte a través del centro de soporte y las actualizaciones a través de NuGet están incluidos durante la duración de la licencia.

EPPlus requiere una licencia por desarrollador. Las licencias se expiden a una sola persona y no pueden compartirse. Como pauta general, cualquiera que produzca o necesite depurar código que utilice directamente EPPlus debería tener una licencia comercial.

Si presta EPPlus como un servicio interno (por ejemplo, exponiendo sus capacidades a través de una API)su empresa debe adquirir una suscripción que cubra el número de usuarios internos (desarrolladores) que utilizarán el servicio.

Suscripciones

Siempre puede utilizar la última versión con una suscripción, pero debe tener una licencia válida mientras utilice EPPlus para el desarrollo. Al final del periodo de licencia, ésta se factura automáticamente y se renueva una vez abonado el pago. Puede cancelar su suscripción al final del periodo de licencia e iniciar una nueva cuando lo desee. Las suscripciones solo se pueden adquirir por internet.

EPPlus puede utilizarse en un entorno comercial. La licencia es para un desarrollador por empresa, con un número ilimitado de ubicaciones de implantación. El número de licencias disponibles para la compra cada año puede aumentarse o reducirse, y la licencia puede suspenderse o cancelarse al final de cada año.

Existe la opción de un periodo de prueba de 32 días.

Precios: Desde 299 $ al año.

Puedes pagar a medida que avanzas

Precio por desarrollador dentro de una única organización, con ubicaciones de implantación ilimitadas y facturación de Stripe. El número de licencias disponibles cada mes puede aumentarse o reducirse, y la licencia puede suspenderse o cancelarse al final de cada mes.

Precios: Desde 29 $ al mes.

**Licencia perpetua

Una licencia perpetua le permite actualizar a nuevas versiones y recibir soporte durante un periodo de tiempo determinado. Después, puede seguir desarrollando software con las versiones publicadas durante ese tiempo sin necesidad de renovar la licencia.

Dentro de la misma empresa, precio por desarrollador con sitios de implantación ilimitados. Uso indefinido de todas las versiones de EPPlus publicadas dentro del plazo de soporte/actualizaciones.

Existe la opción de un periodo de prueba de 32 días.

Precios: Desde 599 $ al año.

Paquetes

Existen opciones de licencia perpetua con una duración inicial de actualizaciones y asistencia. De este modo, podrá seguir desarrollando software utilizando las versiones publicadas durante este periodo de tiempo sin necesidad de renovar su licencia.

Precios: Desde 4295 $ al año.

Licencia no comercial para Polyform.

EPPlus está licenciado bajo la licencia Polyform Noncommercial a partir de la versión 5, que indica que el código es abierto y puede utilizarse para usos no comerciales. Puede ver más detalles en su sitio web.

Modelo y precio de la licencia IronXL

Licencia perpetua: cada licencia se adquiere una vez y no requiere renovación.

Asistencia gratuita y actualizaciones del producto: cada licencia incluye un año de actualizaciones gratuitas del producto y la asistencia del equipo que lo desarrolla. Es posible adquirir extensiones en cualquier momento. Se pueden ver las extensiones.

Licencias inmediatas: las claves de licencia registradas se envían en cuanto se recibe el pago.

Póngase en contacto con nuestros especialistas en licencias de Iron Software si tiene alguna pregunta sobre las licencias de IronXL for .NET.

Todas las licencias son perpetuas y se aplican al desarrollo, la puesta en marcha y la producción.

Lite - Permite a un único desarrollador de software de una organización utilizar el software Iron en un único lugar. Iron Software puede utilizarse en una aplicación web, una aplicación de intranet o un programa de software de escritorio. Las licencias son intransferibles y no pueden compartirse fuera de una organización o de una relación agencia/cliente. Este tipo de licencia, al igual que todos los demás tipos de licencia, excluye expresamente todos los derechos no concedidos expresamente en virtud del Acuerdo, incluida la redistribución OEM y la utilización del Software Iron como SaaS sin adquirir cobertura adicional.

Precios: Desde 489 $ al año.

Licencia profesional - Permite a un número predeterminado de desarrolladores de software de una organización utilizar Iron Software en una única ubicación, hasta un máximo de diez. El software Iron puede utilizarse en tantos sitios web, aplicaciones de intranet o aplicaciones de software de escritorio como se desee. Las licencias son intransferibles y no pueden compartirse fuera de una organización o de una relación agencia/cliente. Este tipo de licencia, al igual que todos los demás tipos de licencia, excluye expresamente todos los derechos no otorgados expresamente bajo el Acuerdo, incluyendo la redistribución OEM y la utilización del Software Iron como SaaS sin adquirir cobertura adicional.

Precios: Desde 976 $ al año.

Licencia ilimitada - Permite a un número ilimitado de desarrolladores de software en una organización utilizar Iron Software en un número ilimitado de ubicaciones. El software Iron puede utilizarse en tantos sitios web, aplicaciones de intranet o aplicaciones de software de escritorio como se desee. Las licencias son intransferibles y no pueden compartirse fuera de una organización o de una relación agencia/cliente. Este tipo de licencia, al igual que todos los demás tipos de licencia, excluye expresamente todos los derechos no otorgados expresamente bajo el Acuerdo, incluyendo la redistribución OEM y la utilización del Software Iron como SaaS sin adquirir cobertura adicional.

Redistribución libre de regalías: le permite distribuir el software Iron como parte de diversos productos comerciales empaquetados. (sin tener que pagar derechos de autor) en función del número de proyectos cubiertos por la licencia base. Permite el despliegue de Iron Software dentro de los servicios de software SaaS, en función del número de proyectos cubiertos por la licencia base.

Precios: A partir de 2939 $ al año.

Conclusión

En conclusión, IronXL es más práctico que EPPlus porque te da la flexibilidad de navegar por la tabla de Excel como lo requieras, con líneas de códigos más cortas y más oportunidades para exportar incluyendo XML, HTML y JSON. IronXL también le permite integrar los datos de su libro de trabajo en una base de datos. Además, dispone de un sistema intuitivo que recalcula las fórmulas cada vez que se edita el documento, y proporciona una configuración de Rangos intuitivos con una Hoja de trabajo ["A1:B10"] sintaxis. Las funciones de hoja incluyen fórmulas que funcionan con Excel y se recalculan cada vez que se edita una hoja. Los formatos de datos de celda tienen múltiples textos, números, fórmulas, fechas, moneda, porcentajes, notación científica y hora. Sus formatos personalizados tienen diferentes métodos de ordenación como rangos, columnas y filas. Su estilo de celda incluye una variedad de fuentes, tamaños, patrones de fondo, bordes y alineaciones.

< ANTERIOR
Comparación de las células IronXL y Aspose
SIGUIENTE >
Comparación entre IronXL y Microsoft Office Interop Excel

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 853,944
Ver licencias >