Comparação entre IronXL e Epplus

O que é o software EPPlus?

EPPlus é uma biblioteca for .NET Framework/.NET Core baseada no NuGet para manipular planilhas Office Open XML. A versão 5 inclui suporte for .NET Framework 3.5 e .NET Core 2.0.EPPlusnão depende de outras bibliotecas, como o Microsoft Excel.

EPPlus possui uma API que permite trabalhar com documentos do Office Excel.EPPlusé uma biblioteca .NET que lê e escreve arquivos Excel formatados em Office OpenXML. Esta biblioteca está disponível como um pacote no NuGet.

A biblioteca foi criada com programadores em mente. O objetivo sempre foi permitir que um desenvolvedor familiar com Excel ou outra biblioteca de planilhas possa aprender rapidamente a API. Alternativamente, como alguém disse, "IntelliSense seu caminho para a vitória!"

Instalação do EPPlus

Para instalar oEPPlusa partir do Visual Studio, vá para Exibir > Outras Janelas > Console do Gerenciador de Pacotes e digite o seguinte comando:

Install-Package EPPlus

Se preferir utilizar a CLI do .NET, execute o seguinte comando a partir de um prompt de comando elevado ou prompt do PowerShell:

dotnet add package EPPlus

EPPlus é um pacote dotnet que você pode adicionar ao seu projeto.

O que é IronXL?

IronXL é uma API para C# e VB Excel que permite ler, editar e criar planilhas do Excel em .NET sem a necessidade de instalar o Microsoft Office ou depender da interoperabilidade do Excel. A biblioteca lida nativamente com arquivos XLS, XLSX, CSV e outros formatos de planilha.

.NET Core, .NET Framework, Xamarin, Mobile, Linux, macOS e Azure são todos suportados pelo IronXL.

Existem várias maneiras diferentes de ler e escrever dados para e a partir de sua planilha.

AdicionandoIronXLusando o Pacote NuGet

Podemos adicionar o pacoteIronXLà sua conta de uma das três maneiras, para que você possa escolher a que funciona melhor para você.

• Usando o Console do Gerenciador de Pacotes para instalar o IronXL

Use o seguinte comando para abrir o Console do Gerenciador de Pacotes no seu Projeto:

Para acessar o Console do Gerenciador de Pacotes, vá para Ferramentas => Gerenciador de Pacotes NuGet => Console do Gerenciador de Pacotes.

Isso o levará ao Console do Gerenciador de Pacotes. Em seguida, no terminal do Gerenciador de Pacotes, digite o seguinte comando:

Install-Package IronXl.Excel

• Usando o Gerenciador de Pacotes NuGet para instalar o IronXL

Esta é uma abordagem diferente para obter o Gerenciador de Pacotes NuGet instalado. Você não precisará utilizar esta abordagem se já tiver concluído a instalação usando o método anterior.

Para acessar o Gerenciador de Pacotes NuGet, vá para Ferramentas > Gerenciador de Pacotes NuGet => Selecione Gerenciar Pacotes NuGet para Solução no menu suspenso.

Isso lançará a Solução NuGet; selecionar "Procurar" e procurar por IronXL.

Na barra de pesquisa, digite Excel:

OIronXLserá instalado para você quando clicar no botão "Instalar". Após instalar o IronXL, você pode ir ao seu formulário e começar a desenvolvê-lo.

Antes de mergulharmos nos exemplos de código, aqui está uma visão geral lado a lado de como oEPPluse oIronXLse comparam nas principais áreas discutidas neste artigo:

Recurso	EPPlus	IronXL
Ler arquivos XLSX	Sim	Sim
Criar arquivos XLSX	Sim	Sim
Suporte ao formato XLS	Não	Sim
Exportar para CSV, JSON, XML	Somente CSV	CSV, JSON, XML
Exportação de banco de dados (Entity Framework)	Não incluído	Sim
Auxiliares de validação de dados	Não incluído	Sim
operações com várias planilhas	Foco em uma única folha de exercícios	Folha de exercícios múltipla e livro de exercícios múltiplo
Licenciamento	Comercial ou Polyform Não Comercial	Comercial (perpétuo)

Para testar as operações doIronXLno Excel em comparação com oEPPlusno seu próprio projeto, está disponível uma avaliação gratuita de 30 dias .

Criando um arquivo Excel com IronXL

Criar uma nova planilha do Excel com oIronXLrequer apenas uma linha de código:

// Create a new Excel workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

// Create a new Excel workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

' Create a new Excel workbook in XLSX format
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

OIronXLpode criar arquivos nos formatos XLS (versão anterior do Excel) e XLSX (versão atual e mais recente do Excel), aproveitando toda a sua gama de recursos do Excel .

• Definir uma planilha padrão

É ainda mais fácil configurar uma planilha padrão:

// Create a worksheet named "2020 Budget" in the workbook
var sheet = workbook.CreateWorkSheet("2020 Budget");

// Create a worksheet named "2020 Budget" in the workbook
var sheet = workbook.CreateWorkSheet("2020 Budget");

' Create a worksheet named "2020 Budget" in the workbook
Dim sheet = workbook.CreateWorkSheet("2020 Budget")

A planilha é representada por sheet no trecho de código acima, e você pode usá-la para definir valores e estilos de células e fazer praticamente tudo o que o Excel pode fazer. Você também pode codificar seu documento Excel em um arquivo somente leitura e realizar operações de exclusão. Você também pode vincular suas planilhas, assim como o Excel faz.

