Esporta dati in Excel in C#

In questo articolo, ti mostrerò come esportare i dati in Excel in C# e VB.NET da varie origini dati come un array, una raccolta di oggetti personalizzati, DataTable, DataView, DataGrid, GridView, HTML, JSON e CSV.

• Esporta matrice in Excel in C#
  • Esporta ArrayList in Excel
  • Esporta raccolta di oggetti personalizzati in Excel
• Copia righe e colonne da un file Excel a un altro
• Esporta DataTable in Excel in C#
  • Esporta i dati di colonne dati selettive in Excel
  • Esporta DataView in Excel
• Esporta i dati da DataGrid e GridView in Excel
• Esporta dati formattati HTML in Excel
  • Esporta file HTML in Excel
• Esporta dati JSON in Excel in C#
• Esporta dati CSV in Excel in C#

Esporta i dati in Excel in C# con l’API Aspose.Cells

Aspose.Cells for .NET è una potente API per la manipolazione di fogli di calcolo che ti consente di creare, modificare o convertire file Excel all’interno di applicazioni .NET. I metodi facili da usare dell’API consentono di eseguire le funzionalità di automazione di Excel senza problemi in poche righe di codice. NuGet è il modo più semplice per scaricare e installare API Aspose.Cells per .NET. Apri la finestra Gestisci pacchetti NuGet e digita “Aspose.Cells” nella casella di testo di ricerca per trovare il pacchetto Aspose.Cells .NET. Infine, fai clic sul pulsante Installa per installare l’ultima versione del pacchetto.

Esporta matrice in Excel in C#

Possiamo esportare una matrice (unidimensionale o bidimensionale) di un tipo di riferimento o di un tipo di valore in un documento Excel. Usiamo il metodo ImportArray della raccolta Cells per esportare i dati in un foglio di calcolo da un array. Le versioni sovraccaricate del metodo ImportArray sono le seguenti.

Un tipico sovraccarico richiede i seguenti parametri:

• Array, l’oggetto array da cui stai esportando il contenuto.
• Numero riga, il numero di riga della prima cella (a base zero) in cui verranno esportati i dati.
• Numero di colonna, il numero di colonna della prima cella (in base zero) in cui verranno esportati i dati.
• È verticale, un valore booleano che specifica se esportare i dati verticalmente o orizzontalmente.

Di seguito sono riportati i passaggi per esportare una matrice in un file Excel in C#.

• Crea un oggetto Cartella di lavoro. Una classe Cartella di lavoro rappresenta un file Microsoft Excel.
• Ottieni un riferimento al foglio di lavoro desiderato. La classe Workbook contiene una raccolta Worksheets che consente l’accesso a ciascun foglio di lavoro in un file Excel.
• Chiama il metodo ImportArray di una raccolta Cells per esportare una matrice nel foglio di lavoro nella riga e nella colonna specificate. La classe Worksheet fornisce una raccolta Cells.
• Salvare il file Excel utilizzando il metodo Workbook.Save(string).

Nell’esempio di codice seguente viene illustrato come esportare una matrice di String in un file di Excel in 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");

Allo stesso modo, possiamo esportare un array bidimensionale in un file Excel. Nell’esempio di codice seguente viene illustrato come esportare una matrice bidimensionale in un file di Excel in 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);

Esporta ArrayList in Excel in C#

Per esportare i dati da un ArrayList in un foglio di lavoro, chiama il metodo ImportArrayList della raccolta Cells. Il metodo ImportArrayList accetta i seguenti parametri:

• L’elenco di array rappresenta l’oggetto ArrayList che stai esportando.
• Il numero di riga rappresenta il numero di riga della prima cella in cui verranno esportati i dati.
• Il numero di colonna rappresenta il numero di colonna della prima cella in cui verranno esportati i dati.
• Vertical è un valore booleano che specifica se esportare i dati verticalmente o orizzontalmente.

L’esempio di codice seguente mostra come esportare un ArrayList in un file di Excel in 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");

Esporta raccolta di oggetti personalizzati in Excel in C#

Per esportare i dati da una raccolta di oggetti personalizzati in un foglio di lavoro, utilizziamo il metodo ImportCustomObjects. Esistono due versioni sovraccaricate di questo metodo.

1. ImportCustomObjects(ICollection list, String[] propertyNames, Boolean isPropertyNameShown, Int32 firstRow, Int32 firstColumn, Int32 rowNumber, Inserzioni booleane, String dateFormatString, Boolean convertStringToNumber)
2. ImportCustomObjects(ICollection list, Int32 firstRow, Int32 firstColumn, Opzioni ImportTableOptions)

Esploreremo ogni metodo sovraccaricato uno per uno. Di seguito la descrizione dei parametri del primo metodo di overload:

• list La raccolta degli oggetti personalizzati.
• propertyNames Nomi delle proprietà dell’oggetto da esportare. Se è nullo, tutte le proprietà verranno esportate.
• isPropertyNameShown Indica se i nomi delle proprietà verranno esportati nella prima riga.
• firstRow Il numero di riga della prima cella in cui esportare.
• firstColumn Il numero di colonna della prima cella in cui esportare.
• rowNumber Numero di oggetti da esportare.
• insertRows Indica se vengono aggiunte righe aggiuntive per adattare i dati.
• dateFormatString Stringa di formato data per le celle.
• convertStringToNumber Indica se questo metodo tenterà di convertire la stringa in un numero.

Nell’esempio seguente, stiamo esportando un elenco di oggetti Persona in un documento Excel in C#. Tieni presente che stiamo esportando solo due proprietà (Nome ed Età) di un oggetto Persona.

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

Ora esploriamo il secondo metodo sovraccaricato di ImportCustomObjects. Di seguito la descrizione dei parametri del metodo:

• list L’elenco degli oggetti personalizzati.
• firstRow Il numero di riga della prima cella in cui esportare.
• firstColumn Il numero di colonna della prima cella in cui esportare.
• opzioni ImportTableOptions oggetto.

Il parametro ImportTableOptions fornisce diverse opzioni per esportare i dati nelle celle. Alcuni di essi sono riportati di seguito:

• CheckMergedCells Un documento Excel contiene celle unite.
• ColumnIndexes Matrice intera di indici di colonna (basati su 0) da esportare dall’origine dati. null significa che tutte le colonne devono essere esportate.
• ConvertGridStyle Indica se applicare lo stile della visualizzazione griglia alle celle.
• ConvertNumericData Un valore booleano che indica se il valore della stringa deve essere convertito in valore numerico o data.
• DateFormat Ottiene o imposta la stringa di formato data per le celle con valori DateTime esportati.
• DefaultValues Il valore predefinito per la cella nella tabella è null.
• InsertRows Indica se devono essere aggiunte nuove righe per l’esportazione dei record di dati.
• IsFieldNameShown Indica se i nomi dei campi devono essere esportati.
• IsFormulas Indica se i dati sono formule.
• IsHtmlString Indica se i dati contengono tag HTML. Se impostiamo il valore su true, la formattazione HTML rimarrà conservata durante l’esportazione dei dati in un documento Excel.
• NumberFormats Ottiene o imposta i formati numerici
• ShiftFirstRowDown Indica se la prima riga deve essere spostata verso il basso durante l’inserimento di righe.
• TotalColumns Ottiene o imposta il conteggio totale delle colonne da esportare da un’origine dati. -1 indica tutte le colonne dell’origine dati specificata.
• TotalRows Ottiene o imposta il conteggio totale delle righe da esportare dall’origine dati. -1 indica tutte le righe dell’origine dati specificata.

Nell’esempio seguente, esportiamo i dati da una raccolta di oggetti in un foglio di lavoro contenente celle unite. Stiamo impostando il valore della proprietà ImportTableOptions.CheckMergedCells su true poiché il documento Excel contiene celle unite.

// 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 righe e colonne da un file Excel a un altro in C#

Possiamo copiare a livello di codice righe e colonne da un documento Excel a un altro. Quando una riga (o una colonna) viene copiata, vengono copiati anche i dati in essa contenuti, comprese le formule – con riferimenti aggiornati – e i valori, i commenti, la formattazione, le celle nascoste, le immagini e altri oggetti di disegno. Possiamo anche copiare righe e colonne all’interno dello stesso foglio di lavoro o su fogli di lavoro diversi in un documento Excel. Aspose.Cells fornisce i metodi seguenti per copiare righe e colonne.

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

Il codice di esempio seguente mostra come copiare righe da un documento di Excel a un altro in 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");

Il codice di esempio seguente mostra come copiare righe specifiche di un documento Excel in un altro.

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

Allo stesso modo, possiamo copiare i dati delle colonne da un documento Microsoft Excel a un altro utilizzando il metodo CopyColumn o CopyColumns.

Esporta DataTable in Excel in C#

I dati da oggetti ADO.NET come DataTable, DataColumn e DataView possono essere esportati in fogli di lavoro Excel. Per esportare i dati da un DataTable, chiamiamo il metodo ImportData di raccolta Cells. Esistono molte versioni sovraccaricate del metodo ImportData, ma utilizziamo quanto segue:

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

Di seguito la descrizione dei parametri:

• table DataTable oggetto da esportare.
• firstRow Il numero di riga della prima cella in cui esportare.
• firstColumn Il numero di colonna della prima cella in cui esportare.
• optionsType ImportTableOptions oggetto.

