Cómo trabajar con archivos de Excel en C#: Figura 1 - Tutorial

¿Cómo se trabaja con un libro de Excel en C#?

1. Crear un proyecto de Visual Studio y agregar el paquete NuGet de IronXL.
2. Crear un archivo de Excel sin Interop.
3. Añadir estilo al archivo de Excel utilizando IronXL.
4. Leer valores de Excel y calcular.
5. Convertir Excel a HTML para uso web.

¿Qué es la biblioteca IronXL?

IronXL es una biblioteca robusta for .NET que simplifica el trabajo con archivos de Excel. Cuenta con una API intuitiva que simplifica la manipulación de documentos de Excel y es compatible con diversos formatos, como XLS, XLSX y CSV. Esta versatilidad permite manipular fácilmente los valores de las celdas, las fórmulas y el formato. IronXL está optimizado para el rendimiento, es capaz de gestionar de forma eficiente archivos de gran tamaño y operaciones de datos complejas, al tiempo que garantiza un uso eficiente de la memoria. Su compatibilidad multiplataforma mejora su utilidad en diferentes sistemas operativos. Estas son sus principales características y ventajas:

¿Cuáles son las características principales de IronXL?

1. Importación y Exportación:

   • Importar datos: Admite los formatos XLS, XLSX, CSV y TSV.
   • Exportar datos: permite exportar hojas de cálculo a XLS, XLSX, CSV, TSV y JSON.

2. Manipulación de Datos:

   • System.Data Integration: Trabaja con hojas de cálculo como objetos DataSet y DataTable.
   • Fórmulas: Admite fórmulas de Excel que se recalculan cuando se editan las hojas.

3. Estilo y Formato:

   • Estilo de celdas: Personaliza la fuente, el tamaño, el patrón de fondo, el borde, la alineación y los formatos numéricos.
   • Ranges: Configuración intuitiva de rangos con la sintaxis WorkSheet["A1:B10"].

4. Seguridad:

   • Cifrado: Cifra y descifra archivos XLSX, XLSM y XLTX con contraseñas.
5. Compatibilidad Multiplataforma:
   • Funciona con .NET Framework, .NET Core, .NET Standard y Azure.
   • Compatible con Windows, macOS, Linux, Docker y AWS.

¿Por qué debería elegir la biblioteca IronXL en lugar de otras bibliotecas de Excel?

1. No es necesario tener Microsoft Office: IronXL no requiere que Microsoft Office esté instalado, lo que lo hace ligero y fácil de implementar.
2. Facilidad de uso: La API es intuitiva y fácil de usar, lo que permite a los desarrolladores integrar rápidamente la funcionalidad de Excel en sus aplicaciones.
3. Rendimiento: IronXL está optimizado para ofrecer un rendimiento óptimo, lo que garantiza un procesamiento rápido y eficiente de archivos Excel de gran tamaño.
4. Versatilidad: Adecuado para una amplia gama de aplicaciones, incluyendo soluciones web, de escritorio y basadas en la nube.
5. Documentación exhaustiva: Se dispone de una amplia documentación y ejemplos, lo que facilita a los desarrolladores dar los primeros pasos y encontrar soluciones a problemas comunes.

¿Cómo puedo empezar a utilizar IronXL?

Para usar IronXL en tus proyectos .NET, necesitas asegurarte de que tu entorno de desarrollo cumpla con los siguientes requisitos:

dotnet add package IronXL.Excel --version 2024.8.5

dotnet add package IronXL.Excel --version 2024.8.5

¿Cómo creo mi primer archivo de Excel con IronXL?

Desarrollemos un proyecto de Visual Studio y añadamos la biblioteca IronXL para empezar a trabajar con un archivo de Excel.

¿Cómo creo un proyecto de Visual Studio y añado IronXL?

Abre Microsoft Visual Studio y selecciona "Crear un nuevo proyecto" para empezar.

Selecciona la plantilla de proyecto que prefieras. Aquí hemos seleccionado "Aplicación de consola" para simplificar.

