Una comparación entre IronXL y Epplus

¿Qué es el software EPPlus?

EPPlus es una biblioteca basada en NuGet for .NET Framework/.NET Core para gestionar hojas de cálculo Office Open XML. La versión 5 incluye soporte for .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 archivos de hojas de cálculo de Excel en .NET sin necesidad de instalar Microsoft Office ni depender de Excel Interop. La biblioteca IronXLgestiona de forma nativa los formatos XLS, XLSX, CSV y otros formatos de hojas de cálculo.

.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 IronXLfrente a EPPlusen su propio proyecto, hay 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);

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

La hoja de cálculo se representa mediante sheet en el fragmento de código anterior, y puede utilizarla 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á el código fuente completo para convertir un DataTable normal en un archivo Excel XLSX 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);
}

Como puede ver, se trata de un método ActionResult que puede utilizarse en cualquier controlador ASP.NET MVC; 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í:

• Mediante un método personalizado de Data Provider, obtenemos un objeto DataTable.
• Creamos un objeto ExcelPackage, que es el contenedor principal de EPPluspara el archivo XLSX.
• Añadimos un ExcelWorksheet al ExcelPackage, que será la hoja de cálculo donde se introducirán los datos.
• Para crear nuestra fila de encabezado, iteramos las columnas DataTable y las añadimos 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 modo que cada fila DataTable se corresponda con una fila de la hoja de cálculo.
• Creamos un MemoryStream para almacenar los datos binarios ExcelPackage cuando se completa la conversión de DataTable a ExcelPackage y, a continuación, 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 varios pasos de EPPlus, que 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());
                    }
                }
            }
        }
    }
}

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

• Lea un archivo de texto CSV y cargue 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 desde un DataReader en un rango.
• LoadFrom- GetValue** — retorna un valor de tipo específico.: carga datos desde un 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 con atributos: carga de forma reflexiva datos de un IEnumerable en un rango o una tabla. Los estilos, formatos numéricos, fórmulas y otras propiedades se especifican mediante atributos.
• LoadFromDictionaries: carga datos de un IEnumerable de objetos ExpandoObject/dynamic (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 una matriz de objetos en un rango, donde cada matriz de objetos corresponde a una fila de 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"},
};

Para crear un nuevo archivo de 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 que aparece a continuación, 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();
    }
}

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 se puede utilizar para consultar datos de una hoja de cálculo porque la propiedad de celda 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 for .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 de 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");

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 cálculo, utilice el nombre WorkBook para encontrarlas con GetWorkSheet.

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

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

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

Cree un nuevo WorkBook con el tipo de hoja para generar un nuevo libro de trabajo en memoria.

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

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

Para hojas de cálculo antiguas de Microsoft Excel, utilice ExcelFileFormat.XLS (95 y versiones 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 puedes crear.

var worksheet = workbook.CreateWorkSheet("Countries");

var worksheet = workbook.CreateWorkSheet("Countries");

Pasa el nombre de la hoja de cálculo 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"];

GetRange también puede ser llamado desde una Hoja de trabajo. GetRange también se puede llamar desde una hoja de cálculo.

• 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);
}

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);
}

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

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 país 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; }
}

Para utilizar una base de datos diferente, instale el paquete NuGet adecuado y busque el equivalente a 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);
    }
}

Genera un CountryContext, luego recorre el 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();
    }
}

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

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

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

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);
}

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

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

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 ofrece 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 de 30 días gratuita y pruebe los ejemplos de este artículo en su propio Entorno.