IronXL eEPPlussão ambas bibliotecas .NET Excel que leem e criam .xls e .xlsx arquivos sem exigir Microsoft Office ou Interop. Esta comparação abrange suas APIs, formatos suportados e licenciamento — com exemplos de código para as operações mais comumente usadas em aplicações .NET.

O que é o software EPPlus?

EPPlus é uma biblioteca para .NET Framework/.NET Core baseada no NuGet para manipular planilhas Office Open XML. A versão 5 inclui suporte para .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 .NET 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.

Adicionando IronXL usando o Pacote NuGet

Podemos adicionar o pacote IronXL à 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:

O IronXL será 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 o IronXL se comparam nas principais áreas discutidas neste artigo:

Para testar as operações do IronXL no 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 o IronXL requer 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)

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

O IronXL pode 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")

' 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élula 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 normal DataTable para um arquivo XLSX Excel e enviá-lo para o 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

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 personalizável de Provedor de Dados, obtemos um objeto DataTable.
• Construímos 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 através das linhas DataTable, adicionando cada uma à nossa planilha linha por linha (começando com a linha 2) para 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 completa e depois convertê-lo para um array 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 do IronXL para a criação de planilhas requer uma única linha de código em comparação com a configuração em várias etapas doEPPlusenvolvendo 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

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

• Ler um arquivo de texto CSV e carregar os dados em um intervalo em uma planilha com LoadFromText e LoadFromTextAsync. A IronXL també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.
• LoadFromTabela de dados — 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 de forma reflexiva de um IEnumerable em um intervalo.
• LoadFromCollection with attributes — carrega dados de forma reflexiva de um IEnumerable em 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, onde cada array de objetos corresponde a uma linha na planilha.

Ao usar esses métodos, você pode opcionalmente dar um parâmetro para gerar uma tabela Excel. Os amostras 4 e 5 do projeto 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"
	}
}

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. Por favor, observe a linha abaixo que realiza a mágica de carregar DataTables em uma planilha 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

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.
• Escrever 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 — mostra um valor com a opção de um tipo de dado.
• 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 dado.
• SetValue — altera o valor de uma única célula.

Linq pode ser usado para consultar dados de uma planilha porque a propriedade da célula 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 Excel é representada pela classe WorkBook. Utilizamos WorkBook para ler um arquivo Excel em C# contendo 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")

'''
''' 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 sub-planilhas, use o nome WorkBook para encontrá-las com GetWorkSheet.

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

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

Dim 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 um novo 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)

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

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

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 de um WorkSheet.

• 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

'''
''' 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-C#, 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

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

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 o IronXL para 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 nação e a exporta para 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

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

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

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

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

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

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

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

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

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

