C# Parse Excel Datei
Bei der Verwendung von Excel-Tabellen für die Anwendung baut, analysieren wir oft die Ergebnisse auf der Grundlage von Daten, und müssen innerhalb von C # Parsen Excel-Datei Daten in das erforderliche Format, um die richtigen Ergebnisse zu erhalten. Das Parsen von Daten in verschiedene Formate wird in der C-Sharp-Umgebung durch die Verwendung von IronXL und die folgenden Schritte erleichtert.
Parsen von Excel-Dateien in C#;
Installieren Sie die Excel-Bibliothek, um Excel-Dateien zu verarbeiten.
Fügen Sie die Excel-Datei hinzu, indem Sie das Objekt
Workbook
öffnen.Wählen Sie das Standard-Arbeitsblatt.
Lesen von Werten aus der Excel-Arbeitsmappe.
- Verarbeiten Sie den Wert genau und zeigen Sie ihn an.
Schritt 1
1. IronXL für Visual Studio herunterladen
Ihr erster Schritt istIronXL für Visual Studio herunterladen oder installieren Sie mitNuGet, beides kostenlose Methoden für Entwicklungsprojekte.
Install-Package IronXL.Excel
Anleitung zum Tutorial
2. Excel-Datei laden
Als Nächstes müssen Sie die Excel-Datei in Ihr C#-Projekt laden, indem Sie den Befehl `WorkBook.Load()funktion von IronXL. Wir übergeben einen String-Parameter, um den Pfad der Excel-Datei wie folgt anzugeben:
//Load Excel file
WorkBook wb = WorkBook.Load("Path");
//Load Excel file
WorkBook wb = WorkBook.Load("Path");
'Load Excel file
Dim wb As WorkBook = WorkBook.Load("Path")
Die Excel-Datei wird in wb
geladen. Jetzt können wir ein bestimmtes WorkSheet öffnen.
3. Öffnen Sie das Excel-WorkSheet
Um ein Arbeitsblatt einer Excel-Datei zu öffnen, verwenden wir die Funktion `WorkBook.GetWorkSheet()funktion. Sie erfordert einen String-Parameter zur Angabe des zu öffnenden WorkSheet-Namens. Wir können es so verwenden:
//specify WorkSheet
WorkSheet ws = Wb.GetWorkSheet("SheetName");
//specify WorkSheet
WorkSheet ws = Wb.GetWorkSheet("SheetName");
'specify WorkSheet
Dim ws As WorkSheet = Wb.GetWorkSheet("SheetName")
wb" ist das WorkBook, das wir in Schritt 1 definiert haben.
4. Daten aus Excel-Datei abrufen
Jetzt können wir jede Art von Daten auf vielfältige Weise aus einem geöffneten Excel-Arbeitsblatt abrufen. Im folgenden Beispiel sehen wir, wie man auf einen bestimmten Zellwert zugreift und ihn in eine Zeichenfolge umwandelt:
//Access the Data by Cell Addressing
string val = ws ["Cell Address"].ToString();
//Access the Data by Cell Addressing
string val = ws ["Cell Address"].ToString();
'Access the Data by Cell Addressing
Dim val As String = ws ("Cell Address").ToString()
In der obigen Zeile ist ws
das WorkSheet, das in Schritt 2 definiert wurde. Dies ist der einfache Ansatz, aber Sie können mehr lesen und verschiedene Beispiele sehen, wie manzugriff auf die Daten einer Excel-Datei.
5. Excel-Daten in numerische Werte umwandeln
Nun gehen wir dazu über, wie man Daten aus Excel-Dateien auswertet.
Zunächst sehen wir uns an, wie man mit numerischen Daten in Excel umgeht und sie in das gewünschte Format parst. Verwenden Sie die IronXL-Liste der Parser-Funktionen unten, um die für Ihr Projekt geeigneten Funktionen zu verwenden.
DataType | Methode | Erläuterung |
---|---|---|
int | WorkSheet ["CellAddress"].IntValue | Sie wird verwendet, wenn wir den Wert einer Excel-Zelle in "Int" umwandeln müssen. |
Int32 | WorkSheet ["CellAddress"].Int32Value | wenn wir den Wert einer Excel-Zelle in `Int32` parsen müssen. |
Int64 | WorkSheet ["CellAddress"].Int64Value | wenn wir einen zu großen numerischen Wert haben und ihn in unserem Projekt verwenden wollen. |
schwimmer | WorkSheet ["CellAddress"].FloatValue | Es wird verwendet, wenn Werte auch nach dem Dezimalpunkt wichtig sind. |
Doppelter | WorkSheet ["CellAddress"].DoubleValue | wenn wir numerische Daten mit größerer Genauigkeit erhalten wollen. |
Dezimal | WorkSheet ["CellAddress"].DecimalValue | Wenn wir zu viele Nachkommastellen haben und ein möglichst genaues Ergebnis haben wollen. |
Hier ein Beispiel für die Verwendung einiger dieser Funktionen zum Parsen von Excel-Dateidaten in C#.
/**
Parse into Numeric Values
anchor-parse-excel-data-into-numeric-values
**/
using IronXL;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
//Parse Excel cell value into string
string str_val = ws ["B3"].Value.ToString();
//Parse Excel cell value into int32
Int32 int32_val = ws ["G3"].Int32Value;
//Parse Excel cell value into Decimal
decimal decimal_val = ws ["E5"].DecimalValue;
Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);
Console.ReadKey();
}
/**
Parse into Numeric Values
anchor-parse-excel-data-into-numeric-values
**/
using IronXL;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
//Parse Excel cell value into string
string str_val = ws ["B3"].Value.ToString();
//Parse Excel cell value into int32
Int32 int32_val = ws ["G3"].Int32Value;
//Parse Excel cell value into Decimal
decimal decimal_val = ws ["E5"].DecimalValue;
Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);
Console.ReadKey();
}
'''
'''Parse into Numeric Values
'''anchor-parse-excel-data-into-numeric-values
'''*
Imports IronXL
Shared Sub Main(ByVal args() As String)
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
'Parse Excel cell value into string
Dim str_val As String = ws ("B3").Value.ToString()
'Parse Excel cell value into int32
Dim int32_val As Int32 = ws ("G3").Int32Value
'Parse Excel cell value into Decimal
Dim decimal_val As Decimal = ws ("E5").DecimalValue
Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val)
Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val)
Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val)
Console.ReadKey()
End Sub
Dieser Code zeigt die folgende Ausgabe an:
Und hier sehen wir die Werte der Excel-Datei "sample.xlsx":
6. Excel-Daten in boolesche Werte umwandeln
IronXL bietet die Funktion BoolValue
, um Excel-Daten in boolesche Datentypen umzuwandeln. Sie kann wie folgt verwendet werden:
/**
Parse into Boolean Values
anchor-parse-excel-data-into-boolean-values
**/
bool Val = ws ["Cell Address"].BoolValue;
/**
Parse into Boolean Values
anchor-parse-excel-data-into-boolean-values
**/
bool Val = ws ["Cell Address"].BoolValue;
'''
'''Parse into Boolean Values
'''anchor-parse-excel-data-into-boolean-values
'''*
Dim Val As Boolean = ws ("Cell Address").BoolValue
ws" ist das WorkSheet, wie im obigen Beispiel beschrieben. Die obige Funktion gibt den Wert True
oder False
zurück. Hinweis: Wenn Sie einen Zellwert in einen booleschen Datentyp umwandeln möchten, stellen Sie sicher, dass die Werte in Ihrer Excel-Datei im Format (0
, 1
) oder (True
, False
) vorliegen.
7. Parse Excel-Datei in C# Sammlungen
Mit IronXL können wir Daten aus Excel-Dateien in die folgenden Arten von CSharp-Sammlungen zerlegen:
DataType | Methode | Erläuterung |
---|---|---|
Array | WorkSheet ["Von:Bis"].ToArray() | Diese Funktion wird verwendet, um Excel-Dateidaten in ein Array zu parsen. Wir geben einen Bereich von Excel-Dateizellen an, deren Daten in ein Array konvertiert werden sollen. |
DataTable | WorkSheet.ToDataTable() | Es wird verwendet, um ein komplettes Excel-Arbeitsblatt in DataTable zu analysieren und die Daten nach Bedarf zu verwenden. |
DataSet | WorkBook.ToDataSet() | können wir ein komplettes Excel WorkBook in ein DataSet parsen. Auf diese Weise werden die WorkSheets der Excel-Datei zu DataTable des DataSet. |
Sehen wir uns ein Beispiel nach dem anderen an, wie man Excel-Dateidaten in diese Sammlungstypen zerlegt.
7.1. Parsen von Excel-Daten in ein Array
IronXL bietet eine einfache Möglichkeit, Excel-Dateidaten eines bestimmten Bereichs in ein Array zu analysieren. Zu diesem Zweck geben wir die Adressen der Zellen "Von" bis "Bis" an, deren Daten in ein Array umgewandelt werden. Dies kann wie folgt geschehen:
var array = WorkSheet ["From:To"].ToArray();
var array = WorkSheet ["From:To"].ToArray();
Dim array = WorkSheet ("From:To").ToArray()
Wenn wir auf ein bestimmtes Element aus dem Array zugreifen wollen, verwenden wir:
string item = array [ItemIndex].Value.ToString();
string item = array [ItemIndex].Value.ToString();
Dim item As String = array (ItemIndex).Value.ToString()
Es ist klar, dass wir durch Indizierung leicht auf Elemente zugreifen können. Sehen wir uns ein Beispiel dafür an, wie man Daten aus einer Excel-Datei in ein Array parst und ein bestimmtes Element daraus auswählt.
/**
Parse into Array
anchor-parse-excel-data-into-array
**/
using IronXL;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
var array = ws ["B6:F6"].ToArray();
int item = array.Count();
string total_items = array [0].Value.ToString();
Console.WriteLine("First item in the array: {0}", item);
Console.WriteLine("Total items from B6 to F6: {0}",total_items);
Console.ReadKey();
}
/**
Parse into Array
anchor-parse-excel-data-into-array
**/
using IronXL;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
var array = ws ["B6:F6"].ToArray();
int item = array.Count();
string total_items = array [0].Value.ToString();
Console.WriteLine("First item in the array: {0}", item);
Console.WriteLine("Total items from B6 to F6: {0}",total_items);
Console.ReadKey();
}
'''
'''Parse into Array
'''anchor-parse-excel-data-into-array
'''*
Imports IronXL
Shared Sub Main(ByVal args() As String)
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
Dim array = ws ("B6:F6").ToArray()
Dim item As Integer = array.Count()
Dim total_items As String = array (0).Value.ToString()
Console.WriteLine("First item in the array: {0}", item)
Console.WriteLine("Total items from B6 to F6: {0}",total_items)
Console.ReadKey()
End Sub
Der obige Code zeigt die folgende Ausgabe an:
Die Bereichswerte der Excel-Datei "sample.xlsx" von "B6" bis "F6" sehen wie folgt aus
7.2. Excel-Arbeitsblatt in Datentabelle analysieren
Das Schöne an IronXL ist, dass wir ein bestimmtes Excel-Arbeitsblatt leicht in eine Datentabelle umwandeln können. Zu diesem Zweck können wir die Funktion `.ToDataTable()die Funktion von IronXL ist wie folgt:
DataTable dt = WorkSheet.ToDataTable();
DataTable dt = WorkSheet.ToDataTable();
Dim dt As DataTable = WorkSheet.ToDataTable()
Sie analysiert das Excel-Arbeitsblatt in die Datentabelle "dt". Wenn wir in diesem Fall die erste Zeile der Excel-Datei als Spaltenname für die Datentabelle verwenden möchten, können wir sie als solche festlegen:
DataTable dt=WorkSheet.ToDataTable(True);
DataTable dt=WorkSheet.ToDataTable(True);
Dim dt As DataTable=WorkSheet.ToDataTable([True])
Der boolesche Parameter von `.ToDataTable()die Funktion legt fest, dass die erste Zeile der Excel-Datei zu ColumnName der DataTable wird. Sie können tiefer in die Arbeit mitExcelWorksheet als DataTable in C#
Und hier ist das Beispiel für das Parsen von Excel WorkSheet in DataTable:
/**
Parse into DataTable
anchor-parse-excel-worksheet-into-datatable
**/
using IronXL;
using System.Data;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
//parse sheet1 of sample.xlsx file into DataTable.
//we set parameter true of ToDataTable() function,so first row of Excel file becomes columnname of DataTable
DataTable dt = ws.ToDataTable(true);
}
/**
Parse into DataTable
anchor-parse-excel-worksheet-into-datatable
**/
using IronXL;
using System.Data;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
//parse sheet1 of sample.xlsx file into DataTable.
//we set parameter true of ToDataTable() function,so first row of Excel file becomes columnname of DataTable
DataTable dt = ws.ToDataTable(true);
}
'''
'''Parse into DataTable
'''anchor-parse-excel-worksheet-into-datatable
'''*
Imports IronXL
Imports System.Data
Shared Sub Main(ByVal args() As String)
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
'parse sheet1 of sample.xlsx file into DataTable.
'we set parameter true of ToDataTable() function,so first row of Excel file becomes columnname of DataTable
Dim dt As DataTable = ws.ToDataTable(True)
End Sub
7.3. Excel-Datei in DataSet parsen
Wenn wir eine komplette Excel-Datei in ein DataSet parsen wollen, dann können wir zu diesem Zweck die Funktion `.ToDataSet()funktion von IronXL. Sie kann wie folgt verwendet werden:
DataSet ds = WorkBook.ToDataSet();
DataSet ds = WorkBook.ToDataSet();
Dim ds As DataSet = WorkBook.ToDataSet()
Hinweis: Wenn wir eine Excel-Datei in ein DataSet analysieren, werden ALLE Arbeitsblätter der Excel-Datei zu Datentabellen dieses Datasets. Sehen wir uns ein Beispiel dafür an, wie man eine Excel-Datei in ein DataSet parst:
/**
Parse File into DataSet
anchor-parse-excel-file-into-dataset
**/
using IronXL;
using System.Data;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");
//parse WorkBook wb into DataSet
DataSet ds = wb.ToDataSet();
//we also can get DataTable from ds which is actually WorkSheet as:
DataTable dt=ds.Tables [0];
}
/**
Parse File into DataSet
anchor-parse-excel-file-into-dataset
**/
using IronXL;
using System.Data;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");
//parse WorkBook wb into DataSet
DataSet ds = wb.ToDataSet();
//we also can get DataTable from ds which is actually WorkSheet as:
DataTable dt=ds.Tables [0];
}
'''
'''Parse File into DataSet
'''anchor-parse-excel-file-into-dataset
'''*
Imports IronXL
Imports System.Data
Shared Sub Main(ByVal args() As String)
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
'parse WorkBook wb into DataSet
Dim ds As DataSet = wb.ToDataSet()
'we also can get DataTable from ds which is actually WorkSheet as:
Dim dt As DataTable=ds.Tables (0)
End Sub
Sie können mehr lesen überExcel-SQL-Datensatz und die Arbeit mit diesen Dateien.
Tutorial Schnellzugriff
Dokumentation für Excel in C#
Nutzen Sie die IronXL-Dokumentation für die Arbeit mit Excel in C#, um alle Funktionen, Klassen, Namespaces und mehr in Ihren Projekten zu verwenden.
Dokumentation für Excel in C#