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. EPPlus nã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 o EPPlus a 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 Excel simples para C# e VB que permite ler, editar e criar arquivos de planilhas Excel em .NET com velocidade relâmpago. Não é necessário instalar o Microsoft Office ou mesmo o Excel Interop. Esta biblioteca também pode ser usada para trabalhar com arquivos Excel.

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

Criando um arquivo Excel com IronXL

Criar um novo Workbook Excel com IronXL não poderia ser mais fácil! É apenas uma única linha de código! Sim, isso é verdade:

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

IronXL pode criar arquivos nos formatos XLS (a versão anterior do arquivo Excel) e XLSX (versão atual e mais nova do arquivo 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");

A planilha é representada por sheet no trecho de código acima, e você pode usá-la para definir valores de células e fazer praticamente tudo 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 com EPPlus Software AB

O EPPlus pode 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á todo o código-fonte para converter um DataTable normal para 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);
}

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.
• Construímos um objeto ExcelPackage, que é o contêiner principal do EPPlus para 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 da nossa planilha.
• Iteramos pelas linhas DataTable, adicionando cada uma à nossa planilha linha por linha (começando com a linha 2), de modo 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 a convertemos 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.

IronXL ganha neste caso porque o processo de criação é muito fácil — você precisa de apenas uma linha de código e está dentro; isso ajuda a economizar tempo e com a depuração, enquanto o EPPlus oferece linhas de código que são entediantes de passar e difíceis de depurar.

Como o EPPlus Software 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());
                    }
                }
            }
        }
    }
}

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.
• 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 de uma coleção IEnumerable em um intervalo.
• LoadFromCollection with attributes — carrega dados de uma coleção 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 uma coleção IEnumerable de ExpandoObject/objetos dinâmicos (através de sua interface IDictionary<string, object>) para 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 amostra 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"},
};

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, preste atenção à única linha abaixo que realiza o carregamento de 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();
    }
}

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. DataTable
• 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.

O 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 do Excel é representada pela classe WorkBook. Utilizamos WorkBook para abrir 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");

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

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

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

• Crie seu próprio Workbook.

Construa um novo WorkBook com o tipo de folha para gerar um novo WorkBook na memória.

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

/**
 Create WorkBook
 **/
var workbook = 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. No 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");

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"];

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

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

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

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

Para usar um banco de dados diferente, instale o pacote NuGet apropriado e procure o equivalente 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);
    }
}

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

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

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

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

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

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

Depois disso, você pode salvar em CSV, JSON ou XML usando seus respectivos códigos.

Por exemplo, para salvar em XML .xml

Para salvar em XML use SaveAsXml da seguinte maneira:

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>

Ler arquivos Excel é mais fácil com IronXL em vez de com EPPlus. IronXL tem códigos mais resumidos que abrangem tudo o que é necessário para acessar todas as colunas, linhas e células em um livro de trabalho, enquanto com o EPPlus você precisará de uma linha de código específica para ler colunas e linhas.

IronXL é mais inteligente quando se trata de manipular documentos Excel. Ele lhe dá a vantagem de criar mais planilhas a qualquer momento, além de ler dados de várias planilhas e livros de trabalho, enquanto o EPPlus lida com uma planilha de cada vez. Com o IronXL, você também pode preencher um banco de dados com os dados em seu livro de trabalho Excel.

Licenciamento e Preços do EPPlus e IronXL

Conclusão

Em conclusão, o IronXL é mais prático que o EPPlus porque lhe dá a flexibilidade de navegar pela tabela do Excel como você precisar, com linhas de código mais curtas e mais oportunidades de exportação incluindo XML, HTML e JSON. O IronXL também permite que você integre os dados do seu workbook em um banco de dados. Além disso, ele tem um sistema intuitivo que recalcula fórmulas cada vez que o documento é editado, e fornece uma configuração de Intervalos Intuitivos com a sintaxe WorkSheet["A1:B10"]. As funções da planilha incluem fórmulas que trabalham com o Excel e são recalculadas cada vez que a planilha é editada. Os formatos de dados das células incluem múltiplos textos, números, fórmulas, datas, moeda, porcentagens, notação científica e tempo. Seus formatos personalizados têm diferentes métodos de ordenação, como intervalos, colunas e linhas. Seu estilo de célula inclui uma variedade de fontes, tamanhos, padrões de fundo, bordas e alinhamentos.

{{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.