Gegevens exporteren naar Excel

In dit artikel laten we u zien hoe u gegevens exporteert naar Excel in C# en VB.NET vanuit verschillende gegevensbronnen, zoals een array, verzameling aangepaste objecten, DataTable, DataView, DataGrid, GridView, HTML, JSON en CSV.

  • [Array exporteren naar Excel in C#][1]
  • [ArrayList exporteren naar Excel][2]
  • [Exporteer verzameling aangepaste objecten naar Excel][3]
  • [Kopieer rijen en kolommen van het ene Excel-bestand naar het andere][4]
  • [Datatabel exporteren naar Excel in C#][5]
  • [Exporteer gegevens van selectieve gegevenskolommen naar Excel][6]
  • [DataView exporteren naar Excel][7]
  • [Gegevens exporteren van DataGrid en GridView naar Excel][8]
  • [Exporteer in HTML opgemaakte gegevens naar Excel][9]
  • [HTML-bestand exporteren naar Excel][10]
  • [JSON-gegevens exporteren naar Excel in C#][11]
  • [CSV-gegevens exporteren naar Excel in C#][12]

Exporteer gegevens naar Excel in C# met Aspose.Cells API

[Aspose.Cells for .NET][13] is een krachtige API voor het manipuleren van spreadsheets waarmee u Excel-bestanden kunt maken, bewerken of converteren binnen .NET-toepassingen. De gebruiksvriendelijke methoden van de API stellen u in staat om Excel-automatiseringsfuncties naadloos uit te voeren in een paar regels code. NuGet is de eenvoudigste manier om [Aspose.Cells API for .NET][14] te downloaden en te installeren. Open het venster NuGet-pakketten beheren en typ “Aspose.Cells” in het zoektekstvak om het Aspose.Cells .NET-pakket te vinden. Klik ten slotte op de knop Installeren om de nieuwste versie van het pakket te installeren.

C# Exportarray naar Excel - Korte zelfstudie

We kunnen een array (eendimensionaal of tweedimensionaal) van een referentietype of waardetype exporteren naar een Excel-document. We gebruiken de methode [ImportArray][15] van de verzameling [Cells][16] om gegevens vanuit een array naar een spreadsheet te exporteren. De overbelaste versies van de methode [ImportArray][15] zijn de volgende.

NaamBeschrijving
ImportArray(Double[], Int32, Int32, Boolean)Exporteert een array van double naar een werkblad.
ImportArray(Int32[], Int32, Int32, Boolean)Exporteert een array van een geheel getal naar een werkblad.
ImportArray(String[], Int32, Int32, Boolean)Exporteert een reeks tekenreeksen naar een werkblad.
ImportArray(Double[,], Int32, Int32)Exporteert een tweedimensionale array van double naar een werkblad.
ImportArray(Int32[,], Int32, Int32)Exporteert een tweedimensionale matrix van een geheel getal naar een werkblad.
ImportArray(String[,], Int32, Int32)Exporteert een tweedimensionale stringreeks naar een werkblad.
Een typische overbelasting heeft de volgende parameters:
  • Array, het array-object waaruit u inhoud exporteert.
  • Rijnummer, het rijnummer van de eerste cel (op basis van nul) waarnaar de gegevens worden geëxporteerd.
  • Kolomnummer, het kolomnummer van de eerste cel (op basis van nul) waarnaar de gegevens worden geëxporteerd.
  • Is verticaal, een Booleaanse waarde die aangeeft of gegevens verticaal of horizontaal moeten worden geëxporteerd. Hieronder volgen de stappen om een array naar een Excel-bestand in C# te exporteren.
  1. Maak een [Werkboek][17]-object. Een klasse [Werkmap][17] vertegenwoordigt een Microsoft Excel-bestand.
  2. Krijg een verwijzing naar het gewenste werkblad. De klasse [Werkmap][17] bevat een verzameling [Werkbladen][18] die toegang geeft tot elk werkblad in een Excel-bestand.
  3. Roep de methode [ImportArray][19] van een verzameling [Cells][16] aan om een array te exporteren naar het werkblad in de opgegeven rij en kolom. De klasse [Worksheet][20] biedt een verzameling [Cells][16].
  4. Sla het Excel-bestand op met de methode [Workbook.Save(string)][21]. Het volgende codevoorbeeld laat zien hoe u een reeks String naar een Excel-bestand in C# exporteert.
// 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");
Stringarray exporteren naar Excel

Exporteer een reeks gegevens naar Excel

Op dezelfde manier kunnen we een tweedimensionale array exporteren naar een Excel-bestand. Het volgende codevoorbeeld laat zien hoe u een tweedimensionale matrix exporteert naar een Excel-bestand 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);

C# Exporteer ArrayList naar Excel

Roep de methode [ImportArrayList][22] van de verzameling [Cells][16] aan om gegevens van een ArrayList naar een werkblad te exporteren. De methode [ImportArrayList][22] gebruikt de volgende parameters:

  • Array-lijst vertegenwoordigt het ArrayList-object dat u exporteert.
  • Rij getal staat voor het rijnummer van de eerste cel waarnaar de gegevens worden geëxporteerd.
  • Kolomnummer staat voor het kolomnummer van de eerste cel waarnaar de gegevens worden geëxporteerd.
  • Is verticaal een Booleaanse waarde die aangeeft of gegevens verticaal of horizontaal moeten worden geëxporteerd. Het volgende codevoorbeeld laat zien hoe u een ArrayList exporteert naar een Excel-bestand 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");

C# Verzameling van aangepaste objecten exporteren naar Excel

Om gegevens uit een verzameling aangepaste objecten naar een werkblad te exporteren, gebruiken we de methode [ImportCustomObjects][23]. Er zijn twee overbelaste versies van deze methode.

  1. [ImportCustomObjects(ICollection list, String[] propertyNames, Boolean isPropertyNameShown, Int32 firstRow, Int32 firstColumn, Int32 rowNumber, Boolean insertions, String dateFormatString, Boolean convertStringToNumber)][24]
  2. [ImportCustomObjects(ICollection-lijst, Int32 firstRow, Int32 firstColumn, ImportTableOptions-opties)][25] We zullen elke overbelaste methode één voor één onderzoeken. De beschrijving van de parameters van de eerste overbelaste methode wordt hieronder gegeven:
  • lijst De verzameling aangepaste objecten.
  • propertyNames Namen van eigenschappen van het te exporteren object. Als het null is, worden alle eigenschappen geëxporteerd.
  • isPropertyNameShown Geeft aan of de eigenschapsnamen naar de eerste rij worden geëxporteerd.
  • firstRow Het rijnummer van de eerste cel waarnaar geëxporteerd moet worden.
  • firstColumn Het kolomnummer van de eerste cel waarnaar geëxporteerd moet worden.
  • rowNumber Aantal te exporteren objecten.
  • insertRows Geeft aan of extra rijen zijn toegevoegd om gegevens te laten passen.
  • dateFormatString Tekenreeks voor datumnotatie voor cellen.
  • convertStringToNumber Geeft aan of deze methode probeert een tekenreeks naar een getal te converteren. In het volgende voorbeeld exporteren we een lijst met Person-objecten naar een Excel-document in C#. Houd er rekening mee dat we slechts twee eigenschappen (Name en Age) van een Person-object exporteren.
// 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;
    }
}
Lijst met objecten exporteren naar Excel

Exporteer een lijst met persoonsobjecten naar Excel

Nu verkennen we de tweede overbelaste methode van [ImportCustomObjects][23]. De beschrijving van de parameters van de methode wordt hieronder gegeven:

  • lijst De lijst met aangepaste objecten.
  • firstRow Het rijnummer van de eerste cel waarnaar geëxporteerd moet worden.
  • firstColumn Het kolomnummer van de eerste cel waarnaar geëxporteerd moet worden.
  • opties [ImportTableOptions][26] object. De parameter [ImportTableOptions][26] biedt verschillende opties voor het exporteren van gegevens naar cellen. Sommigen van hen worden hieronder gegeven:
  • CheckMergedCells Bevat een Excel-document samengevoegde cellen.
  • ColumnIndexes Integer-array van kolomindexen (0-gebaseerd) om uit de gegevensbron te exporteren. null betekent dat alle kolommen moeten worden geëxporteerd.
  • ConvertGridStyle Geeft aan of de stijl van de rasterweergave op cellen moet worden toegepast.
  • ConvertNumericData Een booleaanse waarde die aangeeft of de tekenreekswaarde moet worden geconverteerd naar een numerieke of datumwaarde.
  • DateFormat Hiermee wordt een tekenreeks voor de datumnotatie opgehaald of ingesteld voor cellen met geëxporteerde DateTime-waarden.
  • DefaultValues De standaardwaarde voor de cel in de tabel is null.
  • InsertRows Geeft aan of er nieuwe rijen moeten worden toegevoegd voor het exporteren van gegevensrecords.
  • IsFieldNameShown Geeft aan of de veldnamen moeten worden geëxporteerd.
  • IsFormulas Geeft aan of de gegevens formules zijn.
  • IsHtmlString Geeft aan of de gegevens HTML-tags bevatten. Als we de waarde instellen op true, blijft de HTML-opmaak behouden tijdens het exporteren van gegevens naar een Excel-document.
  • NumberFormats Haalt of stelt de getalnotaties in
  • ShiftFirstRowDown Geeft aan of de eerste rij omlaag moet worden geschoven bij het invoegen van rijen.
  • TotalColumns Hiermee wordt het totale aantal kolommen opgehaald of ingesteld om te exporteren vanuit een gegevensbron. -1 betekent alle kolommen van de gegeven gegevensbron.
  • TotalRows Haalt het totale aantal rijen op of stelt het in om te exporteren vanuit de gegevensbron. -1 betekent alle rijen van de gegeven gegevensbron. In het volgende voorbeeld exporteren we gegevens uit een verzameling objecten naar een werkblad met samengevoegde cellen. We stellen de waarde van de eigenschap [ImportTableOptions.CheckMergedCells][27] in op true omdat het Excel-document samengevoegde cellen bevat.
// 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; }
}
Exporteer gegevens uit een verzameling objecten naar een werkblad met samengevoegde cellen

