Comparación entre IronXL y Epplus

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)

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;

    // replace the GetDataTable() method with your DBMS-fetching code.
    using (DataTable dt = GetDataTable())
    {
        // create an empty spreadsheet
        using (var p = new ExcelPackage())
        {
            // add a worksheet to the spreadsheet
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            // Initialize rows and cols counter: note that they are 1-based!
            var row = 1;
            var col = 1;

            // Create the column names on the first line.
            // In this sample we'll just use the DataTable colum names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows to the XLS file
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r [dc].ToString());
                }

                // alternate light-gray color for uneven rows (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);
                }
            }

            // output the XLSX file
            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;

    // replace the GetDataTable() method with your DBMS-fetching code.
    using (DataTable dt = GetDataTable())
    {
        // create an empty spreadsheet
        using (var p = new ExcelPackage())
        {
            // add a worksheet to the spreadsheet
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            // Initialize rows and cols counter: note that they are 1-based!
            var row = 1;
            var col = 1;

            // Create the column names on the first line.
            // In this sample we'll just use the DataTable colum names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows to the XLS file
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r [dc].ToString());
                }

                // alternate light-gray color for uneven rows (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);
                }
            }

            // output the XLSX file
            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

	' replace the GetDataTable() method with your DBMS-fetching code.
	Using dt As DataTable = GetDataTable()
		' create an empty spreadsheet
		Using p = New ExcelPackage()
			' add a worksheet to the spreadsheet
			Dim ws As ExcelWorksheet = p.Workbook.Worksheets.Add(dt.TableName)

			' Initialize rows and cols counter: note that they are 1-based!
			Dim row = 1
			Dim col = 1

			' Create the column names on the first line.
			' In this sample we'll just use the DataTable colum names
			row = 1
			col = 0
			For Each dc As DataColumn In dt.Columns
				col += 1
				ws.SetValue(row, col, dc.ColumnName)
			Next dc

			' Insert the DataTable rows to the XLS file
			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

				' alternate light-gray color for uneven rows (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

			' output the XLSX file
			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

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)
        {
            //provide file path
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            //use EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                //get the first worksheet in the workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets [1];
                int colCount = worksheet.Dimension.End.Column;  //get Column Count
                int rowCount = worksheet.Dimension.End.Row;     //get row count
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        //Print data, based on row and columns position
                        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)
        {
            //provide file path
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            //use EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                //get the first worksheet in the workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets [1];
                int colCount = worksheet.Dimension.End.Column;  //get Column Count
                int rowCount = worksheet.Dimension.End.Row;     //get row count
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        //Print data, based on row and columns position
                        Console.WriteLine(" Row:" + row + " column:" + col + " Value:" + worksheet.Cells [row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}

Imports OfficeOpenXml
Imports System
Imports System.IO

Namespace ReadExcelInCsharp
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			'provide file path
			Dim existingFile As New FileInfo("D:\sample_XLSX.xlsx")
			'use EPPlus
			Using package As New ExcelPackage(existingFile)
				'get the first worksheet in the workbook
				Dim worksheet As ExcelWorksheet = package.Workbook.Worksheets (1)
				Dim colCount As Integer = worksheet.Dimension.End.Column 'get Column Count
				Dim rowCount As Integer = worksheet.Dimension.End.Row 'get row count
				For row As Integer = 1 To rowCount
					For col As Integer = 1 To colCount
						'Print data, based on row and columns position
						Console.WriteLine(" Row:" & row & " column:" & col & " Value:" & worksheet.Cells (row, col).Value?.ToString().Trim())
					Next col
				Next row
			End Using
		End Sub
	End Class
End Namespace

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"
	}
}

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)
        {
            //Let use below test data for writing it to 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"},
           };

            // let's convert our object data to Datatable for a simplified logic.
            // Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
            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)
        {
            //Let use below test data for writing it to 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"},
           };

            // let's convert our object data to Datatable for a simplified logic.
            // Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
            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)
			'Let use below test data for writing it to 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"
				}
			}

			' let's convert our object data to Datatable for a simplified logic.
			' Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
			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

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")

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")