Ahora ingresa el nombre y la ubicación del proyecto.

Selecciona la versión de .NET Framework que prefieras. Hemos seleccionado la última versión disponible en nuestro equipo.

Una vez que haga clic en el botón "Crear", el proyecto se creará y estará listo para su uso. Abre el Explorador de Soluciones para verificar los archivos del proyecto.

Ahora, instalemos la biblioteca IronXL desde el administrador de paquetes NuGet como se muestra anteriormente.

¿Cómo puedo crear un archivo de Excel sin Interop?

Ahora vamos a crear un archivo de Excel sin utilizar la biblioteca Microsoft Interop. IronXL ofrece una forma sencilla e intuitiva de crear hojas de cálculo mediante programación.

using IronXL;

namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create new Excel WorkBook Object
            WorkBook workBook = WorkBook.Create();
            // Create WorkSheet
            WorkSheet workSheet = workBook.CreateWorkSheet("newXlDemo");
            // Add data in new worksheet
            workSheet["A1"].Value = "IronXL is the best Excel library";           
            // Save the Excel file as XLSX
            workBook.SaveAs("myIronXlDemo.xlsx");
        }
    }
}

using IronXL;

namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create new Excel WorkBook Object
            WorkBook workBook = WorkBook.Create();
            // Create WorkSheet
            WorkSheet workSheet = workBook.CreateWorkSheet("newXlDemo");
            // Add data in new worksheet
            workSheet["A1"].Value = "IronXL is the best Excel library";           
            // Save the Excel file as XLSX
            workBook.SaveAs("myIronXlDemo.xlsx");
        }
    }
}

Imports IronXL

Namespace WorkingWithIronXL
	Public Class Program
		Public Shared Sub Main()
			' Create new Excel WorkBook Object
			Dim workBook As WorkBook = WorkBook.Create()
			' Create WorkSheet
			Dim workSheet As WorkSheet = workBook.CreateWorkSheet("newXlDemo")
			' Add data in new worksheet
			workSheet("A1").Value = "IronXL is the best Excel library"
			' Save the Excel file as XLSX
			workBook.SaveAs("myIronXlDemo.xlsx")
		End Sub
	End Class
End Namespace

Explicación del Código

1. Agregamos el espacio de nombres IronXL para comenzar a trabajar con la biblioteca.
2. Crea un objeto Excel con WorkBook.Create() para crear un archivo XLSX.
3. Llame al método CreateWorkSheet para crear una hoja de cálculo dentro del libro.
4. Añade valores a las celdas utilizando workSheet["A1"].Value.
5. Guarde el archivo Excel utilizando workBook.SaveAs y proporcionando un nombre de archivo.

Archivo Excel de salida

// Save as different Excel formats
workBook.SaveAs("file.xlsx"); // Excel 2007+ format
workBook.SaveAs("file.xls");  // Excel 97-2003 format
workBook.SaveAs("file.xlsm"); // Excel with macros

// Export to other formats
workBook.SaveAsCsv("file.csv", ",");  // CSV with comma delimiter
workBook.SaveAsJson("file.json");     // JSON format
workBook.SaveAsXml("file.xml");       // XML format

// Save as different Excel formats
workBook.SaveAs("file.xlsx"); // Excel 2007+ format
workBook.SaveAs("file.xls");  // Excel 97-2003 format
workBook.SaveAs("file.xlsm"); // Excel with macros

// Export to other formats
workBook.SaveAsCsv("file.csv", ",");  // CSV with comma delimiter
workBook.SaveAsJson("file.json");     // JSON format
workBook.SaveAsXml("file.xml");       // XML format

' Save as different Excel formats
workBook.SaveAs("file.xlsx") ' Excel 2007+ format
workBook.SaveAs("file.xls")  ' Excel 97-2003 format
workBook.SaveAs("file.xlsm") ' Excel with macros