Gegevens exporteren naar een Excel-document met samengevoegde cellen

C# Kopieert rijen en kolommen van het ene Excel-bestand naar het andere

We kunnen rijen en kolommen programmatisch kopiëren van het ene Excel-document naar het andere. Wanneer een rij (of kolom) wordt gekopieerd, worden de gegevens erin, inclusief formules – met bijgewerkte verwijzingen – en waarden, opmerkingen, opmaak, verborgen cellen, afbeeldingen en andere tekenobjecten ook gekopieerd. We kunnen ook rijen en kolommen kopiëren binnen hetzelfde werkblad of tussen verschillende werkbladen in een Excel-document. Aspose.Cells biedt de volgende methoden om rijen en kolommen te kopiëren.

  • [CopyRow(Cells sourceCells, int sourceRowIndex, int destinationRowIndex)][28] Kopieert gegevens van een enkele rij.
  • [CopyRows(Cells sourceCells, int sourceRowIndex, int destinationRowIndex, int rowNumber)][29] Kopieert gegevens van meerdere rijen.
  • [CopyColumn(Cells sourceCells, int sourceColumnIndex, int destinationColumnIndex)][30] Kopieert gegevens van een enkele kolom.
  • [CopyColumns(Cells sourceCells, int sourceColumnIndex, int destinationColumnIndex, int columnNumber)][31] Kopieert gegevens van meerdere kolommen. De volgende voorbeeldcode laat zien hoe u rijen van het ene Excel-document naar het andere kopieert 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");

