IronXL é uma poderosa biblioteca C# que permite aos desenvolvedores ler, escrever e manipular arquivos do Excel sem exigir instalação do Microsoft Excel, oferecendo compatibilidade entre plataformas e suportando formatos como XLS, XLSX, CSV com uma API intuitiva.
IronXL é uma biblioteca robusta para .NET que simplifica o trabalho com arquivos Excel. Ela possui uma API intuitiva que simplifica a manipulação de documentos Excel, suportando vários formatos como XLS, XLSX, e CSV. Essa versatilidade permite manipulação fácil de valores de células, fórmulas e formatação. IronXL é otimizado para desempenho, capaz de lidar eficientemente com arquivos grandes e operações complexas, garantindo o uso eficiente da memória. Sua compatibilidade entre plataformas melhora sua utilidade em diferentes sistemas operacionais. Aqui estão suas principais características e benefícios:
Importação e Exportação:
Manipulação de Dados:
DataSet e DataTable objetos.Estilização e Formatação:
WorkSheet["A1:B10"].Segurança:
Compatibilidade Cross Platform:
Para usar o IronXL em seus projetos .NET, você precisa garantir que seu ambiente de desenvolvimento atenda aos seguintes pré-requisitos:
Você pode instalar o IronXL via NuGet Package Manager no Visual Studio ou usando o Package Manager Console com o seguinte comando:
Para instruções detalhadas de instalação, incluindo configuração para Blazor, .NET MAUI, ou projetos VB.NET, consulte a documentação oficial.
Vamos desenvolver um projeto no Visual Studio e adicionar a biblioteca IronXL para começar a trabalhar em um arquivo Excel.
Abra o Microsoft Visual Studio e selecione 'Criar um novo projeto' para começar.
Selecione o modelo de projeto de sua escolha. Aqui, selecionamos Aplicativo de Console por simplicidade.
Agora, insira o nome e a localização do projeto.
Selecione a versão do .NET Framework que você preferir. Selecionamos a mais recente disponível em nossa máquina.
Uma vez que você clicar no botão Criar, o projeto será criado e estará pronto para uso. Abra o Solution Explorer para verificar os arquivos do projeto.
Agora, vamos instalar a biblioteca IronXL do gerenciador de pacotes NuGet como mostrado acima.
Agora vamos criar um arquivo Excel sem usar a biblioteca Microsoft Interop. IronXL fornece uma maneira simples e intuitiva de criar planilhas programaticamente.
using IronXL;
namespace WorkingWith IronXL
{
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 NamespaceImports 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 NamespaceExplicação do código
WorkBook.Create() para criar um arquivo XLSX.CreateWorkSheet para criar uma planilha dentro do livro de trabalho.workSheet["A1"].Value.workBook.SaveAs fornecendo um nome de arquivo.Arquivo Excel de Saída
Ao contrário das abordagens tradicionais que dependem do Microsoft Excel Interop, o IronXL é uma biblioteca .NET independente que lê e escreve arquivos Excel diretamente. Isso significa:
O IronXL suporta salvar em vários formatos:
// 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' 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 formatO IronXL oferece um tratamento de erros abrangente. Aqui está um exemplo de prática recomendada:
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}");
}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 TryTry
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 TryAgora vamos ver como adicionar estilos a células do Excel. O IronXL oferece opções de estilo abrangentes para criar planilhas de aparência profissional.
using IronXL;
namespace WorkingWith IronXL
{
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 WorkingWith IronXL
{
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 NamespaceImports 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 NamespaceExplicação do código
WorkBook.Create.workBook.CreateWorkSheet.workSheet["A1"].Value.workSheet["A1"].Style.Font.Bold.workBook.SaveAs.Arquivo Excel de Saída
O IronXL oferece opções de estilo extensivas, incluindo:
Você pode aplicar estilos a intervalos de células de forma eficiente:
// 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' 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
NextSim, o IronXL suporta formatação condicional:
// 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)' 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)Agora vamos ver como ler arquivos Excel usando o IronXL e realizar cálculos. O IronXL suporta várias funções matemáticas para análise de dados.
using IronXL;
using System;
namespace WorkingWith IronXL
{
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 WorkingWith IronXL
{
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 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
' Calculate aggregate values
Dim sum As Decimal = workSheet("F2:F10").Sum()
Console.WriteLine($"Sum of F2:F10: {sum}")
End Sub
End Class
End NamespaceImports 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
' Calculate aggregate values
Dim sum As Decimal = workSheet("F2:F10").Sum()
Console.WriteLine($"Sum of F2:F10: {sum}")
End Sub
End Class
End NamespaceExplicação do código
WorkBook.Load.Console.WriteLine.Excel de Entrada
Saída
IronXL suporta a leitura de vários tipos de dados das células:
// 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' 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").FormattedCellValueIronXL oferece maneiras seguras de lidar com células vazias:
// 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' 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 IfIronXL suporta várias funções agregadas:
// 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()' 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()Vamos ver como converter Excel para HTML para uso na web. Isso é particularmente útil para exibir dados do Excel em aplicações web.
using IronXL;
using IronXL.Options;
namespace WorkingWith IronXL
{
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 WorkingWith IronXL
{
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 WorkingWith IronXL
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 NamespaceImports IronXL
Imports IronXL.Options
Namespace WorkingWith IronXL
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 NamespaceExplicação do código
Load.HtmlExportOptions.ExportToHtml para converter e salvar como HTML.Entrada
Saída
IronXL oferece várias opções de exportação para HTML:
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 = New HtmlExportOptions() With {
.OutputRowNumbers = True,
.OutputColumnHeaders = True,
.OutputHiddenRows = False,
.OutputHiddenColumns = False,
.OutputLeadingSpacesAsNonBreaking = True,
.TableCssClass = "excel-table"
}Dim htmlOptions = New HtmlExportOptions() With {
.OutputRowNumbers = True,
.OutputColumnHeaders = True,
.OutputHiddenRows = False,
.OutputHiddenColumns = False,
.OutputLeadingSpacesAsNonBreaking = True,
.TableCssClass = "excel-table"
}IronXL preserva automaticamente a formatação básica ao exportar para HTML. Para preservação de formatação avançada:
// 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 with inline CSS styles
workBook.ExportToHtml("styled.html", New HtmlExportOptions With {
.OutputRowNumbers = False,
.OutputColumnHeaders = True,
' Preserves cell styles as inline CSS
.PreserveStyles = True
})Sim, você pode exportar planilhas individuais:
// 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' 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")
NextIronXL é uma biblioteca .NET versátil com uma ampla gama de aplicações no mundo real, incluindo:
1. Relatórios Empresariais:
2. Análise de Dados:
3. Gestão de Inventário:
4. Gestão de Relacionamento com o Cliente (CRM):
5. Instituições Educacionais:
6. Serviços Financeiros:
7. Recursos Humanos:
8. Gerenciamento de Projetos:
9. Comércio eletrônico:
10. Saúde:
Indústrias que lidam com grandes quantidades de dados estruturados se beneficiam mais:
IronXL é otimizado para desempenho com:
Cenários comuns de integração incluem:
IronXL é uma biblioteca empresarial da Iron Software. Requer uma licença para execução. Você pode baixar uma licença de teste usando seu ID de email aqui. Ao enviar, a licença é entregue ao seu email. Coloque essa licença no início do seu código, antes de usar o IronXL:
License.LicenseKey = "your Key Here";License.LicenseKey = "your Key Here";License.LicenseKey = "your Key Here"License.LicenseKey = "your Key Here"IronXL oferece vários tipos de licença:
Você pode aplicar a chave de licença de várias maneiras:
// 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")' 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")Para aplicações web, você também pode configurar a licença no Web.config.
Quando o teste expira:
Para continuar usando o IronXL, compre uma licença comercial. A equipe oferece extensões de licença e atualizações para clientes existentes.
O IronXL é uma poderosa biblioteca .NET para criar, ler e editar arquivos Excel, oferecendo uma API intuitiva que simplifica o trabalho com documentos Excel. Ele suporta múltiplos formatos, incluindo XLS, XLSX e CSV, tornando-o versátil para vários casos de uso. O IronXL permite fácil manipulação de valores de células, fórmulas e formatação, otimizado para desempenho, manuseando eficientemente grandes arquivos e operações complexas. Sua gestão de memória garante aplicativos responsivos, e sua compatibilidade multiplataforma o torna valioso para desenvolvedores em diferentes sistemas operacionais.
Quer você esteja criando aplicações web, software de desktop, ou serviços na nuvem, o IronXL fornece as ferramentas necessárias para trabalhar efetivamente com arquivos Excel em C#. Para recursos mais avançados, consulte a documentação completa e explore os amplos exemplos de código.
Principais conclusões:
Mantenha-se atualizado com os últimos recursos e melhorias conferindo o changelog e os marcos para os contínuos aprimoramentos do IronXL.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronXL faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
A API do Excel que você precisa, sem as complicações do Office Interop.