Deixe-me esclarecer a diferença entre um livro de trabalho e uma planilha caso você não tenha certeza.

As planilhas estão contidas em um livro de trabalho. Isso significa que você pode colocar quantas planilhas quiser dentro de um livro de trabalho. Explicarei como fazer isso em um artigo posterior. Linhas e colunas compõem uma planilha. A interseção de uma linha e uma coluna é conhecida como célula, e é nela que você irá interagir dentro do Excel.

Criando um arquivo Excel comEPPlusSoftware AB

OEPPluspode ser usado para criar arquivos Excel e realizar operações como criar tabelas dinâmicas, áreas dinâmicas e até mesmo formatação condicional e alteração de fontes. Sem mais delongas, aqui está o código-fonte completo para converter um arquivo normal DataTable em um arquivo Excel XLSX e enviá-lo ao usuário para download:

public ActionResult ConvertToXLSX()
{
    byte[] fileData = null;

    // Replace the GetDataTable() method with your DBMS-fetching code.
    using (DataTable dt = GetDataTable())
    {
        // Create an empty spreadsheet
        using (var p = new ExcelPackage())
        {
            // Add a worksheet to the spreadsheet
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            // Initialize rows and columns counter: note that they are 1-based!
            var row = 1;
            var col = 1;

            // Create the column names on the first line.
            // In this sample, we'll just use the DataTable column names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows into the XLS file
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r[dc].ToString());
                }

                // Alternate light-gray color for uneven rows (3, 5, 7, 9)...
                if (row % 2 != 0)
                {
                    ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                }
            }

            // Output the XLSX file
            using (var ms = new MemoryStream())
            {
                p.SaveAs(ms);
                ms.Seek(0, SeekOrigin.Begin);
                fileData = ms.ToArray();
            }
        }
    }

    string fileName = "ConvertedFile.xlsx";
    string contentType = System.Web.MimeMapping.GetMimeMapping(fileName);
    Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
    return File(fileData, contentType);
}

public ActionResult ConvertToXLSX()
{
    byte[] fileData = null;

    // Replace the GetDataTable() method with your DBMS-fetching code.
    using (DataTable dt = GetDataTable())
    {
        // Create an empty spreadsheet
        using (var p = new ExcelPackage())
        {
            // Add a worksheet to the spreadsheet
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            // Initialize rows and columns counter: note that they are 1-based!
            var row = 1;
            var col = 1;

            // Create the column names on the first line.
            // In this sample, we'll just use the DataTable column names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows into the XLS file
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r[dc].ToString());
                }

                // Alternate light-gray color for uneven rows (3, 5, 7, 9)...
                if (row % 2 != 0)
                {
                    ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                }
            }

            // Output the XLSX file
            using (var ms = new MemoryStream())
            {
                p.SaveAs(ms);
                ms.Seek(0, SeekOrigin.Begin);
                fileData = ms.ToArray();
            }
        }
    }

    string fileName = "ConvertedFile.xlsx";
    string contentType = System.Web.MimeMapping.GetMimeMapping(fileName);
    Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
    return File(fileData, contentType);
}

Public Function ConvertToXLSX() As ActionResult
	Dim fileData() As Byte = Nothing

	' Replace the GetDataTable() method with your DBMS-fetching code.
	Using dt As DataTable = GetDataTable()
		' Create an empty spreadsheet
		Using p = New ExcelPackage()
			' Add a worksheet to the spreadsheet
			Dim ws As ExcelWorksheet = p.Workbook.Worksheets.Add(dt.TableName)

			' Initialize rows and columns counter: note that they are 1-based!
			Dim row = 1
			Dim col = 1

			' Create the column names on the first line.
			' In this sample, we'll just use the DataTable column names
			row = 1
			col = 0
			For Each dc As DataColumn In dt.Columns
				col += 1
				ws.SetValue(row, col, dc.ColumnName)
			Next dc

			' Insert the DataTable rows into the XLS file
			For Each r As DataRow In dt.Rows
				row += 1
				col = 0
				For Each dc As DataColumn In dt.Columns
					col += 1
					ws.SetValue(row, col, r(dc).ToString())
				Next dc

				' Alternate light-gray color for uneven rows (3, 5, 7, 9)...
				If row Mod 2 <> 0 Then
					ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid
					ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray)
				End If
			Next r

			' Output the XLSX file
			Using ms = New MemoryStream()
				p.SaveAs(ms)
				ms.Seek(0, SeekOrigin.Begin)
				fileData = ms.ToArray()
			End Using
		End Using
	End Using

	Dim fileName As String = "ConvertedFile.xlsx"
	Dim contentType As String = System.Web.MimeMapping.GetMimeMapping(fileName)
	Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName))
	Return File(fileData, contentType)
End Function

Como você pode ver, este é um método ActionResult que pode ser usado em qualquer controlador ASP.NET MVC; se você não estiver usando ASP.NET MVC, basta copiar o conteúdo do método e colá-lo onde precisar (por exemplo, ASP.NET clássico, Aplicativo de Console, Windows Forms, etc.).

O código é autoexplicativo, com comentários suficientes para ajudá-lo a entender os vários processos de processamento. Mas primeiro, um resumo rápido do que estamos fazendo aqui:

• Usando um método de provedor de dados personalizado, obtemos um objeto DataTable.
• Criamos um objeto ExcelPackage, que é o contêiner principal doEPPluspara o arquivo XLSX.
• Adicionamos um ExcelWorksheet ao ExcelPackage, que será a planilha onde os dados serão inseridos.
• Para criar nossa linha de cabeçalho, iteramos as colunas DataTable, adicionando-as à primeira linha de nossa planilha.
• Iteramos pelas linhas DataTable, adicionando cada uma à nossa planilha linha por linha (começando pela linha 2) de forma que cada linha DataTable corresponda a uma linha da planilha.
• Construímos um MemoryStream para armazenar os dados binários ExcelPackage quando a conversão de DataTable para ExcelPackage estiver concluída e, em seguida, os convertemos em uma matriz de bytes.
• Criamos a resposta HTML e enviamos o arquivo XLSX ao usuário com um anexo de Content-Disposition, fazendo com que o navegador baixe o arquivo automaticamente.

A abordagem doIronXLpara a criação de planilhas requer uma única linha de código, em comparação com a configuração de várias etapas do EPPlus, que envolve ExcelPackage, ExcelWorksheet e iteração manual de células. Para equipes que priorizam a prototipagem rápida e a depuração simplificada, essa diferença na quantidade de código repetitivo pode se acumular ao longo do ciclo de vida de um projeto.

Como oEPPlusSoftware AB grava Arquivos Excel

EPPlus suporta o trabalho com arquivos Excel. É uma biblioteca .net que lê e escreve arquivos Excel.

• Lendo Arquivos Excel

Para fazer isso, você precisa primeiro instalar o pacote EPPlus: vá para 'Ferramentas'-> 'Gerenciador de Pacotes NuGet'-> 'Gerenciar NuGet para esta solução' -> 'Instalar EPPlus' -> 'Instalar EPPlus' -> 'Instalar EPPlus' -> 'Instalar EPPlus' -> 'Instalar EPPlus' -> Instalar EP. Procure por 'EPPlus' na guia 'Procurar', depois instale o pacote NuGet.

Você pode usar o código abaixo em seu aplicativo de console 'Program.cs' uma vez que você tenha instalado o pacote.

using OfficeOpenXml;
using System;
using System.IO;