De volgende voorbeeldcode laat zien hoe specifieke rijen van het ene Excel-document naar het andere kunnen worden gekopieerd.

// 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");
Kopieert rijgegevens van het ene Excel-document naar het andere

We kunnen op dezelfde manier kolomgegevens kopiëren van het ene Microsoft Excel-document naar het andere met de methode [CopyColumn][30] of [CopyColumns][31].

C# Gegevenstabel exporteren naar Excel

Gegevens van ADO.NET-objecten zoals [DataTable][32], [DataColumn][33] en [DataView][34] kunnen worden geëxporteerd naar Excel-werkbladen. Om gegevens uit een DataTable te exporteren, noemen we de [ImportData][35]-methode van Cells-verzameling. Er zijn veel overbelaste versies van de methode [ImportData][36], maar we gebruiken de volgende:

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

De beschrijving van de parameters wordt hieronder gegeven:

  • tabel DataTable object dat moet worden geëxporteerd.
  • firstRow Het rijnummer van de eerste cel waarnaar geëxporteerd moet worden.
  • firstColumn Het kolomnummer van de eerste cel waarnaar geëxporteerd moet worden.
  • optionsType [ImportTableOptions][26] object. In het volgende codevoorbeeld maken we een DataTable-object met drie kolommen en twee rijen. En exporteren naar een Excel-werkblad.
