In diesem Artikel zeige ich Ihnen, wie Sie Daten aus verschiedenen Datenquellen wie einem Array, einer Sammlung benutzerdefinierter Objekte, DataTable, DataView, DataGrid, GridView, HTML, JSON und CSV nach Excel in C# und VB.NET exportieren.
- Array in C# nach Excel exportieren
- Kopieren Sie Zeilen und Spalten von einer Excel-Datei in eine andere
- DataTable nach Excel in C# exportieren
- Exportieren Sie Daten aus DataGrid und GridView nach Excel
- Exportieren Sie HTML-formatierte Daten nach Excel
- Exportieren Sie JSON-Daten nach Excel in C#
- CSV-Daten nach Excel in C# exportieren
Exportieren Sie Daten nach Excel in C# mit der Aspose.Cells-API
Aspose.Cells for .NET ist eine leistungsstarke API zur Bearbeitung von Tabellenkalkulationen, mit der Sie Excel-Dateien in .NET-Anwendungen erstellen, bearbeiten oder konvertieren können. Die benutzerfreundlichen Methoden der API ermöglichen es Ihnen, Excel-Automatisierungsfunktionen nahtlos in wenigen Codezeilen auszuführen. NuGet ist der einfachste Weg, Aspose.Cells API for .NET herunterzuladen und zu installieren. Öffnen Sie das Fenster NuGet-Pakete verwalten und geben Sie „Aspose.Cells“ in das Suchtextfeld ein, um das .NET-Paket Aspose.Cells zu finden. Klicken Sie abschließend auf die Schaltfläche Installieren, um die neueste Version des Pakets zu installieren.
Array in C# nach Excel exportieren
Wir können ein Array (eindimensional oder zweidimensional) eines Referenztyps oder Werttyps in ein Excel-Dokument exportieren. Wir verwenden die Methode ImportArray der Sammlung Cells, um Daten aus einem Array in eine Tabelle zu exportieren. Die überladenen Versionen der Methode ImportArray sind die folgenden.
Name | Beschreibung |
---|---|
ImportArray(Double[], Int32, Int32, Boolean) | Exportiert ein Array von Double in ein Arbeitsblatt. |
ImportArray(Int32[], Int32, Int32, Boolean) | Exportiert ein Array einer ganzen Zahl in ein Arbeitsblatt. |
ImportArray(String[], Int32, Int32, Boolean) | Exportiert ein String-Array in ein Arbeitsblatt. |
ImportArray(Double[,], Int32, Int32) | Exportiert ein zweidimensionales Array von double in ein Arbeitsblatt. |
ImportArray(Int32[,], Int32, Int32) | Exportiert ein zweidimensionales Array einer ganzen Zahl in ein Arbeitsblatt. |
ImportArray(String[,], Int32, Int32) | Exportiert ein zweidimensionales String-Array in ein Arbeitsblatt. |
Eine typische Überlastung nimmt die folgenden Parameter an:
- Array, das Array-Objekt, aus dem Sie Inhalte exportieren.
- Zeilennummer, die Zeilennummer der ersten Zelle (nullbasiert), in die die Daten exportiert werden.
- Spaltennummer, die Spaltennummer der ersten Zelle (nullbasiert), in die die Daten exportiert werden.
- Ist vertikal, ein boolescher Wert, der angibt, ob Daten vertikal oder horizontal exportiert werden.
Im Folgenden sind die Schritte zum Exportieren eines Arrays in eine Excel-Datei in C# aufgeführt.
- Erstellen Sie ein Workbook-Objekt. Eine Workbook-Klasse repräsentiert eine Microsoft Excel-Datei.
- Holen Sie sich einen Verweis auf das gewünschte Arbeitsblatt. Die Klasse Workbook enthält eine Sammlung Worksheets, die den Zugriff auf jedes Arbeitsblatt in einer Excel-Datei ermöglicht.
- Rufen Sie die Methode ImportArray einer Sammlung Cells auf, um ein Array in das Arbeitsblatt in der angegebenen Zeile und Spalte zu exportieren. Die Klasse Worksheet stellt eine Sammlung Cells bereit.
- Speichern Sie die Excel-Datei mit der Methode Workbook.Save(string).
Das folgende Codebeispiel zeigt, wie ein String-Array in eine Excel-Datei in C# exportiert wird.
// 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");
Ebenso können wir ein zweidimensionales Array in eine Excel-Datei exportieren. Das folgende Codebeispiel zeigt, wie ein zweidimensionales Array in eine Excel-Datei in C# exportiert wird.
// 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);
ArrayList nach Excel in C# exportieren
Um Daten aus einer ArrayList in ein Arbeitsblatt zu exportieren, rufen Sie die Methode ImportArrayList der Sammlung Cells auf. Die Methode ImportArrayList akzeptiert die folgenden Parameter:
- Die Array-Liste stellt das ArrayList-Objekt dar, das Sie exportieren.
- Die Zeilennummer stellt die Zeilennummer der ersten Zelle dar, in die die Daten exportiert werden.
- Die Spaltennummer stellt die Spaltennummer der ersten Zelle dar, in die die Daten exportiert werden.
- Ist vertikal ein boolescher Wert, der angibt, ob Daten vertikal oder horizontal exportiert werden.
Das folgende Codebeispiel zeigt, wie eine ArrayList in eine Excel-Datei in C# exportiert wird.
// 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");
Sammlung von benutzerdefinierten Objekten nach Excel in C# exportieren
Um Daten aus einer Sammlung benutzerdefinierter Objekte in ein Arbeitsblatt zu exportieren, verwenden wir die Methode ImportCustomObjects. Es gibt zwei überladene Versionen dieser Methode.
- ImportCustomObjects(ICollection list, String[] propertyNames, Boolean isPropertyNameShown, Int32 firstRow, Int32 firstColumn, Int32 rowNumber, Boolesche Einfügungen, String dateFormatString, Boolean convertStringToNumber)
- ImportCustomObjects(ICollection list, Int32 firstRow, Int32 firstColumn, ImportTableOptions options)
Wir werden jede überladene Methode einzeln untersuchen. Die Beschreibung der Parameter der ersten überladenen Methode ist unten angegeben:
- list Die Sammlung der benutzerdefinierten Objekte.
- propertyNames Namen von Eigenschaften des zu exportierenden Objekts. Wenn es null ist, werden alle Eigenschaften exportiert.
- isPropertyNameShown Gibt an, ob die Eigenschaftsnamen in die erste Zeile exportiert werden.
- firstRow Die Zeilennummer der ersten Zelle, in die exportiert werden soll.
- firstColumn Die Spaltennummer der ersten Zelle, in die exportiert werden soll.
- rowNumber Anzahl der zu exportierenden Objekte.
- insertRows Gibt an, ob zusätzliche Zeilen hinzugefügt werden, um Daten anzupassen.
- dateFormatString Datumsformatzeichenfolge für Zellen.
- convertStringToNumber Gibt an, ob diese Methode versucht, eine Zeichenfolge in eine Zahl umzuwandeln.
Im folgenden Beispiel exportieren wir eine Liste von Person-Objekten in ein Excel-Dokument in C#. Bitte beachten Sie, dass wir nur zwei Eigenschaften (Name und Alter) eines Personenobjekts exportieren.
// 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;
}
}
Jetzt untersuchen wir die zweite überladene Methode von ImportCustomObjects. Die Beschreibung der Parameter der Methode ist unten angegeben:
- list Die Liste der benutzerdefinierten Objekte.
- firstRow Die Zeilennummer der ersten Zelle, in die exportiert werden soll.
- firstColumn Die Spaltennummer der ersten Zelle, in die exportiert werden soll.
- options ImportTableOptions-Objekt.
Der Parameter ImportTableOptions bietet mehrere Optionen zum Exportieren von Daten in Zellen. Einige von ihnen sind unten aufgeführt:
- CheckMergedCells Enthält ein Excel-Dokument verbundene Zellen.
- ColumnIndexes Ganzzahliges Array von Spaltenindizes (0-basiert), die aus der Datenquelle exportiert werden sollen. null bedeutet, dass alle Spalten exportiert werden sollen.
- ConvertGridStyle Gibt an, ob der Stil der Rasteransicht auf Zellen angewendet werden soll.
- ConvertNumericData Ein boolescher Wert, der angibt, ob der Zeichenfolgenwert in einen numerischen Wert oder einen Datumswert konvertiert werden soll.
- DateFormat Ruft Datumsformatzeichenfolgen für Zellen mit exportierten DateTime-Werten ab oder legt diese fest.
- DefaultValues Der Standardwert für die Zelle in der Tabelle ist null.
- InsertRows Gibt an, ob beim Exportieren von Datensätzen neue Zeilen hinzugefügt werden sollen.
- IsFieldNameShown Gibt an, ob die Feldnamen exportiert werden sollen.
- IsFormulas Gibt an, ob es sich bei den Daten um Formeln handelt.
- IsHtmlString Gibt an, ob die Daten HTML-Tags enthalten. Wenn wir den Wert auf true setzen, bleibt die HTML-Formatierung beim Exportieren von Daten in ein Excel-Dokument erhalten.
- NumberFormats Ruft die Zahlenformate ab oder legt sie fest
- ShiftFirstRowDown Gibt an, ob die erste Zeile beim Einfügen von Zeilen nach unten verschoben werden soll.
- TotalColumns Ruft die Gesamtzahl der Spalten ab, die aus einer Datenquelle exportiert werden sollen, oder legt sie fest. -1 bedeutet alle Spalten der angegebenen Datenquelle.
- TotalRows Ruft die Gesamtzeilenanzahl ab oder legt sie fest, die aus der Datenquelle exportiert werden soll. -1 bedeutet alle Zeilen der angegebenen Datenquelle.
Im folgenden Beispiel exportieren wir Daten aus einer Sammlung von Objekten in ein Arbeitsblatt, das verbundene Zellen enthält. Wir setzen den Wert der Eigenschaft ImportTableOptions.CheckMergedCells auf „true“, da das Excel-Dokument verbundene Zellen enthält.
// 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; }
}
Kopiert Zeilen und Spalten von einer Excel-Datei in eine andere in C#
Wir können Zeilen und Spalten programmgesteuert von einem Excel-Dokument in ein anderes kopieren. Wenn eine Zeile (oder Spalte) kopiert wird, werden die darin enthaltenen Daten einschließlich Formeln – mit aktualisierten Verweisen – und Werte, Kommentare, Formatierungen, ausgeblendete Zellen, Bilder und andere Zeichnungsobjekte ebenfalls kopiert. Wir können auch Zeilen und Spalten innerhalb desselben Arbeitsblatts oder über verschiedene Arbeitsblätter in einem Excel-Dokument kopieren. Aspose.Cells bietet die folgenden Methoden zum Kopieren von Zeilen und Spalten.
- 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.
Der folgende Beispielcode zeigt, wie Zeilen aus einem Excel-Dokument in ein anderes in C# kopiert werden.
// 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");
Der folgende Beispielcode zeigt, wie bestimmte Zeilen eines Excel-Dokuments in ein anderes kopiert werden.
// 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");
Auf ähnliche Weise können wir Spaltendaten von einem Microsoft Excel-Dokument in ein anderes kopieren, indem wir die Methode CopyColumn oder CopyColumns verwenden.
DataTable nach Excel in C# exportieren
Daten aus ADO.NET-Objekten wie DataTable, DataColumn und DataView können in Excel-Arbeitsblätter exportiert werden. Um Daten aus einer DataTable zu exportieren, rufen wir die Methode ImportData der Cells-Sammlung auf. Es gibt viele überladene Versionen der Methode ImportData, aber wir verwenden Folgendes:
public int ImportData(
DataTable table,
int firstRow,
int firstColumn,
ImportTableOptions options
)
Die Beschreibung der Parameter ist unten angegeben:
- table DataTable zu exportierendes Objekt.
- firstRow Die Zeilennummer der ersten Zelle, in die exportiert werden soll.
- firstColumn Die Spaltennummer der ersten Zelle, in die exportiert werden soll.
- optionsType ImportTableOptions-Objekt.
Im folgenden Codebeispiel erstellen wir ein DataTable-Objekt mit drei Spalten und zwei Zeilen. Und in ein Excel-Arbeitsblatt exportieren.
// 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");
Exportieren Sie Daten ausgewählter Datenspalten nach Excel in C#
Wir können ausgewählte DataColumns einer DataTable oder DataView in ein Excel-Dokument exportieren. Wie bereits erwähnt, akzeptiert die Methode ImportData ein Argument des Typs ImportTableOptions. Die Klasse ImportTableOptions hat eine Eigenschaft ColumnIndexes, die ein Array von Spaltenindizes (nullbasiert) akzeptiert, die wir exportieren möchten. Im folgenden Codebeispiel exportieren wir nur zwei DataColumns einer DataTable in ein Excel-Arbeitsblatt.
// 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");
Exportieren Sie Daten aus DataView nach Excel in C#
Ein DataView ist eine Ansicht einer DataTable, die angepasst werden kann, um eine Teilmenge von Daten aus der DataTable darzustellen. Wir verwenden die folgende überladene Version der Methode ImportData, um Daten aus DataView in ein Excel-Dokument zu exportieren.
public int ImportData(
DataView dataView,
int firstRow,
int firstColumn,
ImportTableOptions options
)
Wir wissen, dass es zwei Möglichkeiten gibt, eine DataView zu erstellen. Wir können den DataView-Konstruktor verwenden oder einen Verweis auf die Eigenschaft DefaultView der DataTable erstellen. Im folgenden Codebeispiel verwenden wir die spätere Methode zum Erstellen einer DataView.
worksheet.Cells.ImportData(dataTable.DefaultView, 0, 0, options);
Exportieren Sie Daten aus DataGrid und GridView nach Excel in C#
Die Bibliothek Aspose.Cells ermöglicht es uns, Daten aus Microsoft Grid-Steuerelementen wie DataGrid und GridView in ein Excel-Arbeitsblatt zu exportieren. Es bietet die Methode ImportDataGrid zum Exportieren von Daten aus einem DataGrid und die Methode ImportGridView zum Exportieren von Daten aus einer GridView.
Es gibt viele überladene Versionen der ImportDataGrid-Methode, aber eine typische Überladung nimmt die folgenden Parameter an:
- dataGrid, das DataGrid-Objekt, aus dem wir Inhalte exportieren.
- firstRow, die Zeilennummer der ersten Zelle, in die die Daten exportiert werden.
- firstColumn, die Spaltennummer der ersten Zelle, in die die Daten exportiert werden.
- insertRows, eine boolesche Eigenschaft, die angibt, ob dem Arbeitsblatt zusätzliche Zeilen hinzugefügt werden sollen, um die Daten anzupassen.
- importStyle, eine boolesche Eigenschaft, die angibt, ob der Zellstil exportiert werden soll.
Das folgende Codebeispiel zeigt, wie Daten aus DataGrid in eine Excel-Datei in C# exportiert werden.
// 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");
Exportieren Sie HTML-formatierte Daten nach Excel in C#
Mit Aspose.Cells können Sie HTML-formatierte Daten in ein Excel-Arbeitsblatt exportieren. Die API analysiert beim Exportieren von Daten HTML-formatierten Text und konvertiert den HTML-Code in formatierte Zellenwerte. Im folgenden Beispielcode enthält DataTable HTML-formatierten Text und wir exportieren ihn mit der Methode ImportData in ein Excel-Dokument.
// 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-Datei in C# nach Excel exportieren
Mit Aspose.Cells können wir eine HTML-Datei nach Excel exportieren. Die HTML-Datei sollte Microsoft Excel-orientiert sein, dh MS-Excel sollte sie öffnen können.
// 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");
Exportieren Sie JSON-Daten nach Excel in C#
Manchmal müssen wir JSON-Daten in ein Excel-Dokument exportieren. Mit Aspose.Cells können wir das ganz einfach mit ein paar Zeilen Code machen. Aspose.Cells bietet eine JsonUtility-Klasse mit einer ImportData-Methode zum Exportieren von JSON-Daten in ein Excel-Dokument. Die Methode ImportData akzeptiert das Objekt JsonLayoutOptions als Parameter. Die Klasse JsonLayoutOptions stellt die Optionen des JSON-Layouts dar und hat die folgenden Eigenschaften.
- 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.
Im folgenden Beispielcode exportieren wir JSON-Daten in eine Excel-Datei 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"
}
}
}
}
CSV-Daten nach Excel in C# exportieren
Eine Datei mit kommagetrennten Werten (CSV) ist eine durch Trennzeichen getrennte Textdatei, die ein Komma verwendet, um Werte zu trennen. Eine CSV-Datei speichert typischerweise tabellarische Daten (Zahlen und Text) im Klartext, in diesem Fall hat jede Zeile die gleiche Anzahl von Feldern.
Das folgende Codebeispiel zeigt, wie wir eine CSV-Datei öffnen und mit der Aspose.Cells-Bibliothek als Excel-Datei speichern können.
// 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");
Fazit
In diesem Beitrag haben Sie gesehen, wie einfach Sie Daten aus Array, DataTable, DataView, DataGrid und GridView in C# nach Excel exportieren können. Sie haben auch gesehen, wie Sie HTML-, JSON- und CSV-Daten in ein Excel-Arbeitsblatt exportieren. Bitte lesen Sie die Dokumentation, um mehr über diese und mehrere andere Funktionen zu erfahren, die die Aspose.Cells-API bietet. Wenn Sie Fragen haben, können Sie sich gerne über unser Support-Forum an uns wenden.