Una comparación entre IronXL y Epplus

¿Qué es el software EPPlus?

EPPlus es una biblioteca basada en NuGet para .NET Framework/.NET Core para gestionar hojas de cálculo Office Open XML. La versión 5 incluye soporte para .NET Framework 3.5 y .NET Core 2.0. EPPlusno depende de otras bibliotecas, como Microsoft Excel.

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

La biblioteca fue creada con la programación en mente. El objetivo siempre ha sido que un desarrollador familiarizado con Excel u otra biblioteca de hojas de cálculo pueda aprender rápidamente a usar la API. Alternativamente, como alguien dijo: "¡Utiliza IntelliSense para ganar!"

Instalación de EPPlus

Para instalar EPPlusdesde Visual Studio, vaya a Ver > Otras Ventanas > Consola del Administrador de Paquetes y escriba el siguiente comando:

Install-Package EPPlus

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

dotnet add package EPPlus

EPPlus es un paquete de dotnet que puedes añadir a tu proyecto.

¿Qué es IronXL?

IronXL es una API de Excel para C# y VB que permite leer, editar y crear hojas de cálculo de Excel en .NET sin necesidad de instalar Microsoft Office ni depender de Excel Interop. La biblioteca admite de forma nativa formatos de hoja de cálculo como XLS, XLSX, CSV y otros.

.NET Core, .NET Framework, Xamarin, Mobile, Linux, macOS y Azure son compatibles con IronXL.

Hay varias formas de leer y escribir datos hacia y desde su hoja de cálculo.

Agregar IronXLmediante el paquete NuGet

Podemos agregar el paquete IronXLa su cuenta de una de tres formas, para que pueda elegir la que mejor le funcione.

• Usando la Consola del Administrador de Paquetes para instalar IronXL

Usa el siguiente comando para abrir la Consola del Administrador de Paquetes en tu Proyecto:

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

Esto le llevará a la Consola del Administrador de Paquetes. Luego, en la terminal del Administrador de Paquetes, escriba el siguiente comando:

Install-Package IronXL.Excel

• Usando el Administrador de Paquetes NuGet para instalar IronXL

Este es un enfoque diferente para obtener el Administrador de Paquetes NuGet instalado. No necesitará utilizar este enfoque si ya ha completado la instalación utilizando el método anterior.

Para acceder al Administrador de Paquetes NuGet, vaya a Herramientas > Administrador de Paquetes NuGet => Seleccione Administrar Paquetes NuGet para la Solución del menú desplegable.

Esto lanzará la Solución NuGet; seleccione "Explorar" y busque IronXL.

En la barra de búsqueda, escriba Excel:

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

Antes de entrar en los ejemplos de código, aquí tienes una comparación detallada de cómo se comparan EPPluse IronXLen las áreas clave tratadas en este artículo:

Característica	EPPlus	IronXL
Leer archivos XLSX	Sí	Sí
Crear archivos XLSX	Sí	Sí
Compatibilidad con el formato XLS	No	Sí
Exportar a CSV, JSON, XML	Solo CSV	CSV, JSON, XML
Exportación de bases de datos (Entity Framework)	No incluido	Sí
Ayudas para la validación de datos	No incluido	Sí
Operaciones con varios libros	Enfoque en una sola hoja de cálculo	Varias hojas de cálculo y varios libros
Licencias	Comercial o Polyform No comercial	Comercial (perpetua)

Para probar las operaciones de Excel de IronXLcontra EPPlusen su propio proyecto, está disponible una prueba gratuita de 30 días.

Creación de un archivo Excel con IronXL

Crear un nuevo libro de Excel con IronXLrequiere una sola línea de código:

// Create a new Excel workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

// Create a new Excel workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

' Create a new Excel workbook in XLSX format
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

IronXL puede crear archivos en formatos XLS (la versión anterior de Excel) y XLSX (la versión actual y más reciente de Excel), aprovechando toda la gama de capacidades de Excel.

• Establecer hoja de trabajo predeterminada

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

// Create a worksheet named "2020 Budget" in the workbook
var sheet = workbook.CreateWorkSheet("2020 Budget");

// Create a worksheet named "2020 Budget" in the workbook
var sheet = workbook.CreateWorkSheet("2020 Budget");