'''
''' Create Excel File
''' *
Shared Sub Main(ByVal 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

'''
''' Create Excel File
''' *
Shared Sub Main(ByVal 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

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 conforme segue:

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

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>

O IronXL oferece 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.

O IronXL oferece 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 o IronXL em termos de licenciamento e preços?

Modelo de Licenciamento e Preço do EPPlus

EPPlus pode ser usado em dois modelos de licença, seja um modelo de licença não comercial ou um modelo de licença comercial da Polyform.

Licenças Comerciais

Estas estão disponíveis tanto em formatos perpétuos quanto baseados em assinatura, com termos variando de um mês a dois anos.

Para todas as categorias de licenciamento, suporte via centro de suporte e atualizações via NuGet estão incluídos durante a duração da licença.

EPPlus requer uma licença por desenvolvedor. Licenças são emitidas para um único indivíduo e não podem ser compartilhadas. Como diretriz geral, qualquer um que produza ou precise depurar código que utilize diretamente oEPPlusdeve ter uma licença comercial.

Se você fornecer oEPPluscomo um serviço internamente (por exemplo, expondo suas capacidades via uma API), sua empresa deve adquirir uma assinatura que cubra o número de usuários internos (desenvolvedores) que usarão o serviço.

Assinaturas

Você pode sempre usar a versão mais recente com uma assinatura, mas deve possuir uma licença válida enquanto usar oEPPluspara desenvolvimento. Ao final do período de licenciamento, a licença é automaticamente faturada e renovada assim que o pagamento é efetuado. Você pode cancelar sua assinatura ao final do período de licenciamento e iniciar uma nova quando desejar. Assinaturas estão disponíveis apenas para compra na internet.

EPPlus pode ser usado em um ambiente comercial. A licença é para um desenvolvedor por empresa, com um número ilimitado de locais de implantação. O número de licenças disponíveis para compra a cada ano pode ser aumentado ou reduzido, e a licença pode ser suspensa ou cancelada ao fim de cada ano.

Um período de teste de 32 dias está disponível como opção.

Preços: Começa em $299 por ano.

Você pode pagar conforme o uso

Preço por desenvolvedor dentro de uma única organização, com locais de implantação ilimitados e faturamento via Stripe. O número de licenças disponíveis a cada mês pode ser aumentado ou reduzido, e a licença pode ser suspensa ou cancelada no final de cada mês.

Preços: Começa a partir de $29 por mês.

Licença Perpétua

Uma licença perpétua permite que você atualize para novas versões e receba suporte por um período determinado de tempo. Você pode continuar a desenvolver software usando as versões lançadas durante esse tempo sem precisar renovar sua licença.

Dentro da mesma empresa, preço por desenvolvedor com locais de implantação ilimitados. Uso de todas as versões doEPPluslançadas dentro do prazo de suporte/melhorias indefinidamente.

Um período de teste de 32 dias está disponível como opção.

Preços: Começa em $599 por ano.

Pacotes

Opções de licença perpétua com uma duração inicial de melhorias e suporte estão disponíveis. Você pode continuar a desenvolver software usando as versões lançadas durante este período sem precisar renovar sua licença.

Preços: Começa em $4,295 por ano.

Licença não comercial para Polyform

EPPlus é licenciado sob a licença Polyform Noncommercial a partir da versão 5, o que indica que o código é de código aberto e pode ser usado para usos não comerciais. Você pode ver mais detalhes em seu site.

Modelo de Licença e Preço do IronXL

Licenciamento Perpétuo: cada licença é comprada uma vez e não requer renovação.

Suporte Gratuito & Atualizações de Produto: cada licença vem com um ano de atualizações gratuitas do produto e suporte da equipe por trás do produto. É possível adquirir extensões a qualquer momento. Extensões podem ser visualizadas.

Licenças Imediatas: as chaves de licença registradas são enviadas assim que o pagamento é recebido.

Por favor, entre em contato com nossos especialistas em licenciamento da Iron Software se tiver alguma dúvida sobre o licenciamento do IronXL for .NET.

Todas as licenças são perpétuas e se aplicam ao desenvolvimento, staging e produção.

Lite - Permite que um único desenvolvedor de software em uma organização utilize a Iron Software em um único lugar. O Iron Software pode ser usado em uma única aplicação web, aplicação intranet ou programa de software desktop. As licenças são intransferíveis e não podem ser compartilhadas fora de uma organização ou de uma relação de agência/cliente. Esse tipo de licença, como todos os outros tipos de licença, exclui expressamente todos os direitos não expressamente concedidos no Acordo, incluindo a redistribuição OEM e a utilização da Iron Software como um SaaS sem a compra de cobertura adicional.

Preços: Começa a partir de $999.

Licença Profissional - Permite que um número predeterminado de desenvolvedores de software em uma organização utilize a Iron Software em um único local, até um máximo de dez. O Iron Software pode ser utilizado em quantos sites, aplicações intranet ou aplicações de software desktop desejar. As licenças são intransferíveis e não podem ser compartilhadas fora de uma organização ou de uma relação de agência/cliente. Este tipo de licença, como todos os outros tipos de licença, exclui expressamente todos os direitos não expressamente concedidos no Acordo, incluindo a redistribuição OEM e a utilização do Iron Software como SaaS sem a aquisição de cobertura adicional.

Preços: Começa a partir de $2,399.

Licença Ilimitada - Permite um número ilimitado de desenvolvedores de software em uma organização para utilizar a Iron Software em um número ilimitado de locais. O Iron Software pode ser utilizado em quantos sites, aplicações intranet ou aplicações de software desktop desejar. As licenças são intransferíveis e não podem ser compartilhadas fora de uma organização ou de uma relação de agência/cliente. Este tipo de licença, como todos os outros tipos de licença, exclui expressamente todos os direitos não expressamente concedidos no Acordo, incluindo a redistribuição OEM e a utilização do Iron Software como SaaS sem a aquisição de cobertura adicional.

Redistribuição Sem Royalties - Permite distribuir a Iron Software como parte de vários produtos comerciais empacotados (sem ter que pagar royalties) com base no número de projetos cobertos pela licença básica. Permite a implantação da Iron Software dentro de serviços de software SaaS, com base no número de projetos cobertos pela licença básica.

Preços: Começa a partir de $4,799.

Além do custo da licença, o custo total do projeto inclui as horas de desenvolvimento gastas na criação de lógica de exportação adicional para formatos como JSON e XML, na construção de pipelines manuais de integração de banco de dados e no gerenciamento da orquestração de múltiplas planilhas, que a biblioteca não suporta nativamente. Para equipes que avaliam custos ao longo de um ciclo de vida de projeto de vários anos, esses custos de integração e manutenção frequentemente superam a diferença entre os modelos de licenciamento.

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, o IronXL adiciona esses recursos como operações de primeira classe. O IronXL também recalcula fórmulas toda 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 o IronXL se 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.

{[{i:(EPPlus é uma marca registrada de seu respectivo proprietário. Este site não é afiliado, endossado ou patrocinado pelo EPPlus. Todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos proprietários. As comparações são apenas para fins informativos e refletem informações disponíveis publicamente no momento da redação.