namespace ReadExcelInCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Provide file path
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            // Use EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                // Get the first worksheet in the workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets[1];
                int colCount = worksheet.Dimension.End.Column;  // Get Column Count
                int rowCount = worksheet.Dimension.End.Row;     // Get row count
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        // Print data, based on row and columns position
                        Console.WriteLine("Row:" + row + " Column:" + col + " Value:" + worksheet.Cells[row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}

using OfficeOpenXml;
using System;
using System.IO;

namespace ReadExcelInCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Provide file path
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            // Use EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                // Get the first worksheet in the workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets[1];
                int colCount = worksheet.Dimension.End.Column;  // Get Column Count
                int rowCount = worksheet.Dimension.End.Row;     // Get row count
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        // Print data, based on row and columns position
                        Console.WriteLine("Row:" + row + " Column:" + col + " Value:" + worksheet.Cells[row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}

Imports OfficeOpenXml
Imports System
Imports System.IO

Namespace ReadExcelInCsharp
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			' Provide file path
			Dim existingFile As New FileInfo("D:\sample_XLSX.xlsx")
			' Use EPPlus
			Using package As New ExcelPackage(existingFile)
				' Get the first worksheet in the workbook
				Dim worksheet As ExcelWorksheet = package.Workbook.Worksheets(1)
				Dim colCount As Integer = worksheet.Dimension.End.Column ' Get Column Count
				Dim rowCount As Integer = worksheet.Dimension.End.Row ' Get row count
				For row As Integer = 1 To rowCount
					For col As Integer = 1 To colCount
						' Print data, based on row and columns position
						Console.WriteLine("Row:" & row & " Column:" & col & " Value:" & worksheet.Cells(row, col).Value?.ToString().Trim())
					Next col
				Next row
			End Using
		End Sub
	End Class
End Namespace

Aqui está um exemplo de saída de um aplicativo de console com um arquivo Excel de exemplo (.xlsx) com o qual estamos trabalhando. Aqui está um arquivo xlsx para leitura em C# usando o EPPlus.

As seguintes formas de carregar dados de várias fontes podem ser acessadas usando a propriedade 'cells' (ExcelRange):

• Leia um arquivo de texto CSV e carregue os dados em um intervalo em uma planilha com LoadFromText e LoadFromTextAsync. AIronXLtambém oferece suas próprias operações de exportação e importação de arquivos CSV .
• LoadFromDataReaderAsync e LoadFromDataReader — carrega campos de dados de um DataReader em um intervalo.
• LoadFromDataTable — carrega dados de um DataTable em um intervalo. Pode importar dados de uma variedade de fontes, incluindo XML (um exemplo é fornecido) e bancos de dados.
• LoadFromCollection — carrega dados reflexivamente de um IEnumerable para um intervalo.
• LoadFromCollection com atributos — carrega dados de forma reflexiva de um IEnumerable para um intervalo ou tabela. Estilos, formatos de número, fórmulas e outras propriedades são especificados através de atributos.
• LoadFromDictionaries — carrega dados de um IEnumerable de objetos ExpandoObject/dinâmicos (através de sua interface IDictionary<string, object>) em um intervalo. Isso é útil para importar dados JSON, e há um exemplo incluído.
• LoadFromArrays — carrega dados de um IEnumerable de objetos [] em um intervalo, com cada matriz de objetos correspondendo a uma linha na planilha.

Ao usar esses métodos, você pode opcionalmente dar um parâmetro para gerar uma tabela Excel. Os exemplos 4 e 5 do projeto de exemplo Sample-.NET Framework ou Sample-.NET Framework contêm exemplos mais extensos.

• Escrevendo Arquivos Excel

Em seguida, vamos ver se podemos exportar dados para um novo arquivo Excel.

Aqui estão alguns dados/objetos de exemplo que gostaríamos de salvar como um documento Excel.

List<UserDetails> persons = new List<UserDetails>()
{
    new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
    new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
    new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
    new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
};

List<UserDetails> persons = new List<UserDetails>()
{
    new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
    new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
    new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
    new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
};

Dim persons As New List(Of UserDetails)() From {
	New UserDetails() With {
		.ID="9999",
		.Name="ABCD",
		.City ="City1",
		.Country="USA"
	},
	New UserDetails() With {
		.ID="8888",
		.Name="PQRS",
		.City ="City2",
		.Country="INDIA"
	},
	New UserDetails() With {
		.ID="7777",
		.Name="XYZZ",
		.City ="City3",
		.Country="CHINA"
	},
	New UserDetails() With {
		.ID="6666",
		.Name="LMNO",
		.City ="City4",
		.Country="UK"
	}
}

Para criar um novo arquivo Excel com as informações essenciais, devemos utilizar a classe ExcelPackage. Escrever dados em um arquivo e produzir uma nova planilha do Excel requer apenas algumas linhas de código. Observe a linha abaixo, que realiza a mágica de carregar DataTables em uma planilha do Excel.

Para simplificar, estou gerando um novo arquivo de planilha na mesma pasta do projeto (o arquivo Excel será produzido na pasta 'bin' do projeto). O código fonte está abaixo:

private static void WriteToExcel(string path)
{
    // Let use below test data for writing it to excel
    List<UserDetails> persons = new List<UserDetails>()
    {
        new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
        new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
        new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
        new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
    };

    // Let's convert our object data to Datatable for a simplified logic.
    // Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
    DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
    FileInfo filePath = new FileInfo(path);
    using (var excelPack = new ExcelPackage(filePath))
    {
        var ws = excelPack.Workbook.Worksheets.Add("WriteTest");
        ws.Cells.LoadFromDataTable(table, true, OfficeOpenXml.Table.TableStyles.Light8);
        excelPack.Save();
    }
}

private static void WriteToExcel(string path)
{
    // Let use below test data for writing it to excel
    List<UserDetails> persons = new List<UserDetails>()
    {
        new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
        new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
        new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
        new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
    };

    // Let's convert our object data to Datatable for a simplified logic.
    // Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
    DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
    FileInfo filePath = new FileInfo(path);
    using (var excelPack = new ExcelPackage(filePath))
    {
        var ws = excelPack.Workbook.Worksheets.Add("WriteTest");
        ws.Cells.LoadFromDataTable(table, true, OfficeOpenXml.Table.TableStyles.Light8);
        excelPack.Save();
    }
}

Private Shared Sub WriteToExcel(ByVal path As String)
	' Let use below test data for writing it to excel
	Dim persons As New List(Of UserDetails)() From {
		New UserDetails() With {
			.ID="9999",
			.Name="ABCD",
			.City ="City1",
			.Country="USA"
		},
		New UserDetails() With {
			.ID="8888",
			.Name="PQRS",
			.City ="City2",
			.Country="INDIA"
		},
		New UserDetails() With {
			.ID="7777",
			.Name="XYZZ",
			.City ="City3",
			.Country="CHINA"
		},
		New UserDetails() With {
			.ID="6666",
			.Name="LMNO",
			.City ="City4",
			.Country="UK"
		}
	}

	' Let's convert our object data to Datatable for a simplified logic.
	' Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
	Dim table As DataTable = CType(JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (GetType(DataTable))), DataTable)
	Dim filePath As New FileInfo(path)
	Using excelPack = New ExcelPackage(filePath)
		Dim ws = excelPack.Workbook.Worksheets.Add("WriteTest")
		ws.Cells.LoadFromDataTable(table, True, OfficeOpenXml.Table.TableStyles.Light8)
		excelPack.Save()
	End Using
End Sub

Após a chamada de API mencionada para validação de dados, um novo arquivo Excel será criado com a transformação do objeto personalizado acima nas colunas e linhas apropriadas do Excel, para mostrar o valor abaixo.

A API pronta para uso acima pode ser utilizada no console .NET Core, em um projeto de teste ou em uma aplicação ASP.NET Core, e a lógica pode ser alterada para atender suas necessidades.

Essas técnicas podem ser acessadas usando a propriedade 'cells' (ExcelRange):

• ToText e ToTextAsync — cria uma string CSV a partir de um intervalo.
• Escrevendo um intervalo em um arquivo CSV com SaveToText e SaveToTextAsync.
• Exportar dados de um intervalo para um Sistema usando o método ToDataTable. Tabela de dados
• GetValue — exibe um valor com a opção de um tipo de dados.
• Value — retorna ou define o valor do intervalo.

Os métodos GetValue e SetValue também podem ser usados ​​diretamente no objeto da planilha. (Isso fornecerá resultados ligeiramente melhores do que ler/escrever no intervalo):

• GetValue — Obtém o valor de uma única célula, com a opção de especificar um tipo de dados.
• SetValue — altera o valor de uma única célula.

O Linq pode ser usado para consultar dados de uma planilha porque a propriedade cell implementa a interface IEnumerable.

Abrir e Escrever no Formato XML Open de Office XLSX com IronXL

IronXL é uma biblioteca NET que permite aos desenvolvedores C# trabalharem com Excel, tabelas dinâmicas e outros arquivos de planilhas de maneira rápida e fácil.

Office Interop não é necessário. Não há dependências particulares nem a necessidade de instalar o Microsoft Office no Core ou Azure.

IronXL é uma renomada biblioteca de planilhas xl em C# e VB.NET for .NET core e .NET framework.

• Lendo Arquivos Excel
• Planilha a ser carregada

Uma planilha do Excel é representada pela classe WorkBook. Utilizamos WorkBook para ler um arquivo Excel em C# que contém até mesmo tabelas dinâmicas. Carregue o arquivo Excel e escolha sua localização (.xlsx).

/**
 Load WorkBook
 **/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

/**
 Load WorkBook
 **/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

'''
''' Load WorkBook
''' *
Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")

Objetos WorkSheet podem ser encontrados em vários WorkBooks. Estas são as planilhas do documento Excel. Se a planilha contiver folhas de exercícios, use o nome WorkBook para encontrá-las com GetWorkSheet.

var worksheet = workbook.GetWorkSheet("GDPByCountry");

var worksheet = workbook.GetWorkSheet("GDPByCountry");

Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

• Crie seu próprio Workbook.

Construa um novo WorkBook com o tipo de planilha para gerar uma nova WorkBook na memória.

/**
 Create WorkBook
 **/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

/**
 Create WorkBook
 **/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

'''
''' Create WorkBook
''' *
Dim workbook As New WorkBook(ExcelFileFormat.XLSX)

Para planilhas antigas do Microsoft Excel, use ExcelFileFormat.XLS (95 e anteriores).

Faça uma WorkSheet se você ainda não tiver uma.

Pode haver inúmeras WorkSheets em cada 'WorkBook'. Uma 'WorkSheet' é uma única folha de dados, enquanto um 'WorkBook' é uma coleção de WorkSheets. Não Excel, é assim que um workbook com duas planilhas fica.

O WorkBook é o nome de um novo WorkSheet que você pode construir.

var worksheet = workbook.CreateWorkSheet("Countries");

var worksheet = workbook.CreateWorkSheet("Countries");

Dim worksheet = workbook.CreateWorkSheet("Countries")

Passe o nome da planilha para CreateWorkSheet.

Obtenha o Intervalo Celular

Uma coleção bidimensional de objetos 'Cell' é representada pela classe 'Range'. Denota um intervalo específico de células do Excel. Usando o indexador de string em um objeto WorkSheet, você pode obter intervalos.

var range = worksheet["D2:D101"];

var range = worksheet["D2:D101"];

Dim range = worksheet("D2:D101")

O argumento de texto pode ser a coordenada de uma célula (por exemplo, 'A1') ou um intervalo de células de esquerda para direita, de cima para baixo (p.ex., 'B2:E5'). GetRange também pode ser chamado a partir de uma planilha.

• Dentro de um Intervalo, Edite os Valores das Células

Os valores das células dentro de um Intervalo podem ser lidos ou editados de várias maneiras. Use um loop For se a contagem for conhecida. Você também pode fazer a formatação de células a partir daqui.

/**
 Edit Cell Values in Range
 **/
 // Iterate through the rows
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{y}:E{y}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string) cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

