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");
}
}
}Explicaçã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 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
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");
}
}
}Explicaçã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
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
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}");
}
}
}Explicaçã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
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 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
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);
}
}
}Explicaçã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"
};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 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
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"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")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.