// 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");
Gegevenstabel exporteren naar Excel

Gegevenstabel exporteren naar Excel

Gegevens van selectieve gegevenskolommen exporteren naar Excel in C#

We kunnen selectieve DataColumns van een DataTable of DataView exporteren naar een Excel-document. Zoals eerder besproken, accepteert de methode [ImportData][35] een argument van het type [ImportTableOptions][37]. De klasse [ImportTableOptions][37] heeft een eigenschap [ColumnIndexes][38] die een reeks kolomindexen (op nul gebaseerd) accepteert die we willen exporteren. In het volgende codevoorbeeld exporteren we slechts twee gegevenskolommen van een gegevenstabel naar een Excel-werkblad.

// 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");
Gegevens van selectieve gegevenskolommen exporteren naar Excel

De uitvoer van DataColumns naar Excel

Gegevens exporteren van DataView naar Excel in C#

Een [DataView][39] is een weergave op een DataTable die kan worden aangepast om een subset van gegevens uit de DataTable weer te geven. We gebruiken de volgende overbelaste versie van de methode [ImportData][36] om gegevens uit DataView naar een Excel-document te exporteren.

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

We weten dat er twee manieren zijn om een [DataView][40] te maken. We kunnen de constructor DataView gebruiken, of we kunnen een verwijzing maken naar de eigenschap [DefaultView][41] van de [DataTable][42]. In het volgende codevoorbeeld gebruiken we de latere manier om een DataView te maken.

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

Exporteer gegevens van DataGrid en GridView naar Excel in C#

Met de [Aspose.Cells][43]-bibliotheek kunnen we gegevens van Microsoft Grid-besturingselementen zoals DataGrid en GridView exporteren naar een Excel-werkblad. Het biedt de methode [ImportDataGrid][44] om gegevens uit een DataGrid te exporteren en de methode [ImportGridView][45] om gegevens uit een GridView te exporteren. Er zijn veel overbelaste versies van de methode [ImportDataGrid][44], maar voor een typische overbelasting zijn de volgende parameters vereist:

  • dataGrid, het DataGrid-object waaruit we inhoud exporteren.
  • firstRow, het rijnummer van de eerste cel waarnaar de gegevens worden geëxporteerd.
  • firstColumn, het kolomnummer van de eerste cel waarnaar de gegevens worden geëxporteerd.
  • insertRows, een Booleaanse eigenschap die aangeeft of er extra rijen aan het werkblad moeten worden toegevoegd om de gegevens erin te laten passen.
  • importStyle, een Booleaanse eigenschap die aangeeft of de celstijl moet worden geëxporteerd. Het volgende codevoorbeeld laat zien hoe u gegevens uit DataGrid exporteert naar een Excel-bestand 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");

