Como trabalhar com arquivos do Excel em C#: Figura 1 - Tutorial

Como eu trabalho com Airbus em C#?

1. Crie um projeto no Visual Studio e adicione o pacote NuGet do IronXL.
2. Crie um arquivo Excel sem Interop.
3. Adicione estilo ao arquivo Excel usando o IronXL.
4. Leia valores do Excel e calcule.
5. Converta o Excel em HTML para uso na web.

O que é a Biblioteca IronXL?

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:

Quais São os Recursos Principais do IronXL?

1. Importação e Exportação:

   • Importar Dados: Suporta formatos XLS, XLSX, CSV e TSV.
   • Exportar Dados: Pode exportar planilhas para XLS, XLSX, CSV, TSV e JSON.

2. Manipulação de Dados:

   • Integração com System.Data: Trabalhe com planilhas como DataSet e DataTable objetos.
   • Fórmulas: Suporta fórmulas do Excel que são recalculadas quando as planilhas são editadas.

3. Estilização e Formatação:

   • Estilização de Célula: Personalize fonte, tamanho, padrão de fundo, borda, alinhamento, e formatos numéricos.
   • Intervalos: Configuração de intervalos intuitiva com a sintaxe WorkSheet["A1:B10"].

4. Segurança:

   • Criptografia: Criptografar e descriptografar arquivos XLSX, XLSM e XLTX com senhas.
5. Compatibilidade Cross Platform:
   • Funciona com .NET Framework, .NET Core, .NET Standard e Azure.
   • Compatível com Windows, macOS, Linux, Docker e AWS.

Por Que Devo Escolher IronXL Em Vez de Outras Bibliotecas de Excel?

1. Não Precisa do Microsoft Office: IronXL não requer que o Microsoft Office seja instalado, tornando-o leve e fácil de implantar.
2. Facilidade de Uso: A API é intuitiva e fácil de usar, permitindo que os desenvolvedores integrem rapidamente funcionalidades do Excel em suas aplicações.
3. Desempenho: IronXL é otimizado para desempenho, garantindo processamento rápido e eficiente de arquivos Excel grandes.
4. Versatilidade: Adequado para uma ampla gama de aplicações, incluindo soluções web, desktop e baseadas em nuvem.
5. Documentação Abrangente: Documentação extensa e exemplos estão disponíveis, facilitando para os desenvolvedores começarem e encontrarem soluções para problemas comuns.

Como Começo com o IronXL?

Para usar o IronXL em seus projetos .NET, você precisa garantir que seu ambiente de desenvolvimento atenda aos seguintes pré-requisitos:

dotnet add package IronXL.Excel --version 2024.8.5

Como Crio Meu Primeiro Arquivo Excel com IronXL?

Vamos desenvolver um projeto no Visual Studio e adicionar a biblioteca IronXL para começar a trabalhar em um arquivo Excel.

Como Crio um Projeto Visual Studio e Adiciono o IronXL?

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.

Como Crio um Arquivo Excel Sem Interop?

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

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 Namespace

Explicação do código

1. Adicionamos o namespace do IronXL para começar a trabalhar com a biblioteca.
2. Crie um objeto Excel com WorkBook.Create() para criar um arquivo XLSX.
3. Chame o método CreateWorkSheet para criar uma planilha dentro do livro de trabalho.
4. Adicione valores às células usando workSheet["A1"].Value.
5. Salve o arquivo Excel usando workBook.SaveAs fornecendo um nome de arquivo.

Arquivo Excel de Saída

// 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

Como adiciono estilos aos arquivos Excel usando o IronXL?

Agora 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 Namespace

Explicação do código

1. Crie um arquivo Excel usando WorkBook.Create.
2. Crie uma planilha usando workBook.CreateWorkSheet.
3. Adicione valores às células usando workSheet["A1"].Value.
4. Adicione estilos às células usando propriedades como workSheet["A1"].Style.Font.Bold.
5. Salve o livro de trabalho usando workBook.SaveAs.

Arquivo Excel de Saída

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

