Exportar dados para o Excel em C#

Neste artigo, mostrarei como exportar dados para o Excel em C# e VB.NET de várias fontes de dados, como array, coleção de objetos personalizados, DataTable, DataView, DataGrid, GridView, HTML, JSON e CSV.

• Exportar matriz para Excel em C #
  • Exportar ArrayList para Excel
  • Exportar coleção de objetos personalizados para o Excel
• Copiar linhas e colunas de um arquivo do Excel para outro
• Exportar DataTable para Excel em C #
  • Exportar dados de DataColumns seletivos para o Excel
  • Exportar DataView para Excel
• Exportar dados de DataGrid e GridView para Excel
• Exportar dados formatados em HTML para o Excel
  • Exportar arquivo HTML para Excel
• Exportar dados JSON para o Excel em C#
• Exportar dados CSV para o Excel em C#

Exportar dados para o Excel em C# com API Aspose.Cells

Aspose.Cells for .NET é uma poderosa API de manipulação de planilhas que permite criar, editar ou converter arquivos Excel em aplicativos .NET. Os métodos fáceis de usar da API permitem que você execute recursos de automação do Excel perfeitamente em poucas linhas de código. NuGet é a maneira mais fácil de baixar e instalar API Aspose.Cells para .NET. Abra a janela Gerenciar Pacotes NuGet e digite “Aspose.Cells” na caixa de texto de pesquisa para localizar o pacote .NET Aspose.Cells. Por fim, clique no botão Instalar para instalar a versão mais recente do pacote.

Exportar matriz para Excel em C

Podemos exportar um array (unidimensional ou bidimensional) de um tipo de referência ou tipo de valor para um documento do Excel. Usamos o método ImportArray da coleção Cells para exportar dados para uma planilha de um array. As versões sobrecarregadas do método ImportArray são as seguintes.

Uma sobrecarga típica usa os seguintes parâmetros:

• Array, o objeto de matriz do qual você está exportando conteúdo.
• Número da linha, o número da linha da primeira célula (baseada em zero) para a qual os dados serão exportados.
• Número da coluna, o número da coluna da primeira célula (baseada em zero) para a qual os dados serão exportados.
• É vertical, um valor booleano que especifica se os dados devem ser exportados verticalmente ou horizontalmente.

A seguir estão as etapas para exportar uma matriz para o arquivo do Excel em C#.

• Crie um objeto Pasta de trabalho. Uma classe Workbook representa um arquivo do Microsoft Excel.
• Obtenha uma referência para a planilha desejada. A classe Workbook contém uma coleção Worksheets que permite o acesso a cada planilha em um arquivo Excel.
• Chame o método ImportArray de uma coleção Cells para exportar uma matriz para a planilha na linha e coluna especificadas. A classe Worksheet fornece uma coleção Cells.
• Salve o arquivo do Excel usando o método Workbook.Save(string).

O exemplo de código a seguir mostra como exportar uma matriz de String para um arquivo do Excel em C#.

// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];

// Creating an array containing names as string values
string[] names = new string[] { "Laurence Chen", "Roman Korchagin", "Kyle Huang" };

// Exporting the array of names to first row and first column vertically
worksheet.Cells.ImportArray(names, 0, 0, true);

// Saving the Excel file
workbook.Save("StringsArray.xlsx");

Da mesma forma, podemos exportar um array bidimensional para um arquivo Excel. O exemplo de código a seguir mostra como exportar uma matriz bidimensional para um arquivo do Excel em C#.

// Creating a two-dimensional array of integers
int[,] array2D = new int[4, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };

// Exporting a two-dimensional array at the first row and first column of the worksheet
worksheet.Cells.ImportArray(array2D, 0, 0);

Exportar ArrayList para Excel em C

Para exportar dados de um ArrayList para uma planilha, chame o método ImportArrayList da coleção Cells. O método ImportArrayList usa os seguintes parâmetros:

• A lista de matrizes representa o objeto ArrayList que você está exportando.
• Número da linha representa o número da linha da primeira célula para a qual os dados serão exportados.
• O número da coluna representa o número da coluna da primeira célula para a qual os dados serão exportados.
• É vertical um valor booleano que especifica se os dados devem ser exportados verticalmente ou horizontalmente.