' Export to other formats
workBook.SaveAsCsv("file.csv", ",")  ' CSV with comma delimiter
workBook.SaveAsJson("file.json")     ' JSON format
workBook.SaveAsXml("file.xml")       ' XML format

try 
{
    WorkBook workBook = WorkBook.Create();
    WorkSheet workSheet = workBook.CreateWorkSheet("Demo");
    workSheet["A1"].Value = "Sample Data";

    // Check if directory exists
    string directory = @"C:\ExcelFiles\";
    if (!Directory.Exists(directory))
    {
        Directory.CreateDirectory(directory);
    }

    workBook.SaveAs(Path.Combine(directory, "output.xlsx"));
}
catch (Exception ex)
{
    Console.WriteLine($"Error creating Excel file: {ex.Message}");
}

try 
{
    WorkBook workBook = WorkBook.Create();
    WorkSheet workSheet = workBook.CreateWorkSheet("Demo");
    workSheet["A1"].Value = "Sample Data";

    // Check if directory exists
    string directory = @"C:\ExcelFiles\";
    if (!Directory.Exists(directory))
    {
        Directory.CreateDirectory(directory);
    }

    workBook.SaveAs(Path.Combine(directory, "output.xlsx"));
}
catch (Exception ex)
{
    Console.WriteLine($"Error creating Excel file: {ex.Message}");
}

Imports System
Imports System.IO

Try
    Dim workBook As WorkBook = WorkBook.Create()
    Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Demo")
    workSheet("A1").Value = "Sample Data"

    ' Check if directory exists
    Dim directory As String = "C:\ExcelFiles\"
    If Not Directory.Exists(directory) Then
        Directory.CreateDirectory(directory)
    End If

    workBook.SaveAs(Path.Combine(directory, "output.xlsx"))
Catch ex As Exception
    Console.WriteLine($"Error creating Excel file: {ex.Message}")
End Try

¿Cómo puedo aplicar estilos a archivos de Excel con IronXL?

Ahora veamos cómo añadir estilos a las celdas de Excel. IronXL ofrece opciones de estilo completas para crear hojas de cálculo con un aspecto profesional.

using IronXL;

namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create a new workbook
            WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
            // Create a new worksheet
            WorkSheet workSheet = workBook.CreateWorkSheet("StyledSheet");
            // Add multiple values to cells
            workSheet["A1"].Value = "This Styled Text with Awesome IronXL library";
            workSheet["A2"].Value = 999999;
            // Apply styles to cells
            workSheet["A1"].Style.Font.Bold = true;
            workSheet["A1"].Style.Font.Italic = true;
            workSheet["A1"].Style.Font.Height = 14;
            workSheet["A1"].Style.Font.Color = "#FF0000"; // Red color
            workSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Double;
            workSheet["A2"].Style.BottomBorder.SetColor("#00FF00"); // Green color
            // Save the workbook
            workBook.SaveAs("myIronXlWriteDemo.xlsx");
        }
    }
}

using IronXL;

namespace WorkingWithIronXL
{
    public class Program
    {
        public static void Main()
        {
            // Create a new workbook
            WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
            // Create a new worksheet
            WorkSheet workSheet = workBook.CreateWorkSheet("StyledSheet");
            // Add multiple values to cells
            workSheet["A1"].Value = "This Styled Text with Awesome IronXL library";
            workSheet["A2"].Value = 999999;
            // Apply styles to cells
            workSheet["A1"].Style.Font.Bold = true;
            workSheet["A1"].Style.Font.Italic = true;
            workSheet["A1"].Style.Font.Height = 14;
            workSheet["A1"].Style.Font.Color = "#FF0000"; // Red color
            workSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Double;
            workSheet["A2"].Style.BottomBorder.SetColor("#00FF00"); // Green color
            // Save the workbook
            workBook.SaveAs("myIronXlWriteDemo.xlsx");
        }
    }
}

Imports IronXL