' Create a worksheet named "2020 Budget" in the workbook
Dim sheet = workbook.CreateWorkSheet("2020 Budget")

La hoja de cálculo está representada por sheet en el fragmento de código anterior, y puedes usarla para establecer valores y estilos de celda y hacer prácticamente todo lo que Excel puede hacer. También puede codificar su documento Excel a un archivo de solo lectura y realizar operaciones de eliminación. También puede vincular sus hojas de trabajo, tal como lo hace Excel.

Permíteme clarificar la diferencia entre un libro y una hoja de cálculo en caso de que no estés seguro.

Las hojas de trabajo están contenidas en un libro. Esto significa que puede poner tantas hojas de trabajo dentro de un libro como desee. Explicaré cómo hacer esto en un artículo posterior. Las hojas de cálculo constan de filas y columnas. La intersección de una fila y una columna se conoce como celda, y es con lo que va a interactuar dentro de Excel.

Creación de un archivo Excel con EPPlusSoftware AB

EPPlus se puede utilizar para crear archivos Excel y realizar operaciones como crear tablas dinámicas, áreas de pivote e incluso 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 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 columns 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 column names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows into 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 columns 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 column names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows into 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 columns 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 column 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 into 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 está usando ASP.NET MVC, simplemente copie el contenido del método y péguelo donde lo necesite (por ejemplo, ASP.NET clásico, Aplicación de Consola, Formularios de Windows, etc.).

El código es autodocumentado, con bastantes comentarios para ayudarle a entender los diversos procesos de procesamiento. Pero primero, un repaso rápido de lo que estamos haciendo aquí:

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

El enfoque de IronXLpara la creación de libros de trabajo requiere una sola línea de código en comparación con la configuración de múltiples pasos de EPPlusque implica ExcelPackage, ExcelWorksheet, y la iteración manual de celdas. Para los equipos que dan prioridad a la creación rápida de prototipos y a una depuración más sencilla, esta diferencia en el código repetitivo puede acumularse a lo largo del ciclo de vida de un proyecto.

Cómo EPPlusSoftware AB escribe archivos de Excel

EPPlus admite el trabajo con archivos Excel. Es una biblioteca .net que lee y escribe archivos Excel.

• Leyendo Archivos Excel

Para hacerlo, primero necesita instalar el paquete EPPlus: vaya a "Herramientas"-> "Administrador de paquetes NuGet"-> "Administrar NuGet para esta solución" -> "Instalar EPPlus" -> "Instalar EPPlus" -> "Instalar EPPlus" -> "Instalar EPPlus" -> "Instalar EPPlus" -> Instalar EP. Busque "EPPlus" en la pestaña "Explorar", luego instale el paquete NuGet.

Puede usar el código a continuación 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

Aquí hay un ejemplo de salida de aplicación de consola con un archivo Excel de ejemplo (.xlsx) con el que estamos trabajando. Aquí hay un archivo xlsx para leer en C# usando EPPlus.

Las siguientes maneras de cargar datos desde múltiples fuentes pueden ser accedidas usando la propiedad "cells" (ExcelRange):

• Leer un archivo de texto CSV y cargar los datos en un rango de una hoja de cálculo con LoadFromText y LoadFromTextAsync. IronXLtambién ofrece sus propias operaciones de exportación e importación de CSV.
• LoadFromDataReaderAsync y LoadFromDataReader - carga campos de datos de un DataReader en un rango.
• LoadFrom- GetValue** — retorna un valor de tipo específico. - carga datos de una DataTable en un rango. Puede importar datos desde una variedad de fuentes, incluidas XML (se suministra un ejemplo) y bases de datos.
• LoadFromCollection - carga de forma reflexiva datos de un IEnumerable en un rango.
• LoadFromCollection with attributes - carga datos de forma reflexiva desde un IEnumerable a 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 objetos ExpandoObject/dinámicos (a través de su interfaz IDictionary<string, object>) en un rango. Esto es útil para importar datos JSON, y se incluye un ejemplo.
• LoadFromArrays - carga datos de un IEnumerable de objeto [] en un rango, con cada array de objeto correspondiente a una fila en la hoja de cálculo.

Al usar estos métodos, puede opcionalmente dar 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.

• Escribiendo Archivos Excel

A continuación, veamos si podemos exportar datos a un nuevo archivo Excel.