O exemplo de código a seguir mostra como exportar um ArrayList para um arquivo do Excel em C#.

// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];

// Instantiating an ArrayList object
ArrayList list = new ArrayList();

// Add few names to the list as string values
list.Add("Laurence Chen");
list.Add("Roman Korchagin");
list.Add("Kyle Huang");
list.Add("Tommy Wang");

// Exporting the contents of ArrayList vertically at the first row and first column of the worksheet. 
worksheet.Cells.ImportArrayList(list, 0, 0, true);

// Saving the Excel file
workbook.Save("ArrayListExport.xlsx");

Exportar coleção de objetos personalizados para Excel em C#

Para exportar dados de uma coleção de objetos personalizados para uma planilha, usamos o método ImportCustomObjects. Existem duas versões sobrecarregadas deste método.

1. ImportCustomObjects(ICollection list, String[] propertyNames, Boolean isPropertyNameShown, Int32 firstRow, Int32 firstColumn, Int32 rowNumber, inserções booleanas, String dateFormatString, Boolean convertStringToNumber)
2. ImportCustomObjects(lista ICollection, Int32 firstRow, Int32 firstColumn, opções ImportTableOptions)

Vamos explorar cada método sobrecarregado um por um. A descrição dos parâmetros do primeiro método sobrecarregado é dada abaixo:

• list A coleção de objetos personalizados.
• propertyNames Nomes de propriedades do objeto a ser exportado. Se for nulo, todas as propriedades serão exportadas.
• isPropertyNameShown Indica se os nomes das propriedades serão exportados para a primeira linha.
• firstRow O número da linha da primeira célula para a qual exportar.
• firstColumn O número da coluna da primeira célula para a qual exportar.
• rowNumber Número de objetos a serem exportados.
• insertRows Indica se linhas extras são adicionadas para ajustar os dados.
• dateFormatString Cadeia de caracteres de formato de data para células.
• convertStringToNumber Indica se este método tentará converter a string em um número.

No exemplo a seguir, estamos exportando uma lista de objetos Person para um documento do Excel em C#. Observe que estamos exportando apenas duas propriedades (Nome e Idade) de um objeto Pessoa.

// Instantiate a new Workbook
Workbook book = new Workbook();
// Obtaining the reference of the worksheet
Worksheet sheet = book.Worksheets[0];

// Define List
List<Person> list = new List<Person>();

list.Add(new Person("Mike", 25, "Software Engineer"));
list.Add(new Person("Steve", 30, "Doctor"));
list.Add(new Person("Billy", 35, "Teacher"));

// We pick only Name and Age columns, not all, to export to the worksheet         
sheet.Cells.ImportCustomObjects((System.Collections.ICollection)list,
    new string[] { "Name", "Age" }, // propertyNames
    true, // isPropertyNameShown
    0, // firstRow
    0, // firstColumn
    list.Count, // Number of objects to be exported
    true, // insertRows
    null, // dateFormatString
    false); // convertStringToNumber

// Save the Excel file
book.Save("ExportedCustomObjects.xlsx");
       
public class Person
{
    public string Name { get; set; }

    public int Age { get; set; }

    public string Occupation { get; set; }

    public Person(string name, int age, string occupation)
    {
        Age = age;
        Name = name;
        Occupation = occupation;
    }
}

Agora vamos explorar o segundo método sobrecarregado de ImportCustomObjects. A descrição dos parâmetros do método é dada abaixo:

• list A lista de objetos personalizados.
• firstRow O número da linha da primeira célula para a qual exportar.
• firstColumn O número da coluna da primeira célula para a qual exportar.
• opções ImportTableOptions objeto.

O parâmetro ImportTableOptions fornece várias opções para exportar dados para células. Alguns deles são dados abaixo:

