Lesen von CSV-Dateien in C#: ein Tutorial

Bei der Arbeit mit verschiedenen Excel-Formaten ist es oft erforderlich, Daten einzulesen und sie dann programmatisch umzukonfigurieren. In diesem Artikel lernen wir, wie man eine CSV-Datei liest und Daten aus einer Excel-Tabelle in C# mit IronXL, dem perfekten Tool für diese Aufgabe, analysiert.

Was ist CSV?

CSV ist ein einfaches Datenformat, aber es kann viele Unterschiede geben, aber es kann schwierig sein, es programmatisch in unseren C#-Projekten zu lesen, weil es mehrere Begrenzungszeichen zur Unterscheidung zwischen Zeilen und Spalten von Daten verwendet. Dieser Artikel zeigt Ihnen, wie Sie dieIronXL-Bibliothek um CSV-Dateien zu lesen.

1. Wie man eine CSV-Datei in C# liest;

Bevor Sie IronXL zum Lesen von CSV-Dateien in MVC, ASP.NET oder .NET Core verwenden können, müssen Sie es installieren. Hier ist ein kurzer Durchgang.

1. Wählen Sie in Visual Studio das Menü Projekt

2. Verwalten von NuGet-Paketen

3. Suche nach IronXL.Excel

4. Installieren Sie

   

   Suchen Sie nach IronXL im NuGet Package Manager in Visual Studio

   Wenn Sie CSV-Dateien in C# lesen müssen, ist IronXL das perfekte Werkzeug. Sie können eine CSV-Datei mit Kommas oder einem anderen Trennzeichen lesen, wie in den nachstehenden Codesegmenten zu sehen ist.

WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
WorkSheet ws = workbook.DefaultWorkSheet;
workbook.SaveAs("Csv_To_Excel.xlsx");

WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
WorkSheet ws = workbook.DefaultWorkSheet;
workbook.SaveAs("Csv_To_Excel.xlsx");

Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
workbook.SaveAs("Csv_To_Excel.xlsx")

Ausgang:

Ausgabe einer CSV-Datei mit Komma als Trennzeichen

Code-Erläuterung:

Aarbeitsbuch objekt erstellt wird. DieloadCSV methode für das WorkBook-Objekt wird dann verwendet, um den Namen der CSV-Datei und ihr Format anzugeben, welche Trennzeichen in der zu lesenden CSV-Datei verwendet werden. In diesem Fall werden Kommas als Begrenzungszeichen verwendet.

Aarbeitsblatt objekt wird dann erstellt. Hier wird der Inhalt der CSV-Datei abgelegt. Anschließend wird die Datei unter einem neuen Namen und Format gespeichert.

Daten werden in Microsoft Excel angezeigt

2. IronXL für Excel-Dateien

Verwenden Sie IronXL für Ihr Projekt als optimierte Methode, um mit Excel-Dateiformaten in C# zu arbeiten. Sie können entwederironXL über den direkten Download installieren. Alternativ können Sie auchNuGet-Installation für Visual Studio. Die Software ist für die Entwicklung kostenlos.

Install-Package IronXL.Excel

3. Arbeitsbuch" laden und auf "Arbeitsblatt" zugreifen

workBook" ist die Klasse von IronXL, deren Objekt vollen Zugriff auf die Excel-Datei und alle ihre Funktionen bietet. Wenn wir zum Beispiel auf eine Excel-Datei zugreifen wollen, würden wir den Code verwenden:

WorkBook wb = WorkBook.Load("sample.xlsx");//Excel file path

WorkBook wb = WorkBook.Load("sample.xlsx");//Excel file path

Dim wb As WorkBook = WorkBook.Load("sample.xlsx") 'Excel file path

Um auf ein bestimmtes Arbeitsblatt einer Excel-Datei zuzugreifen, bietet IronXL die Klasse WorkSheet.

WorkSheet ws = wb.GetWorkSheet("Sheet1"); //by sheet name

WorkSheet ws = wb.GetWorkSheet("Sheet1"); //by sheet name

Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1") 'by sheet name

Sobald Sie das Excel-Arbeitsblatt "ws" erhalten haben, können Sie jede Art von Daten daraus extrahieren und alle Excel-Funktionen darauf ausführen. Dabei kann auf Daten aus dem Excel-Arbeitsblatt "ws" zugegriffen werden:

using IronXL;
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    foreach (var cell in ws ["A2:A10"])
    {
        Console.WriteLine("value is: {0}", cell.Text);
    }
    Console.ReadKey();
}

using IronXL;
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    foreach (var cell in ws ["A2:A10"])
    {
        Console.WriteLine("value is: {0}", cell.Text);
    }
    Console.ReadKey();
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	For Each cell In ws ("A2:A10")
		Console.WriteLine("value is: {0}", cell.Text)
	Next cell
	Console.ReadKey()
End Sub

4. Lesen eines Excel-Arbeitsblatts als Datentabelle

Mit IronXL ist es sehr einfach, mit einem Excel-Arbeitsblatt als Datentabelle zu arbeiten.

DataTable dt = WorkSheet.ToDataTable();

DataTable dt = WorkSheet.ToDataTable();

Dim dt As DataTable = WorkSheet.ToDataTable()

Verwenden Sie den folgenden Namensraum

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Schreiben Sie den folgenden Code:

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel file Name
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    DataTable dt = ws.ToDataTable(true);//parse sheet1 of sample.xlsx file into datatable
    foreach (DataRow row in dt.Rows) //access rows
    {
        for (int i = 0; i < dt.Columns.Count; i++) //access columns of corresponding row
        {
            Console.Write(row [i] + "  ");
        }
        Console.WriteLine();
    }
}

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel file Name
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    DataTable dt = ws.ToDataTable(true);//parse sheet1 of sample.xlsx file into datatable
    foreach (DataRow row in dt.Rows) //access rows
    {
        for (int i = 0; i < dt.Columns.Count; i++) //access columns of corresponding row
        {
            Console.Write(row [i] + "  ");
        }
        Console.WriteLine();
    }
}

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") ' Your Excel file Name
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	Dim dt As DataTable = ws.ToDataTable(True) 'parse sheet1 of sample.xlsx file into datatable
	For Each row As DataRow In dt.Rows 'access rows
		For i As Integer = 0 To dt.Columns.Count - 1 'access columns of corresponding row
			Console.Write(row (i) & "  ")
		Next i
		Console.WriteLine()
	Next row
End Sub

Konsolenausgabe von einem DataTable-Objekt

In diesem Beispiel wird gezeigt, wie eine Excel-Datei als "Datensatz" verwendet werden kann.

static void Main(string [] args)
{          
    WorkBook wb = WorkBook.Load("sample.xlsx");
    DataSet ds = wb.ToDataSet(); //Parse WorkBook wb into DataSet
    foreach (DataTable dt in ds.Tables)
    {
        Console.WriteLine(dt.TableName);
    }
}

static void Main(string [] args)
{          
    WorkBook wb = WorkBook.Load("sample.xlsx");
    DataSet ds = wb.ToDataSet(); //Parse WorkBook wb into DataSet
    foreach (DataTable dt in ds.Tables)
    {
        Console.WriteLine(dt.TableName);
    }
}

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ds As DataSet = wb.ToDataSet() 'Parse WorkBook wb into DataSet
	For Each dt As DataTable In ds.Tables
		Console.WriteLine(dt.TableName)
	Next dt
End Sub

Zugriff auf Blattname aus DataSet-Objekt

Schauen wir uns ein weiteres Beispiel an, wie man auf jeden Zellwert in allen Excel-Blättern zugreifen kann. Hier können wir auf jeden Zellwert eines jeden Arbeitsblatts in einer Excel-Datei zugreifen.

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx");
    DataSet ds = wb.ToDataSet();//behave complete Excel file as DataSet
    foreach (DataTable dt in ds.Tables)//behave Excel WorkSheet as DataTable.
    {
        foreach (DataRow row in dt.Rows)//corresponding Sheet's Rows
        {
            for (int i = 0; i < dt.Columns.Count; i++)//Sheet columns of corresponding row
            {
                Console.Write(row [i] + "  ");
            }
            Console.WriteLine();
        }
    }
}

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx");
    DataSet ds = wb.ToDataSet();//behave complete Excel file as DataSet
    foreach (DataTable dt in ds.Tables)//behave Excel WorkSheet as DataTable.
    {
        foreach (DataRow row in dt.Rows)//corresponding Sheet's Rows
        {
            for (int i = 0; i < dt.Columns.Count; i++)//Sheet columns of corresponding row
            {
                Console.Write(row [i] + "  ");
            }
            Console.WriteLine();
        }
    }
}

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("Weather.xlsx")
	Dim ds As DataSet = wb.ToDataSet() 'behave complete Excel file as DataSet
	For Each dt As DataTable In ds.Tables 'behave Excel WorkSheet as DataTable.
		For Each row As DataRow In dt.Rows 'corresponding Sheet's Rows
			For i As Integer = 0 To dt.Columns.Count - 1 'Sheet columns of corresponding row
				Console.Write(row (i) & "  ")
			Next i
			Console.WriteLine()
		Next row
	Next dt