• **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)

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")

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")

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
**/
//Iterate through the rows
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    //Get all cells for the person
    var cells = worksheet [$"A{y}:E{y}"].ToList();

    //Validate the phone number (1 = B)
    var phoneNumber = cells [1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    //Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells [3].Value);

    //Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells [4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

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

    //Get all cells for the person
    var cells = worksheet [$"A{y}:E{y}"].ToList();

    //Validate the phone number (1 = B)
    var phoneNumber = cells [1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    //Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells [3].Value);

    //Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells [4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

'''
'''Edit Cell Values in Range
'''anchor-edit-cell-values-within-a-range
'''*
'Iterate through the rows
For y = 2 To 101
	Dim result = New PersonValidationResult With {.Row = y}
	results.Add(result)

	'Get all cells for the person
	Dim cells = worksheet ($"A{y}:E{y}").ToList()

	'Validate the phone number (1 = B)
	Dim phoneNumber = cells (1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	'Validate the email address (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells (3).Value))

	'Get the raw date in the format of Month Day [suffix], Year (4 = E)
	Dim rawDate = CStr(cells (4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next y

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
**/
//Iterate through the rows
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    //Get all cells for the person
    var cells = worksheet [$"A{i}:E{i}"].ToList();

    //Validate the phone number (1 = B)
    var phoneNumber = cells [1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    //Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells [3].Value);

    //Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells [4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

/**
Validate Spreadsheet Data
anchor-validate-spreadsheet-data
**/
//Iterate through the rows
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    //Get all cells for the person
    var cells = worksheet [$"A{i}:E{i}"].ToList();

    //Validate the phone number (1 = B)
    var phoneNumber = cells [1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    //Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells [3].Value);

    //Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells [4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

'''
'''Validate Spreadsheet Data
'''anchor-validate-spreadsheet-data
'''*
'Iterate through the rows
For i = 2 To 101
	Dim result = New PersonValidationResult With {.Row = i}
	results.Add(result)

	'Get all cells for the person
	Dim cells = worksheet ($"A{i}:E{i}").ToList()

	'Validate the phone number (1 = B)
	Dim phoneNumber = cells (1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	'Validate the email address (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells (3).Value))

	'Get the raw date in the format of Month Day [suffix], Year (4 = E)
	Dim rawDate = CStr(cells (4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next i

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")

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

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: Make async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configure context to use 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();

        //Create the database if it doesn't already exist
        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: Make async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configure context to use 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();

        //Create the database if it doesn't already exist
        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: Make async
		Database.EnsureCreated()
	End Sub

	''' <summary>
	''' Configure context to use 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()

		'Create the database if it doesn't already exist
		command.CommandText = $"PRAGMA foreign_keys = ON;"
		command.ExecuteNonQuery()

		optionsBuilder.UseSqlite(connection)

		MyBase.OnConfiguring(optionsBuilder)
	End Sub

End Class

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()
{
    //Get the first worksheet
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    //Create the database connection
    using (var countryContext = new CountryContext())
    {
        //Iterate through all the cells
        for (var i = 2; i <= 213; i++)
        {
            //Get the range from A-B
            var range = worksheet [$"A{i}:B{i}"].ToList();

            //Create a Country entity to be saved to the database
            var country = new Country
            {
                Name = (string)range [0].Value,
                GDP = (decimal)(double)range [1].Value
            };

            //Add the entity 
            await countryContext.Countries.AddAsync(country);
        }

        //Commit changes to the database
        await countryContext.SaveChangesAsync();
    }
}

public async Task ProcessAsync()
{
    //Get the first worksheet
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    //Create the database connection
    using (var countryContext = new CountryContext())
    {
        //Iterate through all the cells
        for (var i = 2; i <= 213; i++)
        {
            //Get the range from A-B
            var range = worksheet [$"A{i}:B{i}"].ToList();

            //Create a Country entity to be saved to the database
            var country = new Country
            {
                Name = (string)range [0].Value,
                GDP = (decimal)(double)range [1].Value
            };

            //Add the entity 
            await countryContext.Countries.AddAsync(country);
        }

        //Commit changes to the database
        await countryContext.SaveChangesAsync();
    }
}

Public Async Function ProcessAsync() As Task
	'Get the first worksheet
	Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")
	Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

	'Create the database connection
	Using countryContext As New CountryContext()
		'Iterate through all the cells
		For i = 2 To 213
			'Get the range from A-B
			Dim range = worksheet ($"A{i}:B{i}").ToList()

			'Create a Country entity to be saved to the database
			Dim country As New Country With {
				.Name = CStr(range (0).Value),
				.GDP = CDec(CDbl(range (1).Value))
			}

			'Add the entity 
			Await countryContext.Countries.AddAsync(country)
		Next i

		'Commit changes to the database
		Await countryContext.SaveChangesAsync()
	End Using
End Function

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

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

//Iterate through all rows with a value
for (var y = 2; y < i; y++)
{
    //Get the C cell
    var cell = sheet [$"C{y}"].First();

    //Set the formula for the Percentage of Total column
    cell.Formula = $"=B{y}/B{i}";
}

//Iterate through all rows with a value
for (var y = 2; y < i; y++)
{
    //Get the C cell
    var cell = sheet [$"C{y}"].First();

    //Set the formula for the Percentage of Total column
    cell.Formula = $"=B{y}/B{i}";
}

'Iterate through all rows with a value
Dim y = 2
Do While y < i
	'Get the C cell
	Dim cell = sheet ($"C{y}").First()

	'Set the formula for the Percentage of Total column
	cell.Formula = $"=B{y}/B{i}"
	y += 1
Loop

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))()

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

    //Set the basic values
    worksheet [$"A{i}"].Value = country.name;
    worksheet [$"B{i}"].Value = country.population;
    worksheet [$"G{i}"].Value = country.region;
    worksheet [$"H{i}"].Value = country.numericCode;

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

        var language = country.languages [x];

        //Get the letter for the column
        var columnLetter = GetColumnLetter(4 + x);

        //Set the language name
        worksheet [$"{columnLetter}{i}"].Value = language.name;
    }
}

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

    //Set the basic values
    worksheet [$"A{i}"].Value = country.name;
    worksheet [$"B{i}"].Value = country.population;
    worksheet [$"G{i}"].Value = country.region;
    worksheet [$"H{i}"].Value = country.numericCode;

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

        var language = country.languages [x];

        //Get the letter for the column
        var columnLetter = GetColumnLetter(4 + x);

        //Set the language name
        worksheet [$"{columnLetter}{i}"].Value = language.name;
    }
}

For i = 2 To countries.Count - 1
	Dim country = countries (i)

	'Set the basic values
	worksheet ($"A{i}").Value = country.name
	worksheet ($"B{i}").Value = country.population
	worksheet ($"G{i}").Value = country.region
	worksheet ($"H{i}").Value = country.numericCode

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

		Dim language = country.languages (x)

		'Get the letter for the column
		Dim columnLetter = GetColumnLetter(4 + x)

		'Set the language name
		worksheet ($"{columnLetter}{i}").Value = language.name
	Next x
Next i

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

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

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")

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">Hello World</Column1>
  </_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 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">Hello World</Column1>
  </_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>

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.