• CheckMergedCells Um documento do Excel contém células mescladas.
• ColumnIndexes Matriz inteira de índices de coluna (com base em 0) para exportar da fonte de dados. null significa que todas as colunas devem ser exportadas.
• ConvertGridStyle Indica se o estilo do modo de exibição de grade deve ser aplicado às células.
• ConvertNumericData Um valor booleano que indica se o valor da string deve ser convertido em valor numérico ou de data.
• DateFormat Obtém ou define a string de formato de data para células com valores de DateTime exportados.
• DefaultValues O valor padrão da célula na tabela é nulo.
• InsertRows Indica se novas linhas devem ser adicionadas para exportar registros de dados.
• IsFieldNameShown Indica se os nomes dos campos devem ser exportados.
• IsFormulas Indica se os dados são fórmulas.
• IsHtmlString Indica se os dados contêm tags HTML. Se definirmos o valor como true, a formatação HTML permanecerá preservada durante a exportação de dados para um documento do Excel.
• NumberFormats Obtém ou define os formatos de número
• ShiftFirstRowDown Indica se a primeira linha deve ser deslocada para baixo ao inserir linhas.
• TotalColumns Obtém ou define a contagem total de colunas a serem exportadas de uma fonte de dados. -1 significa todas as colunas da fonte de dados fornecida.
• TotalRows Obtém ou define a contagem total de linhas a serem exportadas da fonte de dados. -1 significa todas as linhas da fonte de dados fornecida.

No exemplo a seguir, estamos exportando dados de uma coleção de objetos para uma planilha contendo células mescladas. Estamos definindo o valor da propriedade ImportTableOptions.CheckMergedCells como true, pois o documento do Excel contém células mescladas.

// Opening an existing Workbook.
Workbook workbook = new Workbook("SampleMergedTemplate.xlsx");
List<Product> productList = new List<Product>();

// Creating a collection of Products
for (int i = 0; i < 3; i++)
{
    Product product = new Product
    {
        ProductId = i,
        ProductName = "Test Product - " + i
    };
    productList.Add(product);
}

ImportTableOptions tableOptions = new ImportTableOptions();
// Set CheckMergedCells property to true
tableOptions.CheckMergedCells = true;
tableOptions.IsFieldNameShown = false;

//Export data to excel template (in second row, first column) 
workbook.Worksheets[0].Cells.ImportCustomObjects((ICollection)productList, 1, 0, tableOptions);
workbook.Save("SampleMergedTemplate_out.xlsx", SaveFormat.Xlsx);

public class Product
{
    public int ProductId { get; set; }

    public string ProductName { get; set; }
}

Copia linhas e colunas de um arquivo do Excel para outro em C

Podemos copiar linhas e colunas programaticamente de um documento do Excel para outro. Quando uma linha (ou coluna) é copiada, os dados contidos nela, incluindo fórmulas – com referências atualizadas – e valores, comentários, formatação, células ocultas, imagens e outros objetos de desenho também são copiados. Também podemos copiar linhas e colunas na mesma planilha ou em planilhas diferentes em um documento do Excel. Aspose.Cells fornece os seguintes métodos para copiar linhas e colunas.

• CopyRow(Cells sourceCells, int sourceRowIndex, int destinationRowIndex) Copies data of a single row.
• CopyRows(Cells sourceCells, int sourceRowIndex, int destinationRowIndex, int rowNumber) Copies data of multiple rows.
• CopyColumn(Cells sourceCells, int sourceColumnIndex, int destinationColumnIndex) Copies data of a single column.
• CopyColumns(Cells sourceCells, int sourceColumnIndex, int destinationColumnIndex, int columnNumber) Copies data of multiple columns.

O código de exemplo a seguir mostra como copiar linhas de um documento do Excel para outro em C#.

// Open the source excel file.
Workbook srcWorkbook = new Workbook("Source_Workbook.xlsx");

// Instantiate the destination excel file.
Workbook destWorkbook = new Workbook();

// Get the first worksheet of the source workbook.
Worksheet srcWorksheet = srcWorkbook.Worksheets[0];

// Get the first worksheet of the destination workbook.
Worksheet desWorksheet = destWorkbook.Worksheets[0];

// Copy all the rows of the first worksheet of source Workbook to
// the first worksheet of destination Workbook.
desWorksheet.Cells.CopyRows(srcWorksheet.Cells, 0, 0, srcWorksheet.Cells.MaxDisplayRange.RowCount);

// Save the excel file.
destWorkbook.Save("Destination_Workbook.xlsx");