End Sub

Konsolenausgabe des Dataset-Objekts

5. CSV-Parsing in C#; .NET

Bei CSV gibt es eine Fülle von Problemen mit der Behandlung von Zeilenumbrüchen in Feldern oder mit Feldern in Anführungszeichen, die einen einfachen Ansatz zur Aufteilung von Zeichenketten völlig blockieren. Ich habe vor kurzem die folgenden Optionen bei der Konvertierung von CSV in C# .NET entdeckt, indem ich ein anpassbares Trennzeichen angegeben habe, anstatt string.Split' zu verwenden(','), um die Werte durch ein Komma zu trennen.

6. Lesen von CSV-Daten in C# Datensätzen

Auf diese Weise wird der Leser durch die nächste Datei geführt. Wir lesen die CSV-Felddateien in trygetfield. Wir verwenden die Lesefunktion auf Feldfelder der CSV-Dateien als Datensatzfelder.

WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
WorkSheet ws = workbook.DefaultWorkSheet;
DataTable dt = ws.ToDataTable(true);//parse sheet1 of sample.xlsx file into datatable
foreach (DataRow row in dt.Rows) //access rows
{
    for (int i = 0; i < dt.Columns.Count; i++) //access columns of corresponding row
    {
        Console.Write(row [i] + "  ");
    }
    Console.WriteLine();
}

WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
WorkSheet ws = workbook.DefaultWorkSheet;
DataTable dt = ws.ToDataTable(true);//parse sheet1 of sample.xlsx file into datatable
foreach (DataRow row in dt.Rows) //access rows
{
    for (int i = 0; i < dt.Columns.Count; i++) //access columns of corresponding row
    {
        Console.Write(row [i] + "  ");
    }
    Console.WriteLine();
}

Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim dt As DataTable = ws.ToDataTable(True) 'parse sheet1 of sample.xlsx file into datatable
For Each row As DataRow In dt.Rows 'access rows
	For i As Integer = 0 To dt.Columns.Count - 1 'access columns of corresponding row
		Console.Write(row (i) & "  ")
	Next i
	Console.WriteLine()
Next row

Konsolenausgabe von DataTable

7. Abrufen von Daten aus Excel-Dateien

Jetzt können wir ganz einfach jede Art von Daten mit einer Vielzahl von Methoden aus dem geöffneten Excel-Arbeitsblatt abrufen. Im folgenden Beispiel sehen wir, wie man auf einen bestimmten Zellwert zugreift und ihn in "String" 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 Zeile darüber 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 Excel-Datei-Daten.

8. Wie man Excel-Dateien in C# analysiert;

Bei der Verwendung von Excel-Kalkulationstabellen für die Erstellung von Anwendungen analysieren wir oft die Ergebnisse auf der Grundlage von Daten und müssen die Daten der Excel-Datei in C# in das erforderliche Format parsen, um die richtigen Ergebnisse zu erhalten. Das Parsen von Daten in verschiedene Formate wird in der C#-Umgebung durch IronXL erleichtert; siehe die folgenden Schritte.

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();
}

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();
}

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

9. Analysieren von Excel-Daten in numerische und boolesche Werte

Nun gehen wir dazu über, wie man Daten aus Excel-Dateien auswertet. Zunächst sehen wir uns an, wie man mit numerischen Excel-Daten umgeht und wie man sie dann in das gewünschte Format parst.

Zusammenfassungstabelle für jeden Datentyp

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();
}

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();
}

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:

Konsolenausgabe mit korrektem Datentyp

Und hier sehen wir die Werte der Excel-Datei sample.xlsx:

Korrekten Datentyp in Excel anzeigen

Um Daten aus Excel-Dateien in boolesche Datentypen umzuwandeln, bietet IronXL dieBoolValue funktion. Sie kann wie folgt verwendet werden:

bool Val = ws ["Cell Address"].BoolValue;

bool Val = ws ["Cell Address"].BoolValue;

Dim Val As Boolean = ws ("Cell Address").BoolValue

10. Wie man Excel-Dateien in C&num analysiert; Sammlungen

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();
}

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();
}

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

10.1 Wie man ein Excel-Arbeitsblatt in eine Datentabelle umwandelt

Eine hervorragende Funktion von IronXL ist, dass wir ein bestimmtes Excel-Arbeitsblatt leicht in eine Datentabelle umwandeln können. Zu diesem Zweck können wir dietoDataTable()" funktion von IronXL wie folgt:

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

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

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

10.2 Wie man eine Excel-Datei in ein DataSet parst

Wenn wir eine komplette Excel-Datei in ein DataSet parsen wollen, dann können wir zu diesem Zweck die.ToDataSet()` funktion in IronXL.

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

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

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

10.3 Lesen von Excel-Daten innerhalb eines bestimmten Bereichs

IronXL bietet eine intelligente Methode zum Lesen von Excel-Dateien innerhalb eines bestimmten Bereichs. Der Bereich kann sowohl auf Zeilen als auch auf Spalten angewendet werden.

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //get specified range values by loop
    foreach (var item in ws ["B3:B8"])
    {
        Console.WriteLine("Value is: {0}", item);
    }
    Console.ReadKey();
}

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //get specified range values by loop
    foreach (var item in ws ["B3:B8"])
    {
        Console.WriteLine("Value is: {0}", item);
    }
    Console.ReadKey();
}

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	'get specified range values by loop
	For Each item In ws ("B3:B8")
		Console.WriteLine("Value is: {0}", item)
	Next item
	Console.ReadKey()
End Sub

Der obige Code zeigt die folgende Ausgabe an:

Konsolenausgabe für den Zugriff auf alle Werte im Bereich B3:B8

Und erzeugt die Excel-Datei sample.xlsx Werte:

Datenanzeige aus sample.xlsx

Darüber hinaus ist IronXL auch mit vielen Excel-Methoden zur Interaktion mit Zellen kompatibel, darunterstyling und Rahmen, mathematische Funktionen, [bedingte Formatierung oder die Erstellung von Diagrammen aus verfügbaren Daten.

11. Wie man boolesche Daten in einer Excel-Datei liest

Bei der Anwendungsentwicklung müssen wir Entscheidungen auf der Grundlage des booleschen Datentyps in Excel-Dateien treffen.

static void Main(string [] args)
{
   WorkBook wb = WorkBook.Load("sample.xlsx");
   WorkSheet ws = wb.GetWorkSheet("Sheet1");
   foreach (var item in ws ["G1:G10"])
   {
   Console.WriteLine("  Condition is: {0}", item.BoolValue);
   }
   Console.ReadKey();
}

static void Main(string [] args)
{
   WorkBook wb = WorkBook.Load("sample.xlsx");
   WorkSheet ws = wb.GetWorkSheet("Sheet1");
   foreach (var item in ws ["G1:G10"])
   {
   Console.WriteLine("  Condition is: {0}", item.BoolValue);
   }
   Console.ReadKey();
}

Shared Sub Main(ByVal args() As String)
   Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
   Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
   For Each item In ws ("G1:G10")
   Console.WriteLine("  Condition is: {0}", item.BoolValue)
   Next item
   Console.ReadKey()
End Sub

Daraus ergibt sich die Ausgabe:

Konsolenausgabe beim Abrufen boolescher Daten

Und die Excel-Datei sample.xlsx mit Werten von C1 bis C10:

Excel-Beispiel zum Vergleich mit der Konsolenausgabe

12. Wie man ein vollständiges Excel-Arbeitsblatt liest

Es ist einfach, ein komplettes Excel-Arbeitsblatt zu lesen, indem man Zeilen- und Spaltenindizes verwendet. Zu diesem Zweck verwenden wir zwei Schleifen: eine, um alle Zeilen zu durchlaufen, und die zweite, um alle Spalten einer bestimmten Zeile zu durchlaufen. Dann können wir ganz einfach alle Zellwerte innerhalb des gesamten Excel-Arbeitsblatts abrufen.

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); // your Excel File Name
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Traverse all rows of Excel WorkSheet
    for (int i = 0;  i< ws.Rows.Count(); i++)
    {
        //Traverse all columns of specific Row
        for (int j = 0; j < ws.Columns.Count(); j++)
        {
            //Get the values
            string val = ws.Rows [i].Columns [j].Value.ToString();
            Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j,val);
        }
    }
    Console.ReadKey();
}

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); // your Excel File Name
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Traverse all rows of Excel WorkSheet
    for (int i = 0;  i< ws.Rows.Count(); i++)
    {
        //Traverse all columns of specific Row
        for (int j = 0; j < ws.Columns.Count(); j++)
        {
            //Get the values
            string val = ws.Rows [i].Columns [j].Value.ToString();
            Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j,val);
        }
    }
    Console.ReadKey();
}

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") ' your Excel File Name
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	'Traverse all rows of Excel WorkSheet
	For i As Integer = 0 To ws.Rows.Count() - 1
		'Traverse all columns of specific Row
		For j As Integer = 0 To ws.Columns.Count() - 1
			'Get the values
			Dim val As String = ws.Rows (i).Columns (j).Value.ToString()
			Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j,val)
		Next j
	Next i
	Console.ReadKey()
End Sub

Konsolenausgabe beim Lesen aller Werte

13. Wie man Excel-Dateien ohne Interop liest

IronXL ist einExcel-Bibliothek für C# und .NET, die es Entwicklern ermöglicht, Excel-Daten aus XLS- und XLSX-Dokumenten zu lesen und zu bearbeiten, ohne Microsoft.Office.Interop.Excel zu verwenden.

Die API ermöglicht es uns, Excel-Dateien intuitiv zu erstellen, zu lesen, zu bearbeiten, zu speichern und zu exportieren:

1. .NET-Framework 4.5+

2. .NET Core 2+

3. .NET-Standard

4. Xamarin

5. Windows Mobile

6. Mono

7. & Azure Cloud Hosting

8. Blazor

9. .NET MAUI

   Fügen Sie den folgenden Namespace hinzu:

using IronXL;
using System;
using System.Linq;

using IronXL;
using System;
using System.Linq;

Imports IronXL
Imports System
Imports System.Linq

Schreiben Sie nun den folgenden Code in die Hauptfunktion.

WorkBook workbook = WorkBook.Load("Weather.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();

//Select cells easily in Excel notation and return the calculated value
int cellValue = sheet ["A2"].IntValue;
// Read from Ranges of cells elegantly.
foreach (var cell in sheet ["A2:A10"])
{
   Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

WorkBook workbook = WorkBook.Load("Weather.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();

//Select cells easily in Excel notation and return the calculated value
int cellValue = sheet ["A2"].IntValue;
// Read from Ranges of cells elegantly.
foreach (var cell in sheet ["A2:A10"])
{
   Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

Dim workbook As WorkBook = WorkBook.Load("Weather.xlsx")
Dim sheet As WorkSheet = workbook.WorkSheets.First()

'Select cells easily in Excel notation and return the calculated value
Dim cellValue As Integer = sheet ("A2").IntValue
' Read from Ranges of cells elegantly.
For Each cell In sheet ("A2:A10")
   Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
Next cell

Konsolenausgabe von jeder Zelle

IronXL unterstützt auch ASP.NET, MVC, Windows, macOS, Linux, iOS und Android Mobile Anwendungsentwicklung.

14. Fazit und Iron XL Sonderangebot

Zusätzlich zuCSV-Parsing in C#, IronXL konvertiert CSV-Dateien in Excel mit nur zwei Zeilen Code!

Mit C# oder VB.NET ist es sehr einfach, die Excel-API von IronXL zu nutzen, ohne dass Interop erforderlich ist. Sie können Excel-Tabellen lesen, bearbeiten und erstellen oder mit anderen Excel-Formaten arbeiten, wie z.BXLS/XLSX/CSV/TSV. Mit der Unterstützung mehrerer Frameworks können Sie 5 Produkte zum Preis von zwei kaufen. Klicken Sie aufunsere Preisseite für weitere Informationen.

5 Produkte von Iron Suite