1. IronXL
2. Anleitungen
3. C# Excel-Datei parsen

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.

C# Öffnen von Excel-Arbeitsblättern

• IronXL für Visual Studio herunterladen
• C# parsen Excel-Daten numerische Werte
• Daten in boolesche Werte zerlegen
• Parsen von Dateien in C# Collections einschließlich Arrays, Datentabellen und Datensätze

Parsen von Excel-Dateien in C#;

1. Installieren Sie die Excel-Bibliothek, um Excel-Dateien zu verarbeiten.

2. Fügen Sie die Excel-Datei hinzu, indem Sie das Objekt Workbook öffnen.

3. Wählen Sie das Standard-Arbeitsblatt.

4. Lesen von Werten aus der Excel-Arbeitsmappe.

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

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:

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#