O código de exemplo a seguir mostra como copiar linhas específicas de um documento do Excel para outro.

// Open the source excel file.
Workbook srcWorkbook = new Workbook("Source_Workbook.xlsx");

// Instantiate the destination excel file.
Workbook destWorkbook = new Workbook();

// Get the first worksheet of the source workbook.
Worksheet srcWorksheet = srcWorkbook.Worksheets[0];

// Get the first worksheet of the destination workbook.
Worksheet desWorksheet = destWorkbook.Worksheets[0];

// Copy the second row of the source Workbook to the first row of destination Workbook.
desWorksheet.Cells.CopyRow(srcWorksheet.Cells, 1, 0);

// Copy the fourth row of the source Workbook to the second row of destination Workbook.
desWorksheet.Cells.CopyRow(srcWorksheet.Cells, 3, 1);

// Save the excel file.
destWorkbook.Save("Destination_Workbook.xlsx");

Da mesma forma, podemos copiar os dados das colunas de um documento do Microsoft Excel para outro usando o método CopyColumn ou CopyColumns.

Exportar DataTable para Excel em C

Dados de objetos ADO.NET como DataTable, DataColumn e DataView podem ser exportados para planilhas do Excel. Para exportar dados de uma DataTable, chamamos o método ImportData da coleção Cells. Existem muitas versões sobrecarregadas do método ImportData, mas usamos o seguinte:

public int ImportData(
	DataTable table,
	int firstRow,
	int firstColumn,
	ImportTableOptions options
)

A descrição dos parâmetros é dada abaixo:

• table DataTable objeto a ser exportado.
• firstRow O número da linha da primeira célula para a qual exportar.
• firstColumn O número da coluna da primeira célula para a qual exportar.
• optionsType ImportTableOptions objeto.

No exemplo de código a seguir, estamos criando um objeto DataTable que tem três colunas e duas linhas. E exportando para uma planilha do Excel.

// Instantiating a Workbook object            
Workbook workbook = new Workbook();

// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];

// Instantiating a "Products" DataTable object
DataTable dataTable = new DataTable("Products");

// Adding columns to the DataTable object
dataTable.Columns.Add("Product ID", typeof(int));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(int));

// Creating an empty row in the DataTable object
DataRow dr = dataTable.NewRow();

// Adding data to the row
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;

// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);

// Creating another empty row in the DataTable object
dr = dataTable.NewRow();

// Adding data to the row
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;

// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);

// Setting IsFieldNameShown property to true will add column names // of the DataTable to the worksheet as a header row
ImportTableOptions tableOptions = new ImportTableOptions();
tableOptions.IsFieldNameShown = true;

// Exporting the contents of DataTable at the first row and first column.
worksheet.Cells.ImportData(dataTable, 0, 0, tableOptions);

// Saving the Excel file
workbook.Save("DataTable_Eport.xlsx");

Exportar dados de DataColumns seletivos para o Excel em C

Podemos exportar DataColumns seletivas de um DataTable ou DataView para um documento do Excel. Conforme discutido anteriormente, o método ImportData aceita um argumento do tipo ImportTableOptions. A classe ImportTableOptions tem uma propriedade ColumnIndexes que aceita uma matriz de índices de colunas (base zero) que queremos exportar. No exemplo de código a seguir, estamos exportando apenas dois DataColumns de um DataTable para uma planilha do Excel.

// Instantiating a "Products" DataTable object
DataTable dataTable = new DataTable("Products");

// Adding columns to the DataTable object
dataTable.Columns.Add("Product ID", typeof(int));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(int));

// Creating an empty row in the DataTable object
DataRow dr = dataTable.NewRow();

// Adding data to the row
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;

// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);

// Creating another empty row in the DataTable object
dr = dataTable.NewRow();

// Adding data to the row
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;

// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);

// Instantiate a new Workbook
Workbook book = new Workbook();

Worksheet sheet = book.Worksheets[0];

// Create export options
ImportTableOptions importOptions = new ImportTableOptions();
// Sets the columns (0-based) to export from data source.
// null means all columns should be exported.
importOptions.ColumnIndexes = new int[] { 0, 1 };
importOptions.IsFieldNameShown = true;