Namespace WorkingWithIronXL
	Public Class Program
		Public Shared Sub Main()
			' Create a new workbook
			Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
			' Create a new worksheet
			Dim workSheet As WorkSheet = workBook.CreateWorkSheet("StyledSheet")
			' Add multiple values to cells
			workSheet("A1").Value = "This Styled Text with Awesome IronXL library"
			workSheet("A2").Value = 999999
			' Apply styles to cells
			workSheet("A1").Style.Font.Bold = True
			workSheet("A1").Style.Font.Italic = True
			workSheet("A1").Style.Font.Height = 14
			workSheet("A1").Style.Font.Color = "#FF0000" ' Red color
			workSheet("A2").Style.BottomBorder.Type = IronXL.Styles.BorderType.Double
			workSheet("A2").Style.BottomBorder.SetColor("#00FF00") ' Green color
			' Save the workbook
			workBook.SaveAs("myIronXlWriteDemo.xlsx")
		End Sub
	End Class
End Namespace

Explicación del Código

1. Crea un archivo de Excel utilizando WorkBook.Create.
2. Crea una hoja de cálculo utilizando workBook.CreateWorkSheet.
3. Añade valores a las celdas utilizando workSheet["A1"].Value.
4. Añade estilos a las celdas utilizando propiedades como workSheet["A1"].Style.Font.Bold.
5. Guarde el libro de trabajo utilizando workBook.SaveAs.

Archivo Excel de Salida

// Apply styles to a range
var range = workSheet["A1:D10"];
foreach (var cell in range)
{
    cell.Style.Font.Bold = true;
    cell.Style.Font.Color = "#0000FF"; // Blue
    cell.Style.SetBackgroundColor("#FFFF00"); // Yellow background
}

// Apply styles to a range
var range = workSheet["A1:D10"];
foreach (var cell in range)
{
    cell.Style.Font.Bold = true;
    cell.Style.Font.Color = "#0000FF"; // Blue
    cell.Style.SetBackgroundColor("#FFFF00"); // Yellow background
}

' Apply styles to a range
Dim range = workSheet("A1:D10")
For Each cell In range
    cell.Style.Font.Bold = True
    cell.Style.Font.Color = "#0000FF" ' Blue
    cell.Style.SetBackgroundColor("#FFFF00") ' Yellow background
Next

// Add conditional formatting rule
var rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(
    ComparisonOperator.GreaterThan, "100");
rule.FontFormatting.Bold = true;
rule.FontFormatting.FontColor = "#FF0000"; // Red for values > 100
workSheet.ConditionalFormatting.AddConditionalFormatting("A1:A10", rule);

// Add conditional formatting rule
var rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(
    ComparisonOperator.GreaterThan, "100");
rule.FontFormatting.Bold = true;
rule.FontFormatting.FontColor = "#FF0000"; // Red for values > 100
workSheet.ConditionalFormatting.AddConditionalFormatting("A1:A10", rule);

' Add conditional formatting rule
Dim rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(ComparisonOperator.GreaterThan, "100")
rule.FontFormatting.Bold = True
rule.FontFormatting.FontColor = "#FF0000" ' Red for values > 100
workSheet.ConditionalFormatting.AddConditionalFormatting("A1:A10", rule)

¿Cómo leo valores de Excel y realizo cálculos?

Ahora veamos cómo leer archivos de Excel con IronXL y realizar cálculos. IronXL admite diversas funciones matemáticas para el análisis de datos.

using IronXL;
using System;

namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ReadData()
        {
            // Load the Excel worksheet
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            // Select the first worksheet
            WorkSheet workSheet = workBook.WorkSheets[0];
            // Read a specific cell value
            int cellValue = workSheet["A2"].IntValue;
            Console.WriteLine($"Value in A2: {cellValue}");
            // Read a range of cells
            foreach (var cell in workSheet["A1:H10"])
            {
                Console.Write($"{cell.Text}\t");
                if(cell.AddressString.Contains("H"))
                {
                    Console.WriteLine();
                }
            }
            // Calculate aggregate values
            decimal sum = workSheet["F2:F10"].Sum();
            Console.WriteLine($"Sum of F2:F10: {sum}");
        }
    }
}