Nell’esempio di codice seguente viene creato un oggetto DataTable con tre colonne e due righe. Ed esportarlo in un foglio di lavoro 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");

Esporta i dati di colonne dati selettive in Excel in C#

Possiamo esportare DataColumns selettive di un DataTable o DataView in un documento Excel. Come discusso in precedenza, il metodo ImportData accetta un argomento di tipo ImportTableOptions. La classe ImportTableOptions ha una proprietà ColumnIndexes che accetta una matrice di indici di colonne (a base zero) che vogliamo esportare. Nell’esempio di codice seguente vengono esportati solo due DataColumns di un DataTable in un foglio di lavoro di 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");

Esporta dati da DataView in Excel in C#

Un DataView è una vista su un DataTable che può essere personalizzato per presentare un sottoinsieme di dati dal DataTable. Usiamo la seguente versione sovraccaricata del metodo ImportData per esportare i dati da DataView in un documento Excel.

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

Sappiamo che ci sono due modi per creare un DataView. Possiamo usare il costruttore DataView, oppure possiamo creare un riferimento alla proprietà DefaultView di DataTable. Nell’esempio di codice seguente viene utilizzato il modo successivo per creare un DataView.

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

Esporta i dati da DataGrid e GridView in Excel in C#

La libreria Aspose.Cells ci consente di esportare i dati dai controlli Microsoft Grid come DataGrid e GridView in un foglio di lavoro Excel. Fornisce il metodo ImportDataGrid, per esportare i dati da un DataGrid e il metodo ImportGridView per esportare i dati da un GridView.

Esistono molte versioni sovraccaricate del metodo ImportDataGrid, ma un sovraccarico tipico accetta i parametri seguenti:

• dataGrid, l’oggetto DataGrid da cui stiamo esportando il contenuto.
• firstRow, il numero di riga della prima cella in cui verranno esportati i dati.
• firstColumn, il numero di colonna della prima cella in cui verranno esportati i dati.
• insertRows, una proprietà booleana che indica se è necessario aggiungere righe aggiuntive al foglio di lavoro per adattare i dati.
• importStyle, una proprietà booleana che indica se lo stile della cella deve essere esportato.

L’esempio di codice seguente mostra come esportare dati da DataGrid in un file Excel in 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");

Esporta dati formattati HTML in Excel in C#

Aspose.Cells ti consente di esportare dati formattati HTML in un foglio di lavoro Excel. L’API analizza il testo formattato HTML durante l’esportazione dei dati e converte l’HTML in valori di celle formattati. Nel codice di esempio seguente, DataTable contiene testo formattato HTML e lo stiamo esportando in un documento Excel utilizzando il metodo 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");

Esporta file HTML in Excel in C#

Aspose.Cells ci consente di esportare un file HTML in Excel. Il file HTML dovrebbe essere orientato a Microsoft Excel, ovvero MS-Excel dovrebbe essere in grado di aprirlo.

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

Esporta dati JSON in Excel in C#

A volte abbiamo la necessità di esportare i dati JSON in un documento Excel. Con Aspose.Cells possiamo farlo facilmente con poche righe di codice. Aspose.Cells fornisce una classe JsonUtility che dispone di un metodo ImportData per esportare dati JSON in un documento Excel. Il metodo ImportData accetta l’oggetto JsonLayoutOptions come parametro. La classe JsonLayoutOptions rappresenta le opzioni del layout JSON e ha le seguenti proprietà.

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

Nel codice di esempio seguente, stiamo esportando i dati JSON in un file Excel in 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"
      }
    }
  }
}

Esporta dati CSV in Excel in C#

Un file con valori separati da virgole (CSV) è un file di testo delimitato che utilizza una virgola per separare i valori. Un file CSV in genere memorizza i dati tabulari (numeri e testo) in testo normale, nel qual caso ogni riga avrà lo stesso numero di campi.

L’esempio di codice seguente mostra come aprire un file CSV e salvarlo come file Excel utilizzando la libreria 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");

Conclusione

In questo post, hai visto con quanta facilità puoi esportare dati in Excel in C# da Array, DataTable, DataView, DataGrid e GridView. Hai anche visto come esportare dati HTML, JSON, CSV in un foglio di lavoro Excel. Si prega di controllare la documentazione per saperne di più su queste e molte altre funzionalità offerte dall’API Aspose.Cells. In caso di domande, non esitare a contattarci tramite il nostro Forum di supporto.

Guarda anche

• Crea file MS Excel a livello di codice in C# senza MS Office
• Importa dati da JSON a foglio di lavoro Excel in C# .NET