Aquí hay algunos datos/objetos de muestra que nos gustaría guardar como un 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 requiere solo 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, estoy generando un nuevo archivo de hoja de cálculo en la misma carpeta del proyecto (el archivo Excel se producirá en la carpeta 'bin' del proyecto). El código fuente está 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

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

La API lista para usar arriba puede ser utilizada en la consola .NET Core, un proyecto de prueba o una aplicación ASP.NET Core, y la lógica puede ser modificada para adaptarse a sus necesidades.

Estas técnicas pueden ser accesadas usando la propiedad "cells" (ExcelRange):

• ToText and ToTextAsync — crea una cadena CSV desde un rango.
• Escribir un rango en un archivo CSV con SaveToText y SaveToTextAsync.
• Exportar datos desde un rango a un System usando el método ToDataTable*DataTable*. - GetValue** — retorna un valor de tipo específico.
• Value — devuelve o establece el valor del rango. Los métodos GetValue y SetValue se pueden usar en el objeto hoja de trabajo.

Los métodos GetValue y SetValue también se pueden utilizar directamente en el objeto de hoja de cálculo. - GetValue — 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.
• SetValue — cambia el valor de una celda.

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

Abrir y escribir en formato Office Open XML XLSX con IronXL

No se requiere la Interop de Office.

No hay dependencias particulares o la necesidad de instalar Microsoft Office en Core o Azure. IronXLes una renombrada biblioteca de hojas de cálculo xl para C# y VB.NET para .NET core y .NET framework.

• Hoja de trabajo a ser cargada

• Leyendo Archivos Excel No se requiere Microsoft Office en Core o Azure.

Una hoja de Excel está representada por la clase WorkBook. Utilizamos WorkBook para leer un archivo Excel en C# que contiene incluso tablas dinámicas. Objetos WorkSheet pueden ser encontrados en numerosos WorkBooks.

/**
 Load WorkBook
 **/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

/**
 Load WorkBook
 **/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

'''
''' Load WorkBook
''' *
Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")

Estas son las hojas de cálculo del documento Excel. Si la hoja tiene hojas de trabajo, use WorkBook y GetWorkSheet. Si la hoja contiene hojas de trabajo, utilice el nombre WorkBook para encontrarlas con GetWorkSheet.

var worksheet = workbook.GetWorkSheet("GDPByCountry");

var worksheet = workbook.GetWorkSheet("GDPByCountry");

Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

Usamos WorkBook para abrir un archivo Excel en C# que incluya tablas dinámicas.

Construya un nuevo WorkBook con el tipo de hoja para generar un nuevo WorkBook en memoria.

/**
 Create WorkBook
 **/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

/**
 Create WorkBook
 **/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

'''
''' Create WorkBook
''' *
Dim workbook As New WorkBook(ExcelFileFormat.XLSX)

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

Crear una hoja de trabajo si no tiene una.

En Excel, esta es como se ve un libro con dos hojas de trabajo.

El WorkBook es el nombre de un nuevo WorkSheet que se 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.

Una colección bidimensional de "Cell" es la clase "Range".

Denota un rango específico de celdas Excel. Denota un rango específico de celdas de Excel. Con el índice de cadena en un objeto de Hoja de trabajo, puedes obtener rangos.

var range = worksheet["D2:D101"];

var range = worksheet["D2:D101"];

Dim range = worksheet("D2:D101")

GetRange también puede ser llamado desde una Hoja de trabajo. GetRange también se puede llamar desde una WorkSheet.

• Dentro de un rango, editar valores de celdas

Usa un bucle For si se conoce la cuenta. También puedes hacer el estilo de celdas desde aquí. Validar Datos en Hojas de cálculo

/**
 Edit Cell Values in 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
 **/
 // 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
''' *
 ' 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

Para validar una hoja de datos, utiliza IronXL.

El ejemplo DataValidation valida teléfonos con libphonenumber-CSharp y correos y fechas con APIs de C#. El código anterior recorre las filas de la hoja de cálculo, tomando las celdas como lista. Cada método validado verifica el valor de una celda y devuelve un error si el valor es incorrecto.

/**
 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
 **/
 // 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
''' *
 ' 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

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

Usando Entity Framework para Exportar Datos

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

Usando Entity Framework para exportar datos