// Exporting the values of 1st and 2nd columns of the data table
sheet.Cells.ImportData(dataTable, 0, 0, importOptions);

book.Save("DataColumsExport.xlsx");

Exportar dados do DataView para o Excel em C#

Uma DataView é uma exibição em uma DataTable que pode ser personalizada para apresentar um subconjunto de dados da DataTable. Usamos a seguinte versão sobrecarregada do método ImportData para exportar dados do DataView para um documento do Excel.

public int ImportData(
	DataView dataView,
	int firstRow,
	int firstColumn,
	ImportTableOptions options
)

Sabemos que existem duas maneiras de criar um DataView. Podemos usar o construtor DataView, ou podemos criar uma referência à propriedade DefaultView do DataTable. No exemplo de código a seguir, estamos usando a maneira posterior de criar um DataView.

worksheet.Cells.ImportData(dataTable.DefaultView, 0, 0, options);

Exportar dados de DataGrid e GridView para Excel em C

A biblioteca Aspose.Cells nos permite exportar dados de controles do Microsoft Grid, como DataGrid e GridView, para uma planilha do Excel. Ele fornece o método ImportDataGrid para exportar dados de um DataGrid e o método ImportGridView para exportar dados de um GridView.

Existem muitas versões sobrecarregadas do método ImportDataGrid, mas uma sobrecarga típica usa os seguintes parâmetros:

• dataGrid, o objeto DataGrid do qual estamos exportando conteúdo.
• firstRow, o número da linha da primeira célula para a qual os dados serão exportados.
• firstColumn, o número da coluna da primeira célula para a qual os dados serão exportados.
• insertRows, uma propriedade booleana que indica se linhas extras devem ser adicionadas à planilha para ajustar os dados.
• importStyle, uma propriedade booleana que indica se o estilo de célula deve ser exportado.

O exemplo de código a seguir mostra como exportar dados do DataGrid para um arquivo do Excel em C#.

// Create a DataTable object and set it as the DataSource of the DataGrid.
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("Product ID", typeof(int));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(int));

DataRow dr = dataTable.NewRow();
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;
dataTable.Rows.Add(dr);

dr = dataTable.NewRow();
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;
dataTable.Rows.Add(dr);

// Now take care of DataGrid
DataGrid dg = new DataGrid();
dg.DataSource = dataTable;
dg.DataBind();

// We have a DataGrid object with some data in it.
// Lets export it to an Excel worksheet.

// Creat a new workbook
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Exporting the contents of the DataGrid to the worksheet
worksheet.Cells.ImportDataGrid(dg, 0, 0, false);

// Save it as Excel file
workbook.Save("ExportDataGrid.xlsx");

Exportar dados formatados em HTML para Excel em C

Aspose.Cells permite exportar dados formatados em HTML para uma planilha do Excel. A API analisa o texto formatado em HTML ao exportar dados e converte o HTML em valores de célula formatados. No código de exemplo a seguir, DataTable contém texto formatado em HTML e estamos exportando-o para um documento do Excel usando o método ImportData.

// Prepare a DataTable with some HTML formatted values
DataTable dataTable = new DataTable("Products");

dataTable.Columns.Add("Product ID", typeof(int));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(int));

DataRow dr = dataTable.NewRow();
dr[0] = 1;
// Make text italicize
dr[1] = "<i>Aniseed</i> Syrup";
dr[2] = 15;
dataTable.Rows.Add(dr);

dr = dataTable.NewRow();
dr[0] = 2;
// Make text bold
dr[1] = "<b>Boston Crab Meat</b>";
dr[2] = 123;
dataTable.Rows.Add(dr);

// Create export options
ImportTableOptions exportOptions = new ImportTableOptions();
exportOptions.IsFieldNameShown = true;
// Set IsHtmlString property to true as the data contains HTML tags. 
exportOptions.IsHtmlString = true;

// Create workbook
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

worksheet.Cells.ImportData(dataTable, 0, 0, exportOptions);

workbook.Save("HTMLFormattedData_Out.xlsx");

Exportar arquivo HTML para Excel em C

Aspose.Cells nos permite exportar um arquivo HTML para Excel. O arquivo HTML deve ser orientado ao Microsoft Excel, ou seja, o MS-Excel deve ser capaz de abri-lo.