Exporteer in HTML opgemaakte gegevens naar Excel in C#

Met [Aspose.Cells][46] kunt u gegevens in HTML-indeling exporteren naar een Excel-werkblad. De API ontleedt HTML-opgemaakte tekst tijdens het exporteren van gegevens en zet de HTML om in opgemaakte celwaarden. In de volgende voorbeeldcode bevat DataTable tekst in HTML-opmaak en we exporteren deze naar een Excel-document met de methode [ImportData][35].

// 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");
HTML-geformatteerde gegevens naar een spreadsheet

De uitvoer van HTML-geëxporteerde gegevens naar een Excel-document

Exporteer HTML-bestand naar Excel in C#

Met Aspose.Cells kunnen we een HTML-bestand exporteren naar Excel. Het HTML-bestand moet Microsoft Excel-georiënteerd zijn, dat wil zeggen dat MS-Excel het moet kunnen openen.

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

Exporteer JSON-gegevens naar Excel in C#

Soms hebben we de behoefte om JSON-gegevens naar een Excel-document te exporteren. Met [Aspose.Cells][46] kunnen we dit eenvoudig doen met een paar regels code. Aspose.Cells biedt een [JsonUtility][47]-klasse met een [ImportData][48]-methode voor het exporteren van JSON-gegevens naar een Excel-document. De methode [ImportData][48] accepteert het object [JsonLayoutOptions][49] als parameter. De klasse [JsonLayoutOptions][49] vertegenwoordigt de opties van JSON-lay-out en heeft de volgende eigenschappen.

  • [ArrayAsTable][50]: Indicates whether the array should be processed as a table.
  • [ConvertNumericOrDate][51]: Gets or sets a value that indicates whether the string in JSON is to be converted to numeric or date.
  • [DateFormat][52]: Gets and sets the format of the date value.
  • [IgnoreArrayTitle][53]: Indicates whether to ignore the title if the property of the object is an array.
  • [IgnoreNull][54]: Indicates whether the null value should be ignored.
  • [IgnoreObjectTitle][55]: Indicates whether to ignore the title if the property of the object is an object.
  • [NumberFormat][56]: Gets and sets the format of the numeric value.
  • [TitleStyle][57]: Gets and sets the style of the title. In de volgende voorbeeldcode exporteren we JSON-gegevens naar een Excel-bestand 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"
      }
    }
  }
}
JSON-gegevens naar een Excel-document

Exporteer JSON-gegevens naar Excel

Exporteer CSV-gegevens naar Excel in C#

Een bestand met door komma’s gescheiden waarden (CSV) is een tekstbestand met scheidingstekens waarin een komma wordt gebruikt om waarden te scheiden. Een CSV-bestand slaat doorgaans tabelgegevens (cijfers en tekst) op in platte tekst, in welk geval elke regel hetzelfde aantal velden heeft. Het volgende codevoorbeeld laat zien hoe we een CSV-bestand kunnen openen en opslaan als een Excel-bestand met de Aspose.Cells-bibliotheek.

// 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");
Open een CSV-bestand in een spreadsheetdocument

CSV naar een Excel-document

Conclusie

In dit bericht heb je gezien hoe gemakkelijk je gegevens naar Excel in C# kunt exporteren vanuit Array, DataTable, DataView, DataGrid en GridView. U hebt ook gezien hoe u HTML-, JSON- en CSV-gegevens exporteert naar een Excel-werkblad. Raadpleeg de [documentatie][46] voor meer informatie over deze en verschillende andere functies die Aspose.Cells API biedt. Als je vragen hebt, neem dan gerust contact met ons op via ons [Ondersteuningsforum][58].

Zie ook