Como leio valores do Excel e calculo?

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 Namespace

Explicação do código

1. Load an Excel file using WorkBook.Load.
2. Acesse a primeira planilha do livro.
3. Leia o valor de uma célula específica e exiba-o usando Console.WriteLine.
4. Percorra um intervalo de células e imprima cada valor. Imprima novas linhas após a coluna H.
5. Calcule a soma dos valores no intervalo F2:F10 e imprima-a.

Excel de Entrada

Saída

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

Como Converto Excel para HTML para Uso na Web?

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 WorkingWithIronXL
    Friend Class IronXlDemo
        Public Shared Sub ConvertToHtml()
            Dim workBook As WorkBook = WorkBook.Load("sampleEmployeeData.xlsx")
            Dim options As 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

Explicação do código

1. Carregue o arquivo Excel usando o método Load.
2. Defina opções para conversão HTML usando HtmlExportOptions.
3. Use o método ExportToHtml para converter e salvar como HTML.

Entrada

Saída

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

Quais São os Casos de Uso no Mundo Real para o IronXL?

IronXL é uma biblioteca .NET versátil com uma ampla gama de aplicações no mundo real, incluindo:

1. Relatórios Empresariais:

• Automatização de relatórios periódicos como resumos de vendas e demonstrações financeiras.
• Criação de painéis personalizados a partir de várias fontes de dados.
• Exportação de dados para Excel para apresentações a stakeholders.

2. Análise de Dados:

• Processamento de grandes conjuntos de dados para análise estatística e transformação.
• Exportação de dados analisados para exame dos stakeholders.
• Uso de funções agregadas para insights rápidos.

3. Gestão de Inventário:

• Gestão de inventários de produtos com níveis de estoque e detalhes dos fornecedores.
• Geração de relatórios de inventário para acompanhar tendências.
• Importação de dados CSV de fornecedores.

4. Gestão de Relacionamento com o Cliente (CRM):

• Exportação de dados de clientes para análise detalhada.
• Atualização de registros de CRM importando dados modificados.
• Criação de relatórios de segmentação usando formatação condicional.

5. Instituições Educacionais:

• Criação de livros de notas de alunos e registros de presença.
• Geração de resultados de exames e análise de desempenho.
• Uso de fórmulas para calcular notas automaticamente.

6. Serviços Financeiros:

• Automação de modelos financeiros, orçamentos e previsões.
• Consolidação de dados financeiros para relatórios abrangentes.
• Criação de gráficos para análise visual.

7. Recursos Humanos:

• Gerenciamento de dados de funcionários, incluindo folha de pagamento e avaliações.
• Gerando relatórios sobre métricas de RH e demografia.
• Protegendo dados sensíveis com criptografia de senha.

8. Gerenciamento de Projetos:

• Acompanhamento de cronogramas de projetos e alocação de recursos.
• Criando gráficos de Gantt e ferramentas de gerenciamento de projetos.
• Usando intervalos nomeados para gerenciamento de fórmulas.

9. Comércio eletrônico:

• Exportando detalhes de pedidos, informações de clientes e dados de vendas de plataformas de e-commerce para o Excel.
• Analisando tendências de vendas, comportamento do cliente e desempenho do produto.

10. Saúde:

• Gerenciamento de registros de pacientes e agendamentos.
• Analisando dados de saúde para melhorar o atendimento ao paciente.
• Protegendo dados de pacientes com proteção de planilha.

Como Licenciar o IronXL para Uso em Produção?

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"

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

O que Aprendemos sobre Trabalhar com Arquivos Excel em C#?

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:

• Não é necessária a instalação do Microsoft Office
• Suporte multiplataforma para Windows, Linux, macOS
• Compreensivas opções de estilo e formatação
• Suporte para fórmulas e cálculos
• Recursos de segurança incluindo proteção por senha
• Fácil exportação e importação de dados
• Excelentes otimizações de desempenho

Mantenha-se atualizado com os últimos recursos e melhorias conferindo o changelog e os marcos para os contínuos aprimoramentos do IronXL.