using IronXL;
using System;
using System.Linq;
// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");
// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];
// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;
// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;
// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}
// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();
// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);
Install-Package IronXL.Excel
Hojas de cálculo Excel
using IronXL;
// Create new Excel spreadsheet
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create worksheets (workSheet1, workSheet2, workSheet3)
WorkSheet workSheet1 = workBook.CreateWorkSheet("workSheet1");
WorkSheet workSheet2 = workBook.CreateWorkSheet("workSheet2");
WorkSheet workSheet3 = workBook.CreateWorkSheet("workSheet3");
// Set worksheet position (workSheet2, workSheet1, workSheet3)
workBook.SetSheetPosition("workSheet2", 0);
// Set active for workSheet3
workBook.SetActiveTab(2);
// Remove workSheet1
workBook.RemoveWorkSheet(1);
workBook.SaveAs("manageWorkSheet.xlsx");
Install-Package IronXL.Excel
Crear archivos Excel
using IronXL;
// Create new Excel WorkBook document
WorkBook workBook = WorkBook.Create();
// Convert XLSX to XLS
WorkBook xlsWorkBook = WorkBook.Create(ExcelFileFormat.XLS);
// Create a blank WorkSheet
WorkSheet workSheet = workBook.CreateWorkSheet("new_sheet");
// Add data and styles to the new worksheet
workSheet["A1"].Value = "Hello World";
workSheet["A1"].Style.WrapText = true;
workSheet["A2"].BoolValue = true;
workSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Double;
// Save the excel file as XLS, XLSX, CSV, TSV, JSON, XML, HTML and streams
workBook.SaveAs("sample.xlsx");
Install-Package IronXL.Excel
Convertir tipos de archivos de hoja de cálculo
using IronXL;
using System.IO;
// Import any XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");
// Export the excel file as XLS, XLSX, XLSM, CSV, TSV, JSON, XML
workBook.SaveAs("sample.xls");
workBook.SaveAs("sample.xlsx");
workBook.SaveAs("sample.tsv");
workBook.SaveAsCsv("sample.csv");
workBook.SaveAsJson("sample.json");
workBook.SaveAsXml("sample.xml");
// Export the excel file as Html, Html string
workBook.ExportToHtml("sample.html");
string htmlString = workBook.ExportToHtmlString();
// Export the excel file as Binary, Byte array, Data set, Stream
byte[] binary = workBook.ToBinary();
byte[] byteArray = workBook.ToByteArray();
System.Data.DataSet dataSet = workBook.ToDataSet(); // Allow easy integration with DataGrids, SQL and EF
Stream stream = workBook.ToStream();
Install-Package IronXL.Excel
Excel a SQL mediante System.Data.DataSet
using IronXL;
using System;
using System.Data;
// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");
// Convert the whole Excel WorkBook to a DataSet
DataSet dataSet = workBook.ToDataSet();
foreach (DataTable table in dataSet.Tables)
{
Console.WriteLine(table.TableName);
// Enumerate by rows or columns first at your preference
foreach (DataRow row in table.Rows)
{
for (int i = 0 ; i < table.Columns.Count ; i++)
{
Console.Write(row[i]);
}
}
}
Install-Package IronXL.Excel
Excel a SQL y DataGrid vía DataTable
using IronXL;
using System;
using System.Data;
// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");
// Select default sheet
WorkSheet workSheet = workBook.DefaultWorkSheet;
// Convert the worksheet to DataTable
DataTable dataTable = workSheet.ToDataTable(true);
// Enumerate by rows or columns first at your preference
foreach (DataRow row in dataTable.Rows)
{
for (int i = 0 ; i < dataTable.Columns.Count ; i++)
{
Console.Write(row[i]);
}
}
Install-Package IronXL.Excel
Formato condicional de Excel
using IronXL;
using IronXL.Formatting.Enums;
using IronXL.Styles;
WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;
// Create conditional formatting rule
var rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(ComparisonOperator.LessThan, "8");
// Set style options
rule.FontFormatting.IsBold = true;
rule.FontFormatting.FontColor = "#123456";
rule.BorderFormatting.RightBorderColor = "#ffffff";
rule.BorderFormatting.RightBorderType = BorderType.Thick;
rule.PatternFormatting.BackgroundColor = "#54bdd9";
rule.PatternFormatting.FillPattern = FillPattern.Diamonds;
// Apply formatting on specified region
workSheet.ConditionalFormatting.AddConditionalFormatting("A3:A8", rule);
// Create conditional formatting rule
var rule1 = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(ComparisonOperator.Between, "7", "10");
// Set style options
rule1.FontFormatting.IsItalic = true;
rule1.FontFormatting.UnderlineType = FontUnderlineType.Single;
// Apply formatting on specified region
workSheet.ConditionalFormatting.AddConditionalFormatting("A3:A9", rule1);
workBook.SaveAs("applyConditionalFormatting.xlsx");
Install-Package IronXL.Excel
Proteger archivos Excel
using IronXL;
WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;
// Open protected spreadsheet file
WorkBook protectedWorkBook = WorkBook.Load("sample.xlsx", "IronSoftware");
// Spreadsheet protection
// Set protection for spreadsheet file
workBook.Encrypt("IronSoftware");
// Remove protection for spreadsheet file. Original password is required.
workBook.Password = null;
workBook.Save();
// Worksheet protection
// Set protection for individual worksheet
workSheet.ProtectSheet("IronXL");
// Remove protection for particular worksheet. It works without password!
workSheet.UnprotectSheet();
workBook.Save();
Install-Package IronXL.Excel
Fórmulas de Excel en C#
using IronXL;
using System.Linq;
WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;
// Set Formulas
workSheet["A1"].Formula = "Sum(B8:C12)";
workSheet["B8"].Formula = "=C9/C11";
workSheet["G30"].Formula = "Max(C3:C7)";
// Force recalculate all formula values in all sheets.
workBook.EvaluateAll();
// Get the formula's calculated value. e.g. "52"
var formulaValue = workSheet["G30"].First().FormattedCellValue;
// Get the formula as a string. e.g. "Max(C3:C7)"
string formulaString = workSheet["G30"].Formula;
// Save changes with updated formulas and calculated values.
workBook.Save();
Install-Package IronXL.Excel
Editar metadatos de Excel en C#
using IronXL;
using System;
WorkBook workBook = WorkBook.Load("sample.xlsx");
// Set author
workBook.Metadata.Author = "Your Name";
// Set comments
workBook.Metadata.Comments = "Monthly report";
// Set title
workBook.Metadata.Title = "July";
// Set keywords
workBook.Metadata.Keywords = "Report";
// Read the creation date of the excel file
DateTime? creationDate = workBook.Metadata.Created;
// Read the last printed date of the excel file
DateTime? printDate = workBook.Metadata.LastPrinted;
workBook.SaveAs("editedMetadata.xlsx");
Install-Package IronXL.Excel
Actualizar registros de bases de datos Excel
using IronXL;
using System.Data;
using System.Data.SqlClient;
// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");
// Convert the workbook to ToDataSet
DataSet dataSet = workBook.ToDataSet();
// Your sql query
string sql = "SELECT * FROM Users";
// Your connection string
string connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=usersdb;Integrated Security=True";
using (SqlConnection connection = new SqlConnection(connectionString))
{
// Open connections to the database
connection.Open();
SqlDataAdapter adapter = new SqlDataAdapter(sql, connection);
// Update the values in database using the values in Excel
adapter.Update(dataSet);
}
Install-Package IronXL.Excel
Estilo Excel Bordes de Celda & Fuentes
using IronSoftware.Drawing;
using IronXL;
using IronXL.Styles;
using System.Linq;
WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();
var range = workSheet["A1:H10"];
var cell = range.First();
// Set background color of the cell with an rgb string
cell.Style.SetBackgroundColor("#428D65");
// Apply styling to the whole range.
// Set underline property to the font
// FontUnderlineType is enum that stands for different types of font underlying
range.Style.Font.Underline = FontUnderlineType.SingleAccounting;
// Define whether to use horizontal line through the text or not
range.Style.Font.Strikeout = false;
// Define whether the font is bold or not
range.Style.Font.Bold = true;
// Define whether the font is italic or not
range.Style.Font.Italic = false;
// Get or set script property of a font
// Font script enum stands for available options
range.Style.Font.FontScript = FontScript.Super;
// Set the type of the border line
// There are also TopBorder,LeftBorder,RightBorder,DiagonalBorder properties
// BorderType enum indicates the line style of a border in a cell
range.Style.BottomBorder.Type = BorderType.MediumDashed;
// Indicate whether the cell should be auto-sized
range.Style.ShrinkToFit = true;
// Set alignment of the cell
range.Style.VerticalAlignment = VerticalAlignment.Bottom;
// Set border color
range.Style.DiagonalBorder.SetColor("#20C96F");
// Define border type and border direction as well
range.Style.DiagonalBorder.Type = BorderType.Thick;
// DiagonalBorderDirection enum stands for direction of diagonal border inside cell
range.Style.DiagonalBorderDirection = DiagonalBorderDirection.Forward;
// Set background color of cells
range.Style.SetBackgroundColor(Color.Aquamarine);
// Set fill pattern of the cell
// FillPattern enum indicates the style of fill pattern
range.Style.FillPattern = FillPattern.Diamonds;
// Set the number of spaces to intend the text
range.Style.Indention = 5;
// Indicate if the text is wrapped
range.Style.WrapText = true;
workBook.SaveAs("stylingOptions.xls");
Install-Package IronXL.Excel
Ordenar rangos de Excel en C#
using IronXL;
WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;
// Select a range
var range = workSheet["A1:D20"];
// Select a column(B)
var column = workSheet.GetColumn(1);
// Sort the range in ascending order (A to Z)
range.SortAscending();
// Sort the range by column(C) in ascending order
range.SortByColumn("C", SortOrder.Ascending);
// Sort the column(B) in descending order (Z to A)
column.SortDescending();
workBook.SaveAs("sortExcelRange.xlsx");
Install-Package IronXL.Excel
Repetir filas y columnas de Excel
using IronXL;
WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;
// Set repeating rows for row(2-4)
workSheet.SetRepeatingRows(1, 3);
// Set repeating columns for column(C-D)
workSheet.SetRepeatingColumns(2, 3);
// Set column break after column(H). Hence, the first page will only contain column(A-G)
workSheet.SetColumnBreak(7);
workBook.SaveAs("repeatingRows.xlsx");
Install-Package IronXL.Excel
Configuración de impresión de Excel
using IronXL;
using IronXL.Printing;
WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;
// Set the print header and footer of the worksheet
workSheet.Header.Center = "My document";
workSheet.Footer.Center = "Page &P of &N";
// Set the header margin
workSheet.PrintSetup.HeaderMargin = 2.33;
// Set the size of the paper
// Paper size enum represents different sizes of paper
workSheet.PrintSetup.PaperSize = PaperSize.B4;
// Set the print orientation of the worksheet
workSheet.PrintSetup.PrintOrientation = PrintOrientation.Portrait;
// Set black and white printing
workSheet.PrintSetup.NoColor = true;
workBook.SaveAs("PrintSetup.xlsx");
Install-Package IronXL.Excel
Formato de visualización de los datos de las celdas
using IronXL;
using System;
using System.Linq;
// Load an existing WorkSheet
WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();
// Set data display format to cell
// The cell value will look like 12300%
workSheet["A2"].Value = 123;
workSheet["A2"].FormatString = "0.0%";
// The cell value will look like 123.0000
workSheet["A2"].First().FormatString = "0.0000";
// Set data display format to range
DateTime dateValue = new DateTime(2020, 1, 1, 12, 12, 12);
workSheet["A3"].Value = dateValue;
workSheet["A4"].First().Value = new DateTime(2022, 3, 3, 10, 10, 10);
workSheet["A5"].First().Value = new DateTime(2021, 2, 2, 11, 11, 11);
var range = workSheet["A3:A5"];
// The cell(A3) value will look like 1/1/2020 12:12:12 PM
range.FormatString = "MM/dd/yy h:mm:ss";
workBook.SaveAs("numberFormats.xls");
Install-Package IronXL.Excel
Cargar Excel desde base de datos SQL
using IronXL;
using System.Data;
using System.Data.SqlClient;
// Your sql query
string sql = "SELECT * FROM Users";
// Your connection string
string connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=usersdb;Integrated Security=True";
using (SqlConnection connection = new SqlConnection(connectionString))
{
// Open connections to the database
connection.Open();
SqlDataAdapter adapter = new SqlDataAdapter(sql, connection);
DataSet ds = new DataSet();
// Fill DataSet with data
adapter.Fill(ds);
// Create an Excel workbook from the SQL DataSet
WorkBook workBook = WorkBook.Load(ds);
}
Install-Package IronXL.Excel
Combinar rangos de Excel
using IronXL;
using System;
using System.Linq;
WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();
// Get a range from an Excel worksheet
var range = workSheet["A2:A8"];
// Combine two ranges
var combinedRange = range + workSheet["A9:A10"];
// Iterate over combined range
foreach (var cell in combinedRange)
{
Console.WriteLine(cell.Value);
}
Install-Package IronXL.Excel
Seleccionar rango de Excel
using IronXL;
using System;
using System.Linq;
WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();
// Get range from worksheet
var range = workSheet["A2:A8"];
// Get column from worksheet
var columnA = workSheet.GetColumn(0);
// Get row from worksheet
var row1 = workSheet.GetRow(0);
// Iterate over the range
foreach (var cell in range)
{
Console.WriteLine($"{cell.Value}");
}
// Select and print every row
var rows = workSheet.Rows;
foreach (var eachRow in rows)
{
foreach (var cell in eachRow)
{
Console.Write($" {cell.Value} |");
}
Console.WriteLine($"");
}
Install-Package IronXL.Excel
Convertir Excel a HTML
using IronXL;
using IronXL.Options;
WorkBook workBook = WorkBook.Load("sample.xlsx");
var options = new HtmlExportOptions()
{
// Set row/column numbers visible in html document
OutputRowNumbers = true,
OutputColumnHeaders = true,
// Set hidden rows/columns visible in html document
OutputHiddenRows = true,
OutputHiddenColumns = true,
// Set leading spaces as non-breaking
OutputLeadingSpacesAsNonBreaking = true
};
// Export workbook to the HTML file
workBook.ExportToHtml("workBook.html", options);
Install-Package IronXL.Excel
Funciones agregadas de Excel
using IronXL;
using System.Linq;
WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();
// Get range from worksheet
var range = workSheet["A1:A8"];
// Apply sum of all numeric cells within the range
decimal sum = range.Sum();
// Apply average value of all numeric cells within the range
decimal avg = range.Avg();
// Identify maximum value of all numeric cells within the range
decimal max = range.Max();
// Identify minimum value of all numeric cells within the range
decimal min = range.Min();
Install-Package IronXL.Excel
Crear Gráfico de Líneas Excel
using IronXL;
using IronXL.Drawing.Charts;
WorkBook workBook = WorkBook.Load("test.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;
// Set the chart type and it's position on the worksheet.
var chart = workSheet.CreateChart(ChartType.Line, 10, 10, 18, 20);
// Add the series to the chart
// The first parameter represents the address of the range for horizontal(category) axis.
// The second parameter represents the address of the range for vertical(value) axis.
var series = chart.AddSeries("B3:B8", "A3:A8");
// Set the chart title.
series.Title = "Line Chart";
// Set the legend position.
// Can be removed by setting it to None.
chart.SetLegendPosition(LegendPosition.Bottom);
// We can change the position of the chart.
chart.Position.LeftColumnIndex = 2;
chart.Position.RightColumnIndex = chart.Position.LeftColumnIndex + 3;
// Plot all the data that was added to the chart before.
// Multiple call of this method leads to plotting multiple charts instead of modifying the existing chart.
// Yet there is no possibility to remove chart or edit it's series/position.
// We can just create new one.
chart.Plot();
workBook.SaveAs("CreateLineChart.xlsx");
Install-Package IronXL.Excel
Congelar paneles en Excel
using IronXL;
using System.Linq;
WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();
// Create freeze pane from column(A-B) and row(1-3)
workSheet.CreateFreezePane(2, 3);
// Overwriting freeze or split pane to column(A-E) and row(1-5) as well as applying prescroll
// The column will show E,G,... and the row will show 5,8,...
workSheet.CreateFreezePane(5, 5, 6, 7);
workBook.SaveAs("createFreezePanes.xls");
// Remove all existing freeze or split pane
workSheet.RemovePane();
Install-Package IronXL.Excel
Copiar hojas de cálculo de Excel
using IronXL;
WorkBook firstBook = WorkBook.Load("sample.xlsx");
WorkBook secondBook = WorkBook.Create();
// Select first worksheet in the workbook
WorkSheet workSheet = firstBook.DefaultWorkSheet;
// Duplicate the worksheet to the same workbook
workSheet.CopySheet("Copied Sheet");
// Duplicate the worksheet to another workbook with the specified name
workSheet.CopyTo(secondBook, "Copied Sheet");
firstBook.Save();
secondBook.SaveAs("copyExcelWorksheet.xlsx");
Como ya sabrá, Excel es probablemente la aplicación de hoja de cálculo más utilizada del mundo. Entre los usuarios se incluyen tanto los desarrolladores como la población en general, pero son los desarrolladores quienes probablemente estarán más interesados en este artículo. Al principio, los desarrolladores no disponían de muchas opciones para trabajar con Excel en sus distintas aplicaciones. Sin embargo, había VBA (Visual Basic para aplicaciones) integrado en el paquete Office con el que podrá manipular cualquier producto Office según sus necesidades.
Los desarrolladores utilizaban VBA en Excel para personalizar sus interacciones con Excel y sus datos, incluso sus capacidades visuales. Pero, finalmente, esto no fue suficiente. Los desarrolladores querían más y empezaron a utilizar Office.Interop.
En este artículo, compararé dos librerías Excel muy buenas que no dependen de Office.Interop para trabajar con Excel. Lo son:
IronXL
NPOI
Verá y aprenderá lo que puede hacer cada biblioteca de Excel y, a continuación, comparará las dos mediante ejemplos de código y tutoriales paso a paso. Aunque este artículo no puede cubrir todas las características de ambas bibliotecas de Excel, explicará los usos más comunes y populares de cada una.
Instanciar XSSFWorkbook objeto para almacenar el archivo Excel
Obtener hoja de cálculo específica con GetSheetAt método
Accede a cada fila pasando el índice de fila a GetRow método
Accede a cada celda de la fila con GetCell método
¿Qué es NPOI?
NPOI es la versión .NET del proyecto Java POI en http://poi.apache.org/. POI es un proyecto de código abierto que puede ayudarte a leer/escribir archivos xls, doc, ppt. Tiene una amplia gama de aplicaciones.
Por ejemplo, puedes utilizarlo para:
Generar un informe de Excel sin Microsoft Office suite instalado en su servidor y más eficiente que llamar a Microsoft Excel ActiveX en segundo plano.
Extraiga texto de documentos de Office para ayudarle a implementar una función de indexación de texto completo (la mayoría de las veces esta función se utiliza para crear motores de búsqueda)
Extraer imágenes de documentos de Office
Generar hojas Excel que contengan fórmulas
NPOI y Excel
NPOI es una adaptación a C# del programa PDI Java de Apache. Es gratuito y de código abierto. Además, no necesita Interop, lo que significa que los usuarios no necesitarán tener Excel instalado para que la aplicación del desarrollador funcione con él.
IronXL y Excel
IronXL es una API de Excel para VB y C#. Con IronXL puedes leer, editar y crear archivos de hojas de cálculo Excel en .NET.
Características comunes de las bibliotecas NPOI y IronXL Excel
NPOI
IronXL
Rangos de celdas
Rangos de celdas
Estilo de las celdas (Borde, Color, Relleno, Fuente, Número, Alineaciones)
Estilos visuales de celda Formatos de fuente, tamaño, patrón de fondo, borde, alineación y número.
Cálculo de la fórmula
Fórmulas
Validación de datos
Validación de datos
Formato condicional
Formato condicional
Imágenes
Imágenes
Gráficos
Gráficos
Cuadro 1 - Comparación de funciones
## Instalación de IronXL y NPOI
Puede instalar ambas bibliotecas descargándolas manualmente, a través de NuGet o con el gestor de paquetes NuGet de Visual Studio. He aquí un breve resumen.
### Instalación de NPOI
#### Instalación de NPOI con NuGet
Para instalar NPOI a través de NuGet, abra el símbolo del sistema del desarrollador de Visual Studio e introduzca lo siguiente:
Figura 1 - Instalación de NuGet NPOI
### Gestor de paquetes NuGet de Visual Studio y NPOI
Utilice los siguientes pasos para instalar IronXL o NPOI a través del gestor de paquetes NuGet en Visual Studio:
* Haga clic con el botón derecho en el proyecto en el Explorador de soluciones
* Seleccione Gestionar paquetes NuGet
* Busque su paquete
* Haga clic en Instalar
Figura 2 - Gestor de paquetes NuGet para NPOI
### Instalación de IronXL
#### Descarga de IronXL
Para descargar IronXL, vaya a la siguiente dirección URL y haga clic en el botón "Descargar".
Figura 3 - Descargar IronXL
#### Instalación de IronXL con NuGet
Para instalar IronXL a través de NuGet, abra el símbolo del sistema del desarrollador de Visual Studio e introduzca lo siguiente:
Figura 4 - Instalación de NuGet IronXL
#### Gestor de paquetes NuGet de Visual Studio e IronXL
Utilice los siguientes pasos para instalar IronXL a través del gestor de paquetes NuGet en Visual Studio:
* Haga clic con el botón derecho en el proyecto en el Explorador de soluciones
* Seleccione Gestionar paquetes NuGet
* Busque su paquete
* Haga clic en Instalar
Gráfico 5 - Gestor de paquetes NuGet para IronXL
## Lectura y escritura en un archivo Excel con NPOI y IronXL
### Lectura de un fichero Excel con NPOI
El siguiente código demuestra cómo leer un archivo Excel y mostrar su contenido con NPOI. Añade el siguiente código e incluye los espacios de nombres necesarios:
```cs
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
```
El siguiente código lee un archivo Excel existente y lo muestra dentro de una vista de cuadrícula de datos.
```cs
public void ReadExcelNPOI()
{
DataTable dtTable = new DataTable();
List lstRows = new List();
ISheet objWorksheet;
string strPath = @"c:\temp\NPOI_Test.XLSX";
using (var fStream = new FileStream(strPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
fStream.Position = 0;
XSSFWorkbook objWorkbook = new XSSFWorkbook(fStream);
objWorksheet = objWorkbook.GetSheetAt(0);
IRow objHeader = objWorksheet.GetRow(0);
int countCells = objHeader.LastCellNum;
for (int j = 0; j < countCells; j++)
{
ICell objCell = objHeader.GetCell(j);
if (objCell == null
string.IsNullOrWhiteSpace(objCell.ToString())) continue;
{
dtTable.Columns.Add(objCell.ToString());
}
}
for (int i = (objWorksheet.FirstRowNum + 1); i <= objWorksheet.LastRowNum; i++)
{
IRow objRow = objWorksheet.GetRow(i);
if (objRow == null) continue;
if (objRow.Cells.All(d => d.CellType == CellType.Blank)) continue;
for (int j = objRow.FirstCellNum; j < countCells; j++)
{
if (objRow.GetCell(j) != null)
{
if (!string.IsNullOrEmpty(objRow.GetCell(j).ToString()) && !string.IsNullOrWhiteSpace(objRow.GetCell(j).ToString()))
{
lstRows.Add(objRow.GetCell(j).ToString());
}
}
}
if (lstRows.Count > 0)
dtTable.Rows.Add(lstRows.ToArray());
lstRows.Clear();
}
}
dataGridView1.DataSource = dtTable;
}
private void button1_Click(object sender, EventArgs e)
{
ReadExcelNPOI();
}
```
## Lectura de un archivo Excel con IronXL
El siguiente código demuestra cómo leer un archivo de Excel y mostrarlo dentro de una vista de cuadrícula de datos con IronXL. Añade el siguiente código e incluye el namespace:
```cs
using IronXL;
```
Fíjese en la inclusión de IronXL. Esto es necesario para que IronXL funcione. Añade las siguientes líneas:
```cs
private void button2_Click(object sender, EventArgs e)
{
string strPath = @"c:\temp\NPOI_Test.XLSX";
WorkBook workbook = WorkBook.Load(strPath);
WorkSheet sheet = workbook.DefaultWorkSheet;
var dtTable = sheet.ToDataTable(true);
dataGridView1.DataSource = dtTable;
}
```
Como puedes ver, todo esto supone mucho menos trabajo.
## Conclusión
¿Por qué IronXL? Como ves, IronXL tiene una API fácil de usar, que mantiene tu código limpio. Bibliotecas que utilizan IronXL presumir de código limpio y legible es una inversión que vale la pena mediante la reducción de tiempo y esfuerzo necesarios para entender lo que el código permite que se cambie sin romper las cosas.
IronXL es más intuitivo en todos los sentidos y, al mismo tiempo, tan potente como NPOI. Y, por supuesto, con una clave de licencia tendrá acceso a la ventaja más importante del software de pago: obtendrá nuestro soporte profesional, programas de actualización coherentes y fiables, y la posibilidad de solicitar funciones a los agentes de soporte de Iron Software, que estarán encantados de ayudarle. Esto es algo que el código abierto no puede ofrecer.
## Descargas
Este proyecto está disponible en GitHub:
Ejemplo de IronXL frente a NPOI