/**
 Edit Cell Values in Range
 **/
 // Iterate through the rows
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{y}:E{y}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string) cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

'''
''' Edit Cell Values in Range
''' *
 ' Iterate through the rows
For y = 2 To 101
	Dim result = New PersonValidationResult With {.Row = y}
	results.Add(result)

	' Get all cells for the person
	Dim cells = worksheet($"A{y}:E{y}").ToList()

	' Validate the phone number (1 = B)
	Dim phoneNumber = cells(1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	' Validate the email address (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells(3).Value))

	' Get the raw date in the format of Month Day [suffix], Year (4 = E)
	Dim rawDate = CStr(cells(4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next y

Validar Dados em Planilhas

Para validar uma planilha de dados, use o IronXL. O exemplo DataValidation valida números de telefone com libphonenumber-CSharp e endereços de e-mail e datas com APIs convencionais do C#.

/**
 Validate Spreadsheet Data
 **/
 // Iterate through the rows
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{i}:E{i}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

/**
 Validate Spreadsheet Data
 **/
 // Iterate through the rows
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{i}:E{i}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

'''
''' Validate Spreadsheet Data
''' *
 ' Iterate through the rows
For i = 2 To 101
	Dim result = New PersonValidationResult With {.Row = i}
	results.Add(result)

	' Get all cells for the person
	Dim cells = worksheet($"A{i}:E{i}").ToList()

	' Validate the phone number (1 = B)
	Dim phoneNumber = cells(1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	' Validate the email address (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells(3).Value))

	' Get the raw date in the format of Month Day [suffix], Year (4 = E)
	Dim rawDate = CStr(cells(4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next i

O código acima percorre as linhas da planilha, capturando as células como uma lista. Cada método validado verifica o valor de uma célula e retorna um erro se o valor estiver incorreto.

Este código cria uma nova planilha, especifica cabeçalhos e produz os resultados das mensagens de erro para que um log de dados incorretos possa ser mantido.

var resultsSheet = workbook.CreateWorkSheet("Results");

resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

for (var i = 0; i < results.Count; i++)
{
    var result = results[i];
    resultsSheet[$"A{i + 2}"].Value = result.Row;
    resultsSheet[$"B{i + 2}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{i + 2}"].Value = result.PhoneNumberErrorMessage;
    resultsSheet[$"D{i + 2}"].Value = result.EmailErrorMessage;
    resultsSheet[$"E{i + 2}"].Value = result.DateErrorMessage;
}

workbook.SaveAs(@"Spreadsheets\\PeopleValidated.xlsx");

var resultsSheet = workbook.CreateWorkSheet("Results");

resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

for (var i = 0; i < results.Count; i++)
{
    var result = results[i];
    resultsSheet[$"A{i + 2}"].Value = result.Row;
    resultsSheet[$"B{i + 2}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{i + 2}"].Value = result.PhoneNumberErrorMessage;
    resultsSheet[$"D{i + 2}"].Value = result.EmailErrorMessage;
    resultsSheet[$"E{i + 2}"].Value = result.DateErrorMessage;
}

workbook.SaveAs(@"Spreadsheets\\PeopleValidated.xlsx");

Dim resultsSheet = workbook.CreateWorkSheet("Results")

resultsSheet("A1").Value = "Row"
resultsSheet("B1").Value = "Valid"
resultsSheet("C1").Value = "Phone Error"
resultsSheet("D1").Value = "Email Error"
resultsSheet("E1").Value = "Date Error"

For i = 0 To results.Count - 1
	Dim result = results(i)
	resultsSheet($"A{i + 2}").Value = result.Row
	resultsSheet($"B{i + 2}").Value = If(result.IsValid, "Yes", "No")
	resultsSheet($"C{i + 2}").Value = result.PhoneNumberErrorMessage
	resultsSheet($"D{i + 2}").Value = result.EmailErrorMessage
	resultsSheet($"E{i + 2}").Value = result.DateErrorMessage
Next i

workbook.SaveAs("Spreadsheets\\PeopleValidated.xlsx")

Usando o Entity Framework para Exportar Dados

Use oIronXLpara converter uma planilha do Excel em um banco de dados ou para exportar dados para um banco de dados. O exemplo ExcelToDB lê uma planilha contendo o PIB por país e a exporta para o SQLite.

Ele cria o banco de dados com EntityFramework e depois exporta os dados linha por linha.

Os pacotes NuGet do SQLite Entity Framework devem ser instalados.

Você pode usar o EntityFramework para construir um objeto modelo que possa exportar dados para um banco de dados.

public class Country
{
    [Key]
    public Guid Key { get; set; }
    public string Name { get; set; }
    public decimal GDP { get; set; }
}

public class Country
{
    [Key]
    public Guid Key { get; set; }
    public string Name { get; set; }
    public decimal GDP { get; set; }
}

Public Class Country
	<Key>
	Public Property Key() As Guid
	Public Property Name() As String
	Public Property GDP() As Decimal
End Class

Para usar um banco de dados diferente, instale o pacote NuGet apropriado e procure o equivalente a UseSqLite (UseMySQL, UseSqlServer, etc.).

/**
 Export Data using Entity Framework
 **/
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    public CountryContext()
    {
        // TODO: Make async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configure context to use Sqlite
    /// </summary>
    /// <param name="optionsBuilder"></param>
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connection = new SqliteConnection($"Data Source=Country.db");
        connection.Open();

        var command = connection.CreateCommand();

        // Create the database if it doesn't already exist
        command.CommandText = $"PRAGMA foreign_keys = ON;";
        command.ExecuteNonQuery();

        optionsBuilder.UseSqlite(connection);

        base.OnConfiguring(optionsBuilder);
    }
}

/**
 Export Data using Entity Framework
 **/
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    public CountryContext()
    {
        // TODO: Make async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configure context to use Sqlite
    /// </summary>
    /// <param name="optionsBuilder"></param>
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connection = new SqliteConnection($"Data Source=Country.db");
        connection.Open();

        var command = connection.CreateCommand();

        // Create the database if it doesn't already exist
        command.CommandText = $"PRAGMA foreign_keys = ON;";
        command.ExecuteNonQuery();

        optionsBuilder.UseSqlite(connection);

        base.OnConfiguring(optionsBuilder);
    }
}

'''
''' Export Data using Entity Framework
''' *
Public Class CountryContext
	Inherits DbContext

	Public Property Countries() As DbSet(Of Country)

	Public Sub New()
		' TODO: Make async
		Database.EnsureCreated()
	End Sub

	''' <summary>
	''' Configure context to use Sqlite
	''' </summary>
	''' <param name="optionsBuilder"></param>
	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		Dim connection = New SqliteConnection($"Data Source=Country.db")
		connection.Open()

		Dim command = connection.CreateCommand()

		' Create the database if it doesn't already exist
		command.CommandText = $"PRAGMA foreign_keys = ON;"
		command.ExecuteNonQuery()

		optionsBuilder.UseSqlite(connection)

		MyBase.OnConfiguring(optionsBuilder)
	End Sub
End Class

Produza um CountryContext, depois itere pelo intervalo para criar cada entrada antes de salvar os dados no banco de dados com SaveChangesAsync.

public async Task ProcessAsync()
{
    // Get the first worksheet
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    // Create the database connection
    using (var countryContext = new CountryContext())
    {
        // Iterate through all the cells
        for (var i = 2; i <= 213; i++)
        {
            // Get the range from A-B
            var range = worksheet[$"A{i}:B{i}"].ToList();

            // Create a Country entity to be saved to the database
            var country = new Country
            {
                Name = (string)range[0].Value,
                GDP = (decimal)(double)range[1].Value
            };

            // Add the entity
            await countryContext.Countries.AddAsync(country);
        }

        // Commit changes to the database
        await countryContext.SaveChangesAsync();
    }
}

public async Task ProcessAsync()
{
    // Get the first worksheet
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    // Create the database connection
    using (var countryContext = new CountryContext())
    {
        // Iterate through all the cells
        for (var i = 2; i <= 213; i++)
        {
            // Get the range from A-B
            var range = worksheet[$"A{i}:B{i}"].ToList();

            // Create a Country entity to be saved to the database
            var country = new Country
            {
                Name = (string)range[0].Value,
                GDP = (decimal)(double)range[1].Value
            };

            // Add the entity
            await countryContext.Countries.AddAsync(country);
        }

        // Commit changes to the database
        await countryContext.SaveChangesAsync();
    }
}

Public Async Function ProcessAsync() As Task
	' Get the first worksheet
	Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")
	Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

	' Create the database connection
	Using countryContext As New CountryContext()
		' Iterate through all the cells
		For i = 2 To 213
			' Get the range from A-B
			Dim range = worksheet($"A{i}:B{i}").ToList()

			' Create a Country entity to be saved to the database
			Dim country As New Country With {
				.Name = CStr(range(0).Value),
				.GDP = CDec(CDbl(range(1).Value))
			}

			' Add the entity
			Await countryContext.Countries.AddAsync(country)
		Next i

		' Commit changes to the database
		Await countryContext.SaveChangesAsync()
	End Using
End Function

Incorpore uma Fórmula em uma Planilha

A propriedade Formula pode ser usada para definir a fórmula de uma célula .

// Iterate through all rows with a value
for (var y = 2; y < i; y++)
{
    // Get the C cell
    var cell = sheet[$"C{y}"].First();

    // Set the formula for the Percentage of Total column
    cell.Formula = $"=B{y}/B{i}";
}

// Iterate through all rows with a value
for (var y = 2; y < i; y++)
{
    // Get the C cell
    var cell = sheet[$"C{y}"].First();

    // Set the formula for the Percentage of Total column
    cell.Formula = $"=B{y}/B{i}";
}

' Iterate through all rows with a value
Dim y = 2
Do While y < i
	' Get the C cell
	Dim cell = sheet($"C{y}").First()

	' Set the formula for the Percentage of Total column
	cell.Formula = $"=B{y}/B{i}"
	y += 1
Loop

O código na coluna C itera por cada estado e calcula um total em porcentagem.

Dados de uma API podem ser baixados para uma planilha

RestClient.Net é usado na chamada a seguir para fazer uma chamada REST. Ele baixa JSON e o transforma em uma 'Lista' do tipo RestCountry. Os dados da API REST podem então ser facilmente salvos em um arquivo Excel iterando por cada país.

/**
 Data API to Spreadsheet
 **/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();

/**
 Data API to Spreadsheet
 **/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();

'''
''' Data API to Spreadsheet
''' *
Dim client As New Client(New Uri("https://restcountries.eu/rest/v2/"))
Dim countries As List(Of RestCountry) = Await client.GetAsync(Of List(Of RestCountry))()

Os dados JSON da API parecem assim:

O código a seguir percorre os países e preenche a planilha com Nome, População, Região, Código Numérico e Topo 3 Idiomas.

for (var i = 2; i < countries.Count; i++)
{
    var country = countries[i];

    // Set the basic values
    worksheet[$"A{i}"].Value = country.name;
    worksheet[$"B{i}"].Value = country.population;
    worksheet[$"G{i}"].Value = country.region;
    worksheet[$"H{i}"].Value = country.numericCode;

    // Iterate through languages
    for (var x = 0; x < 3; x++)
    {
        if (x > (country.languages.Count - 1)) break;

        var language = country.languages[x];

        // Get the letter for the column
        var columnLetter = GetColumnLetter(4 + x);

        // Set the language name
        worksheet[$"{columnLetter}{i}"].Value = language.name;
    }
}

for (var i = 2; i < countries.Count; i++)
{
    var country = countries[i];

    // Set the basic values
    worksheet[$"A{i}"].Value = country.name;
    worksheet[$"B{i}"].Value = country.population;
    worksheet[$"G{i}"].Value = country.region;
    worksheet[$"H{i}"].Value = country.numericCode;

    // Iterate through languages
    for (var x = 0; x < 3; x++)
    {
        if (x > (country.languages.Count - 1)) break;

        var language = country.languages[x];

        // Get the letter for the column
        var columnLetter = GetColumnLetter(4 + x);

        // Set the language name
        worksheet[$"{columnLetter}{i}"].Value = language.name;
    }
}

For i = 2 To countries.Count - 1
	Dim country = countries(i)

	' Set the basic values
	worksheet($"A{i}").Value = country.name
	worksheet($"B{i}").Value = country.population
	worksheet($"G{i}").Value = country.region
	worksheet($"H{i}").Value = country.numericCode

	' Iterate through languages
	For x = 0 To 2
		If x > (country.languages.Count - 1) Then
			Exit For
		End If

		Dim language = country.languages(x)

		' Get the letter for the column
		Dim columnLetter = GetColumnLetter(4 + x)

		' Set the language name
		worksheet($"{columnLetter}{i}").Value = language.name
	Next x
Next i

Abrir arquivos Excel com o IronXL

Após lançar o arquivo Excel, adicione as primeiras linhas que leem a 1ª célula na 1ª planilha e imprima.

static void Main(string[] args)
{
    var workbook = IronXl.WorkBook.Load($@"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx");
    var sheet = workbook.WorkSheets.First();
    var cell = sheet["A1"].StringValue;
    Console.WriteLine(cell);
}

static void Main(string[] args)
{
    var workbook = IronXl.WorkBook.Load($@"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx");
    var sheet = workbook.WorkSheets.First();
    var cell = sheet["A1"].StringValue;
    Console.WriteLine(cell);
}

Imports System
Imports System.IO
Imports IronXl

Module Program
    Sub Main(args As String())
        Dim workbook = WorkBook.Load($"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx")
        Dim sheet = workbook.WorkSheets.First()
        Dim cell = sheet("A1").StringValue
        Console.WriteLine(cell)
    End Sub
End Module

Usando o IronXL, crie um novo arquivo Excel.

/**
 Create Excel File
 **/
static void Main(string[] args)
{
    var newXLFile = WorkBook.Create(ExcelFileFormat.XLSX);
    newXLFile.Metadata.Title = "IronXL New File";
    var newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet");
    newWorkSheet["A1"].Value = "Hello World";
    newWorkSheet["A2"].Style.BottomBorder.SetColor("#ff6600");
    newWorkSheet["A2"].Style.BottomBorder.Type = IronXl.Styles.BorderType.Dashed;
}

/**
 Create Excel File
 **/
static void Main(string[] args)
{
    var newXLFile = WorkBook.Create(ExcelFileFormat.XLSX);
    newXLFile.Metadata.Title = "IronXL New File";
    var newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet");
    newWorkSheet["A1"].Value = "Hello World";
    newWorkSheet["A2"].Style.BottomBorder.SetColor("#ff6600");
    newWorkSheet["A2"].Style.BottomBorder.Type = IronXl.Styles.BorderType.Dashed;
}

Option Strict On



Module Program
    ''' <summary>
    ''' Create Excel File
    ''' </summary>
    Sub Main(args As String())
        Dim newXLFile = WorkBook.Create(ExcelFileFormat.XLSX)
        newXLFile.Metadata.Title = "IronXL New File"
        Dim newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet")
        newWorkSheet("A1").Value = "Hello World"
        newWorkSheet("A2").Style.BottomBorder.SetColor("#ff6600")
        newWorkSheet("A2").Style.BottomBorder.Type = IronXl.Styles.BorderType.Dashed
    End Sub
End Module

Depois disso, você pode salvar em CSV, JSON ou XML usando seus respectivos códigos, como mostrado nos exemplos de código do IronXL .

Por exemplo, para salvar em XML .xml

Para salvar em XML, use SaveAsXml da seguinte forma:

newXLFile.SaveAsXml($@"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML");

newXLFile.SaveAsXml($@"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML");

newXLFile.SaveAsXml($"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML")

O resultado parece assim:

<?xml version="1.0" standalone="yes"?>
<_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Hello World</Column1>
  </_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" />
  </_x0031_stWorkSheet>
</_x0031_stWorkSheet>

<?xml version="1.0" standalone="yes"?>
<_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Hello World</Column1>
  </_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" />
  </_x0031_stWorkSheet>
</_x0031_stWorkSheet>

OIronXLoferece uma API mais concisa para leitura de arquivos Excel — acessar colunas, linhas e células em uma planilha normalmente requer menos linhas de código. Em contrapartida, oEPPlusexpõe uma API mais granular em nível de célula que exige o tratamento explícito de colunas e linhas, o que oferece um controle preciso, mas aumenta a verbosidade.

OIronXLoferece maior flexibilidade na manipulação de documentos do Excel. Ele permite a criação de planilhas adicionais a qualquer momento, a leitura de dados em várias planilhas e pastas de trabalho em um único fluxo de trabalho e a exportação de dados da pasta de trabalho diretamente para um banco de dados. AEPPlusconcentra sua API no trabalho com planilhas individuais — uma abordagem simples para tarefas em uma única planilha, mas que cria etapas de integração adicionais para equipes que precisam de operações entre várias pastas de trabalho.

Como se comparam oEPPluse oIronXLem termos de licenciamento e preços?

Qual biblioteca você deve escolher?

OEPPlusoferece uma API sólida e bem estabelecida para trabalhar com planilhas Office Open XML, e seu controle granular em nível de célula é adequado para projetos que precisam de manipulação precisa de planilhas. Para equipes cujas necessidades incluem exportação em múltiplos formatos (XML, HTML, JSON), operações entre pastas de trabalho e integração com bancos de dados, oIronXLadiciona esses recursos como operações de primeira classe. OIronXLtambém recalcula as fórmulas cada vez que o documento é editado e fornece uma sintaxe de intervalo intuitiva com WorkSheet[“A1:B10”]. Os formatos de dados das células abrangem texto, números, fórmulas, datas, moedas, porcentagens, notação científica e hora, enquanto o estilo das células engloba fontes, tamanhos, padrões de fundo, bordas e alinhamentos. A classificação está disponível em intervalos, colunas e linhas. A escolha entre os dois depende, em última análise, se o seu projeto precisa do tratamento específico de Open XML doEPPlusou da maior abrangência de funcionalidades do IronXL. Para ver como oIronXLse adapta ao seu fluxo de trabalho, baixe uma versão de avaliação gratuita de 30 dias e teste os exemplos deste artigo em seu próprio ambiente.