using IronXL;
using System;

namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ReadData()
        {
            // Load the Excel worksheet
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.xlsx");
            // Select the first worksheet
            WorkSheet workSheet = workBook.WorkSheets[0];
            // Read a specific cell value
            int cellValue = workSheet["A2"].IntValue;
            Console.WriteLine($"Value in A2: {cellValue}");
            // Read a range of cells
            foreach (var cell in workSheet["A1:H10"])
            {
                Console.Write($"{cell.Text}\t");
                if(cell.AddressString.Contains("H"))
                {
                    Console.WriteLine();
                }
            }
            // Calculate aggregate values
            decimal sum = workSheet["F2:F10"].Sum();
            Console.WriteLine($"Sum of F2:F10: {sum}");
        }
    }
}

Imports Microsoft.VisualBasic
Imports IronXL
Imports System

Namespace WorkingWithIronXL
	Friend Class IronXlDemo
		Public Shared Sub ReadData()
			' Load the Excel worksheet
			Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
			' Select the first worksheet
			Dim workSheet As WorkSheet = workBook.WorkSheets(0)
			' Read a specific cell value
			Dim cellValue As Integer = workSheet("A2").IntValue
			Console.WriteLine($"Value in A2: {cellValue}")
			' Read a range of cells
			For Each cell In workSheet("A1:H10")
				Console.Write($"{cell.Text}" & vbTab)
				If cell.AddressString.Contains("H") Then
					Console.WriteLine()
				End If
			Next cell
			' Calculate aggregate values
			Dim sum As Decimal = workSheet("F2:F10").Sum()
			Console.WriteLine($"Sum of F2:F10: {sum}")
		End Sub
	End Class
End Namespace

Explicación del Código

1. Cargue un archivo de Excel utilizando WorkBook.Load.
2. Accedemos a la primera hoja de trabajo en el libro.
3. Lee el valor de una celda específica y muéstralo utilizando Console.WriteLine.
4. Recorra una serie de celdas e imprima cada valor. Imprimir nuevas líneas después de la columna H.
5. Calcula la suma de los valores del rango F2:F10 e imprímela.

Excel de Entrada

Salida

// Different ways to read cell values
string textValue = workSheet["A1"].StringValue;
int intValue = workSheet["B1"].IntValue;
decimal decimalValue = workSheet["C1"].DecimalValue;
double doubleValue = workSheet["D1"].DoubleValue;
DateTime dateValue = workSheet["E1"].DateTimeValue;
bool boolValue = workSheet["F1"].BoolValue;

// Read formula results
string formulaResult = workSheet["G1"].FormattedCellValue;

// Different ways to read cell values
string textValue = workSheet["A1"].StringValue;
int intValue = workSheet["B1"].IntValue;
decimal decimalValue = workSheet["C1"].DecimalValue;
double doubleValue = workSheet["D1"].DoubleValue;
DateTime dateValue = workSheet["E1"].DateTimeValue;
bool boolValue = workSheet["F1"].BoolValue;

// Read formula results
string formulaResult = workSheet["G1"].FormattedCellValue;

' Different ways to read cell values
Dim textValue As String = workSheet("A1").StringValue
Dim intValue As Integer = workSheet("B1").IntValue
Dim decimalValue As Decimal = workSheet("C1").DecimalValue
Dim doubleValue As Double = workSheet("D1").DoubleValue
Dim dateValue As DateTime = workSheet("E1").DateTimeValue
Dim boolValue As Boolean = workSheet("F1").BoolValue

' Read formula results
Dim formulaResult As String = workSheet("G1").FormattedCellValue

// Check if cell is empty
if (workSheet["A1"].IsEmpty)
{
    Console.WriteLine("Cell A1 is empty");
}

// Use null-coalescing for safe value reading
string value = workSheet["A1"].StringValue ?? "Default Value";

// Check for specific content types
if (workSheet["B1"].IsNumeric)
{
    decimal numValue = workSheet["B1"].DecimalValue;
}