// An HTML file
string filePath = "Book1.html";

// Instantiate LoadOptions specified by the LoadFormat.
HtmlLoadOptions loadOptions = new HtmlLoadOptions(LoadFormat.Html);

// Create a Workbook object and open the HTML file.
Workbook wb = new Workbook(filePath, loadOptions);

// Save the file as Excel Document
wb.Save("Book1_out.xlsx");

Exportar dados JSON para o Excel em C#

Às vezes, temos a necessidade de exportar dados JSON para um documento do Excel. Com Aspose.Cells podemos fazer isso facilmente com algumas linhas de código. Aspose.Cells fornece uma classe JsonUtility que possui um método ImportData para exportar dados JSON para um documento do Excel. O método ImportData aceita o objeto JsonLayoutOptions como parâmetro. A classe JsonLayoutOptions representa as opções de layout JSON e possui as seguintes propriedades.

• ArrayAsTable: Indicates whether the array should be processed as a table.
• ConvertNumericOrDate: Gets or sets a value that indicates whether the string in JSON is to be converted to numeric or date.
• DateFormat: Gets and sets the format of the date value.
• IgnoreArrayTitle: Indicates whether to ignore the title if the property of the object is an array.
• IgnoreNull: Indicates whether the null value should be ignored.
• IgnoreObjectTitle: Indicates whether to ignore the title if the property of the object is an object.
• NumberFormat: Gets and sets the format of the numeric value.
• TitleStyle: Gets and sets the style of the title.

No código de exemplo a seguir, estamos exportando dados JSON para um arquivo do Excel em C#.

// Instantiating a Workbook object
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Read JSON file
string jsonInput = File.ReadAllText("Sample.json");

// Set Styles
CellsFactory factory = new CellsFactory();
Style style = factory.CreateStyle();
style.HorizontalAlignment = TextAlignmentType.Center;
style.Font.Color = System.Drawing.Color.BlueViolet;
style.Font.IsBold = true;

// Set JsonLayoutOptions
JsonLayoutOptions options = new JsonLayoutOptions();
options.TitleStyle = style;
options.ArrayAsTable = true;

// Export JSON Data
JsonUtility.ImportData(jsonInput, worksheet.Cells, 0, 0, options);

// Save Excel file
workbook.Save("ExportingJsonData.xlsx");

{
  "quiz": {
    "sport": {
      "q1": {
        "question": "Which one is correct team name in NBA?",
        "answer": "Huston Rocket"
      }
    },
    "maths": {
      "q1": {
        "question": "5 + 7 = ?",
        "answer": "12"
      },
      "q2": {
        "question": "12 - 8 = ?",
        "answer": "4"
      }
    }
  }
}

Exportar dados CSV para o Excel em C#

Um arquivo de valores separados por vírgula (CSV) é um arquivo de texto delimitado que usa uma vírgula para separar valores. Um arquivo CSV normalmente armazena dados tabulares (números e texto) em texto simples, caso em que cada linha terá o mesmo número de campos.

O exemplo de código a seguir mostra como podemos abrir um arquivo CSV e salvá-lo como um arquivo do Excel usando a biblioteca Aspose.Cells.

// Instantiate LoadOptions with CSV LoadFormat.
LoadOptions loadOptions = new LoadOptions(LoadFormat.CSV);

// Open CSV file as a Workbook object
Workbook wb = new Workbook("Business-Price.csv", loadOptions);

// Save the file as an Excel Documnt
wb.Save("CSVAsAnExcelDocument.xlsx");

Conclusão

Neste post, você viu como é fácil exportar dados para o Excel em C# de Array, DataTable, DataView, DataGrid e GridView. Você também viu como exportar dados HTML, JSON, CSV para uma planilha do Excel. Verifique a documentação para saber mais sobre esses e vários outros recursos que a API Aspose.Cells oferece. Se você tiver alguma dúvida, não hesite em nos contatar através do nosso Fórum de Suporte.

Veja também

• Crie arquivos do MS Excel programaticamente em C# sem o MS Office
• Importar dados de JSON para planilha do Excel em C# .NET