El ejemplo ExcelToDB lee una hoja de cálculo que contiene el PIB por nación y lo exporta a SQLite. El ejemplo ExcelToDB lee una hoja de cálculo que contiene el PIB por nación y lo exporta a SQLite.

Se deben instalar los paquetes NuGet de Entity Framework de SQLite.

Usa EntityFramework para construir un objeto modelo que exporte 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 apropiado y busque el equivalente UseSqLite (UseMySQL, UseSqlServer, etc.).

/**
 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
 **/
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
''' *
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 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 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

La propiedad Formula se puede utilizar para establecer la fórmula de una celda.

La propiedad Formula se puede utilizar 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

Los datos de una API pueden descargarse a una hoja de cálculo

Los datos de una API pueden ser descargados a una hoja de cálculo

Usa la propiedad Formula para establecer la fórmula de una celda. Los datos JSON de la API se ven así:

/**
 Data 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
 **/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();

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

RestClient.Net se usa para realizar una llamada REST.

Abrir archivos Excel con IronXL

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

Después de iniciar el archivo Excel, agregue las primeras líneas que leen la primera celda en la primera hoja y la imprimen.

Usando IronXL, cree un nuevo archivo Excel.

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

Abre archivos de Excel con IronXL.

/**
 Create 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
 **/
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
''' *
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

A continuación, puede ahorrar el resultado en formato CSV, JSON o XML utilizando los códigos correspondientes, tal y como se muestra en los ejemplos de código de IronXL.

Por ejemplo, para Guardar en XML .xml

Para guardar en XML utilice SaveAsXml de la siguiente manera:

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

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

newXLFile.SaveAsXml($"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML")

Leer Excel es más fácil con IronXLque con EPPlus.

<?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>

IronXL ofrece una API más concisa para leer archivos de Excel: acceder a columnas, filas y celdas de un libro de trabajo suele requerir menos líneas de código. EPPlus, por el contrario, expone una API a nivel de celda más granular que requiere un manejo explícito de columnas y filas, lo que ofrece un control preciso pero añade verbosidad.

IronXL ofrece una mayor flexibilidad a la hora de manipular documentos de Excel. Permite crear hojas adicionales en cualquier momento, leer datos de varias hojas de cálculo y libros de trabajo en un único flujo de trabajo, y exportar los datos del libro de trabajo directamente a una base de datos. EPPluscentra su API en trabajar con hojas de cálculo individuales, un enfoque que resulta sencillo para tareas de una sola hoja, pero que genera pasos de integración adicionales para los equipos que necesitan realizar operaciones entre libros de trabajo.

¿En qué se diferencian EPPluse IronXLen cuanto a licencias y precios?

¿Qué biblioteca elegir?

EPPlus ofrece una API sólida y consolidada para trabajar con hojas de cálculo Office Open XML, y su control granular a nivel de celda resulta ideal para proyectos que requieren una manipulación precisa de las hojas de cálculo. Para los equipos cuyos requisitos se extienden a la exportación en múltiples formatos (XML, HTML, JSON), operaciones entre libros de trabajo e integración con bases de datos, IronXLañade estas capacidades como operaciones de primer nivel. IronXLtambién recalcula las fórmulas cada vez que se edita el documento y proporciona una sintaxis de rango intuitiva con WorkSheet[“A1:B10”]. Los formatos de datos de las celdas abarcan texto, números, fórmulas, fechas, divisas, porcentajes, notación científica y hora, mientras que el estilo de las celdas incluye fuentes, tamaños, patrones de fondo, bordes y alineaciones. La ordenación está disponible en rangos, columnas y filas. La elección entre ambas depende, en última instancia, de si su proyecto necesita el manejo específico de Open XML de EPPluso la gama más amplia de funciones de IronXL. Para ver cómo IronXLse adapta a su flujo de trabajo, descargue una prueba gratuita de 30 días y pruebe los ejemplos de este artículo en su propio entorno.

Este sitio no está afiliado, respaldado ni patrocinado por EPPlus. Este sitio no está afiliado, respaldado ni patrocinado por EPPlus. Todos los nombres de producto, logotipos y marcas son propiedad de sus respectivos dueños. Las comparaciones son solo para fines informativos y reflejan información públicamente disponible en el momento de la redacción.)}]