// Check if cell is empty
if (workSheet["A1"].IsEmpty)
{
    Console.WriteLine("Cell A1 is empty");
}

// Use null-coalescing for safe value reading
string value = workSheet["A1"].StringValue ?? "Default Value";

// Check for specific content types
if (workSheet["B1"].IsNumeric)
{
    decimal numValue = workSheet["B1"].DecimalValue;
}

' Check if cell is empty
If workSheet("A1").IsEmpty Then
    Console.WriteLine("Cell A1 is empty")
End If

' Use null-coalescing for safe value reading
Dim value As String = If(workSheet("A1").StringValue, "Default Value")

' Check for specific content types
If workSheet("B1").IsNumeric Then
    Dim numValue As Decimal = workSheet("B1").DecimalValue
End If

// Available aggregate functions
decimal sum = workSheet["A1:A10"].Sum();
decimal avg = workSheet["A1:A10"].Avg();
decimal min = workSheet["A1:A10"].Min();
decimal max = workSheet["A1:A10"].Max();
int count = workSheet["A1:A10"].Count();

// Available aggregate functions
decimal sum = workSheet["A1:A10"].Sum();
decimal avg = workSheet["A1:A10"].Avg();
decimal min = workSheet["A1:A10"].Min();
decimal max = workSheet["A1:A10"].Max();
int count = workSheet["A1:A10"].Count();

' Available aggregate functions
Dim sum As Decimal = workSheet("A1:A10").Sum()
Dim avg As Decimal = workSheet("A1:A10").Avg()
Dim min As Decimal = workSheet("A1:A10").Min()
Dim max As Decimal = workSheet("A1:A10").Max()
Dim count As Integer = workSheet("A1:A10").Count()

¿Cómo convierto un archivo Excel a HTML para su uso en la web?

Veamos cómo convertir Excel a HTML para su uso en la web. Esto resulta especialmente útil para mostrar datos de Excel en aplicaciones web.

using IronXL;
using IronXL.Options;

namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ConvertToHtml()
        {
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.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);
        }
    }
}

using IronXL;
using IronXL.Options;

namespace WorkingWithIronXL
{
    internal class IronXlDemo
    {
        public static void ConvertToHtml()
        {
            WorkBook workBook = WorkBook.Load("sampleEmployeeData.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);
        }
    }
}

Imports IronXL
Imports IronXL.Options

Namespace WorkingWithIronXL
	Friend Class IronXlDemo
		Public Shared Sub ConvertToHtml()
			Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
			Dim options = New HtmlExportOptions() With {
				.OutputRowNumbers = True,
				.OutputColumnHeaders = True,
				.OutputHiddenRows = True,
				.OutputHiddenColumns = True,
				.OutputLeadingSpacesAsNonBreaking = True
			}
			' Export workbook to the HTML file
			workBook.ExportToHtml("workBook.html", options)
		End Sub
	End Class
End Namespace

Explicación del Código

1. Cargue el archivo Excel utilizando el método Load.
2. Configure las opciones para la conversión a HTML utilizando HtmlExportOptions.
3. Utilice el método ExportToHtml para convertir y guardar como HTML.

Entrada

Salida

var htmlOptions = new HtmlExportOptions()
{
    // Table formatting options
    OutputRowNumbers = true,
    OutputColumnHeaders = true,

    // Visibility options  
    OutputHiddenRows = false,
    OutputHiddenColumns = false,

    // Formatting preservation
    OutputLeadingSpacesAsNonBreaking = true,

    // Custom CSS class
    TableCssClass = "excel-table"
};

var htmlOptions = new HtmlExportOptions()
{
    // Table formatting options
    OutputRowNumbers = true,
    OutputColumnHeaders = true,

    // Visibility options  
    OutputHiddenRows = false,
    OutputHiddenColumns = false,

    // Formatting preservation
    OutputLeadingSpacesAsNonBreaking = true,

    // Custom CSS class
    TableCssClass = "excel-table"
};

Dim htmlOptions As New HtmlExportOptions() With {
    .OutputRowNumbers = True,
    .OutputColumnHeaders = True,
    .OutputHiddenRows = False,
    .OutputHiddenColumns = False,
    .OutputLeadingSpacesAsNonBreaking = True,
    .TableCssClass = "excel-table"
}

// Export with inline CSS styles
workBook.ExportToHtml("styled.html", new HtmlExportOptions
{
    OutputRowNumbers = false,
    OutputColumnHeaders = true,
    // Preserves cell styles as inline CSS
    PreserveStyles = true
});

// Export with inline CSS styles
workBook.ExportToHtml("styled.html", new HtmlExportOptions
{
    OutputRowNumbers = false,
    OutputColumnHeaders = true,
    // Preserves cell styles as inline CSS
    PreserveStyles = true
});

' Export with inline CSS styles
workBook.ExportToHtml("styled.html", New HtmlExportOptions With {
    .OutputRowNumbers = False,
    .OutputColumnHeaders = True,
    ' Preserves cell styles as inline CSS
    .PreserveStyles = True
})

// Export specific worksheet
WorkSheet sheet = workBook.GetWorkSheet("Sheet1");
sheet.SaveAsHtml("sheet1.html");

// Export multiple specific sheets
foreach (var sheetName in new[] { "Sheet1", "Sheet3" })
{
    workBook.GetWorkSheet(sheetName).SaveAsHtml($"{sheetName}.html");
}

// Export specific worksheet
WorkSheet sheet = workBook.GetWorkSheet("Sheet1");
sheet.SaveAsHtml("sheet1.html");

// Export multiple specific sheets
foreach (var sheetName in new[] { "Sheet1", "Sheet3" })
{
    workBook.GetWorkSheet(sheetName).SaveAsHtml($"{sheetName}.html");
}

' Export specific worksheet
Dim sheet As WorkSheet = workBook.GetWorkSheet("Sheet1")
sheet.SaveAsHtml("sheet1.html")

' Export multiple specific sheets
For Each sheetName As String In {"Sheet1", "Sheet3"}
    workBook.GetWorkSheet(sheetName).SaveAsHtml($"{sheetName}.html")
Next

¿Cuáles son los casos de uso reales de IronXL?

IronXL es una biblioteca .NET versátil con una amplia gama de aplicaciones del mundo real, incluyendo:

1. Informes de Negocios:

• Automatización de informes periódicos, como resúmenes de ventas y estados financieros.
• Creación de paneles personalizados a partir de diversas fuentes de datos.
• Exportar datos a Excel para presentaciones a las partes interesadas.

2. Análisis de Datos:

• Procesamiento de grandes conjuntos de datos para su análisis estadístico y transformación.
• Exportación de datos analizados para su examen por parte de las partes interesadas.
• Uso de funciones de agregación para obtener información rápida.

3. Gestión de Inventario:

• Gestión de inventarios de productos con niveles de stock y datos de proveedores.
• Generar informes de inventario para realizar un seguimiento de las tendencias.
• Importación de datos CSV de proveedores.

4. Gestión de Relaciones con Clientes (CRM):

• Exportación de datos de clientes para un análisis detallado.
• Actualización de registros de CRM mediante la importación de datos modificados.
• Creación de informes de segmentación mediante el formato condicional.

5. Instituciones Educativas:

• Creación de libros de notas y registros de asistencia de los alumnos.
• Generación de resultados de exámenes y análisis de rendimiento.
• Uso de fórmulas para calcular las calificaciones automáticamente.

6. Servicios Financieros:

• Automatización de modelos financieros, presupuestos y previsiones.
• Consolidación de datos financieros para la elaboración de informes exhaustivos.
• Creación de gráficos para el análisis visual.

7. Recursos Humanos:

• Gestión de datos de empleados, incluyendo nóminas y evaluaciones.
• Generación de informes sobre métricas de RR. HH. y datos demográficos.
• Protección de datos confidenciales mediante cifrado con contraseña.

8. Gestión de Proyectos:

• Seguimiento de los plazos de los proyectos y la asignación de recursos.
• Creación de diagramas de Gantt y herramientas de gestión de proyectos.
• Uso de rangos con nombre para la gestión de fórmulas.

9. Comercio electrónico:

• Exportar detalles de pedidos, información de clientes y datos de ventas desde plataformas de comercio electrónico a Excel.
• Análisis de tendencias de ventas, comportamiento del cliente y rendimiento de productos.

10. Atención Sanitaria:

• Gestión de historiales de pacientes y agendas de citas.
• Analizar datos sanitarios para mejorar la atención al paciente.
• Protección de los datos de los pacientes mediante la protección de hojas de cálculo.

¿Cómo obtengo la licencia de IronXL para uso en producción?

IronXL es una biblioteca Enterprise de Iron Software. Se requiere una licencia para ejecutarlo. Puede descargar una Licencia Trial utilizando su dirección de correo electrónico desde aquí. Una vez enviada, la licencia se envía a tu correo electrónico. Coloca esta licencia al principio de tu código, antes de utilizar IronXL:

License.LicenseKey = "your Key Here";

License.LicenseKey = "your Key Here";

License.LicenseKey = "your Key Here"

// Method 1: In code
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY";

// Method 2: Using app.config or web.config
// Add to configuration file:
// <appSettings>
//   <add key="IronXL.LicenseKey" value="YOUR-LICENSE-KEY"/>
// </appSettings>

// Method 3: Using environment variable
Environment.SetEnvironmentVariable("IRONXL_LICENSE_KEY", "YOUR-LICENSE-KEY");

// Method 1: In code
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY";

// Method 2: Using app.config or web.config
// Add to configuration file:
// <appSettings>
//   <add key="IronXL.LicenseKey" value="YOUR-LICENSE-KEY"/>
// </appSettings>

// Method 3: Using environment variable
Environment.SetEnvironmentVariable("IRONXL_LICENSE_KEY", "YOUR-LICENSE-KEY");

' Method 1: In code
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY"

' Method 2: Using app.config or web.config
' Add to configuration file:
' <appSettings>
'   <add key="IronXL.LicenseKey" value="YOUR-LICENSE-KEY"/>
' </appSettings>

' Method 3: Using environment variable
Environment.SetEnvironmentVariable("IRONXL_LICENSE_KEY", "YOUR-LICENSE-KEY")

¿Qué hemos aprendido sobre el trabajo con archivos de Excel en C#?

IronXL es una potente biblioteca IronXL for .NET para crear, leer y editar archivos de Excel, que ofrece una API intuitiva que simplifica el trabajo con documentos de Excel. Es compatible con múltiples formatos, incluidos XLS, XLSX y CSV, lo que la hace versátil para diversos casos de uso. IronXL permite una manipulación fácil de valores de celda, fórmulas y formatos, y está optimizado para el rendimiento, manejando eficientemente archivos grandes y operaciones complejas. Su gestión de la memoria garantiza aplicaciones con buena capacidad de respuesta, y su compatibilidad multiplataforma la hace muy valiosa para los desarrolladores que trabajan en diferentes sistemas operativos.

Tanto si estás creando aplicaciones web, software de escritorio o servicios en la nube, IronXL te ofrece las herramientas necesarias para trabajar de forma eficaz con archivos de Excel en C#. Para conocer las funciones más avanzadas, consulta la documentación completa y explora los numerosos ejemplos de código.

Conclusiones clave:

• No requiere instalación de Microsoft Office
• Compatibilidad multiplataforma con Windows, Linux y macOS
• Opciones completas de estilo y formato
• Compatibilidad con fórmulas y cálculos
• Funciones de seguridad, incluida la protección con contraseña
• Fácil exportación e importación de datos
• Excelentes optimizaciones de rendimiento

Mantente al día de las últimas funciones y mejoras consultando el registro de cambios y los hitos de las mejoras continuas de IronXL.