Konvertieren einer CSV-Datei in eine Liste in C#

In diesem Tutorial für Anfänger sehen wir uns an, wie man CSV-Dateien in eine Liste in C# mithilfe der IronXL-Bibliothek einliest. Dies ist eines der grundlegendsten Dinge, die man in jeder Programmiersprache wissen muss, da CSV-Dateien eine sehr verbreitete Art sind, Daten zu speichern und sie von einem System oder einer Anwendung in eine andere zu übertragen. Wir behandeln alles von der Einrichtung Ihres Projekts bis zum effektiven Parsen von CSV-Dateien.

Konvertieren einer CSV-Datei in eine Liste in C#;

1. Erstellen Sie ein C#-Konsolenprojekt in Visual Studio.

2. Installieren Sie die C# CSV-Bibliothek mit NuGet Package Manager.

3. Laden Sie die CSV-Datei mit der Methode WorkBook.LoadCSV.

4. Datenwerte aus der Datei lesen und die Liste auffüllen.

5. Drucken Sie die Liste auf der Konsole aus.

Ihr Projekt einrichten

Schritt 1: Erstellen eines neuen C#-Projekts

1. Öffne Visual Studio: Starten Sie Visual Studio auf Ihrem Computer.

2. Ein neues Projekt erstellen: Klicken Sie auf "Ein neues Projekt erstellen". Es öffnet sich ein Fenster, in dem Sie den Projekttyp auswählen können.

3. Projekttyp auswählen: Wählen Sie "Konsolenanwendung (.NET Core)" als Projekttyp für Einfachheit.

4. Nennen Sie Ihr Projekt: Nennen Sie Ihr Projekt CSVFileReader.

5. Standort wählen: Wählen Sie einen geeigneten Speicherort auf Ihrem Gerät, um dieses Projekt zu speichern.

6. Projekt generieren: Klicken Sie auf "Erstellen", um Ihr neues C#-Projekt zu initialisieren.

Schritt 2: Installieren der IronXL-Bibliothek

1. NuGet-Paket-Manager öffnen: Gehen Sie in Visual Studio zum Menü "Tools" und wählen Sie dann "NuGet-Paket-Manager" aus. Wählen Sie "NuGet-Pakete für die Lösung verwalten...".

2. Suchen nach IronXL: Klicken Sie auf die Registerkarte "Durchsuchen" und suchen Sie nach "IronXL.Excel".

   

3. Installieren Sie IronXL: Finden Sie das IronXL-Paket in den Suchergebnissen, wählen Sie es aus und klicken Sie auf "Installieren". Stellen Sie sicher, dass Sie allen Lizenzvereinbarungen zustimmen und die Änderungen überprüfen.

4. Installation überprüfen: Nach der Installation sollten Sie sehen, dass IronXL in den Referenzen Ihres Projekts aufgeführt ist.

   Jetzt ist Ihr CSVFileReader-Projekt mit der IronXL-Bibliothek eingerichtet, und Sie können mit dem Lesen und Verarbeiten von CSV-Dateien in C# beginnen. Diese Einrichtung bildet die Grundlage für die CSV-Leseaufgaben, die wir in den folgenden Abschnitten dieses Lernprogramms durchführen werden.

Parsing und Verarbeitung von CSV-Dateien in C#;

Nachdem das Projekt eingerichtet und die IronXL-Bibliothek installiert ist, können wir uns nun auf das Parsen und Verarbeiten von CSV-Dateien konzentrieren. Wir werden innerhalb der Datei Program.cs arbeiten, die automatisch in Ihrem CSVFileReader-Projekt generiert wird.

Schritt 1: Festlegen des Dateipfads

Bevor wir Daten lesen können, müssen wir wissen, wo sich unsere CSV-Datei befindet. Definieren Sie eine Variable in der Main-Methode, um den Dateipfad zu speichern.

string filename = "csvfile.csv"; // Replace with your actual file path

string filename = "csvfile.csv"; // Replace with your actual file path

Dim filename As String = "csvfile.csv" ' Replace with your actual file path

Schritt 2: Laden der CSV-Datei

IronXL macht das Laden einer CSV-Datei einfach. Verwenden Sie die WorkBook.LoadCSV-Methode, um die CSV-Datei in ein WorkBook-Objekt einzulesen.

var csv = WorkBook.LoadCSV(filename);

var csv = WorkBook.LoadCSV(filename);

Dim csv = WorkBook.LoadCSV(filename)

Schritt 3: Definieren einer Datenstruktur

Erstellen Sie eine Klasse, die die Datenstruktur in Ihrer CSV-Datei darstellt. Wenn Ihre CSV beispielsweise Informationen über Personen enthält, definieren Sie eine Person-Klasse so:

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Public Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Schritt 4: Parsing von CSV-Daten

In diesem Schritt werden wir die CSV-Datei analysieren und eine List<Person> mit den Daten füllen. Wir verwenden IronXL zum Lesen der CSV-Datei, und der Schlüssel dazu ist die korrekte Verarbeitung jeder Zeile der CSV-Datei unter Berücksichtigung von Kopfzeilen und potenziellen Leerzeilen. Hier finden Sie eine detaillierte Aufschlüsselung des Codes:

List<Person> people = new List<Person>();
bool isFirstRow = true; // Add a flag to check for the first row
foreach (var row in csv.WorkSheets [0].Rows)
{
    if (isFirstRow)
    {
        isFirstRow = false; // Set the flag to false after skipping the first row
        continue;
    }
    if (row.IsEmpty) continue; // Skip empty rows
    var cells = row.ToArray();
    var person = new Person()
    {
        Name = cells [0].StringValue,
        Age = int.Parse(cells [1].StringValue) // Ensure this is a numeric value
    };
    people.Add(person);
}

List<Person> people = new List<Person>();
bool isFirstRow = true; // Add a flag to check for the first row
foreach (var row in csv.WorkSheets [0].Rows)
{
    if (isFirstRow)
    {
        isFirstRow = false; // Set the flag to false after skipping the first row
        continue;
    }
    if (row.IsEmpty) continue; // Skip empty rows
    var cells = row.ToArray();
    var person = new Person()
    {
        Name = cells [0].StringValue,
        Age = int.Parse(cells [1].StringValue) // Ensure this is a numeric value
    };
    people.Add(person);
}

Dim people As New List(Of Person)()
Dim isFirstRow As Boolean = True ' Add a flag to check for the first row
For Each row In csv.WorkSheets (0).Rows
	If isFirstRow Then
		isFirstRow = False ' Set the flag to false after skipping the first row
		Continue For
	End If
	If row.IsEmpty Then
		Continue For ' Skip empty rows
	End If
	Dim cells = row.ToArray()
	Dim person As New Person() With {
		.Name = cells (0).StringValue,
		.Age = Integer.Parse(cells (1).StringValue)
	}
	people.Add(person)
Next row

In diesem Parsing-Prozess initialisieren wir zuerst eine List<Person>, um die analysierten Daten zu speichern, und verwenden ein boolesches Flag isFirstRow, um die Kopfzeile der CSV-Datei zu überspringen. Die foreach-Schleife iteriert durch jede Zeile der CSV-Datei. Während der ersten Iteration wird die Kopfzeile identifiziert und übersprungen, um sicherzustellen, dass nur Datenzeilen verarbeitet werden. Dann überprüfen wir jede Zeile, um sicherzustellen, dass sie nicht leer ist, indem wir row.IsEmpty verwenden. Dieser Schritt ist wichtig, um Parsing-Fehler bei leeren Zeilen zu vermeiden.

Für jede Datenzeile konvertieren wir die Zeile in ein Array von Zellen (row.ToArray()) und erstellen dann ein Person-Objekt mit diesen Daten. Es ist wichtig, die Datentypen korrekt zu analysieren und zu konvertieren, z. B. die Zeichenkette "Alter" in eine ganze Zahl umzuwandeln. Das geparste Person-Objekt wird dann unserer people-Liste hinzugefügt. Dieser Ansatz stellt sicher, dass nur gültige Datenzeilen verarbeitet und gespeichert werden, wodurch potenzielle Probleme wie nicht-numerische Zeichenfolgen in numerischen Spalten oder unerwartet leere Zeilen effektiv behandelt werden.

Schritt 5: Anzeige der Daten

Nachdem die CSV-Daten in unsere List<Person> geparst wurden, besteht der nächste wichtige Schritt darin, die Daten anzuzeigen und zu verifizieren. So können wir nicht nur sicherstellen, dass unser Parsing erfolgreich war, sondern auch die Ausgabe beobachten und eine schnelle Überprüfung der Datenqualität durchführen. So können Sie dies umsetzen:

foreach (var person in people)
{
    Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}

foreach (var person in people)
{
    Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}

For Each person In people
	Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")
Next person

Hier ist der vollständige Program.cs-Code:

using IronXL;

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main(string [] args)
    {
        string filename = @"C:\Users\tayya\Downloads\sample_data.csv"; // Replace with your actual file path
        var csv = WorkBook.LoadCSV(filename);
        List<Person> people = new List<Person>();
        bool isFirstRow = true; // Add a flag to check for the first row
        foreach (var row in csv.WorkSheets [0].Rows)
        {
            if (isFirstRow)
            {
                isFirstRow = false; // Set the flag to false after skipping the first row
                continue;
            }
            if (row.IsEmpty) continue; // Skip empty rows
            var cells = row.ToArray();
            var person = new Person()
            {
                Name = cells [0].StringValue,
                Age = int.Parse(cells [1].StringValue) // Ensure this is a numeric value
            };
            people.Add(person);
        }
        foreach (var person in people)
        {
            Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
        }
    }
}

using IronXL;

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main(string [] args)
    {
        string filename = @"C:\Users\tayya\Downloads\sample_data.csv"; // Replace with your actual file path
        var csv = WorkBook.LoadCSV(filename);
        List<Person> people = new List<Person>();
        bool isFirstRow = true; // Add a flag to check for the first row
        foreach (var row in csv.WorkSheets [0].Rows)
        {
            if (isFirstRow)
            {
                isFirstRow = false; // Set the flag to false after skipping the first row
                continue;
            }
            if (row.IsEmpty) continue; // Skip empty rows
            var cells = row.ToArray();
            var person = new Person()
            {
                Name = cells [0].StringValue,
                Age = int.Parse(cells [1].StringValue) // Ensure this is a numeric value
            };
            people.Add(person);
        }
        foreach (var person in people)
        {
            Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
        }
    }
}

Imports IronXL

Public Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim filename As String = "C:\Users\tayya\Downloads\sample_data.csv" ' Replace with your actual file path
		Dim csv = WorkBook.LoadCSV(filename)
		Dim people As New List(Of Person)()
		Dim isFirstRow As Boolean = True ' Add a flag to check for the first row
		For Each row In csv.WorkSheets (0).Rows
			If isFirstRow Then
				isFirstRow = False ' Set the flag to false after skipping the first row
				Continue For
			End If
			If row.IsEmpty Then
				Continue For ' Skip empty rows
			End If
			Dim cells = row.ToArray()
			Dim person As New Person() With {
				.Name = cells (0).StringValue,
				.Age = Integer.Parse(cells (1).StringValue)
			}
			people.Add(person)
		Next row
		For Each person In people
			Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")
		Next person
	End Sub
End Class

Ausgabe des Codes

Wenn Sie die Datei ausführen, werden die Daten der Liste in der Konsole angezeigt:

Umgang mit verschiedenen Datentypen

Bei der Verarbeitung verschiedener Datentypen in einer CSV-Datei ist es wichtig, die Parsing-Logik an den spezifischen Typ jeder Datenspalte anzupassen. Im Beispiel der Person-Klasse kann das Name-Feld als Zeichenkette direkt mit StringValue zugewiesen werden, während numerische Felder wie Age eine Umwandlung von Zeichenkette zu Ganzzahl erfordern, indem Int32.Parse oder Convert.ToInt32 verwendet wird. Dies ist wichtig, um Fehler bei der Typübereinstimmung zu vermeiden.

Für komplexere Datentypen, wie zum Beispiel Datumsangaben, verwenden Sie DateTime.Parse, um Zeichenfolgen-Darstellungen von Daten in DateTime-Objekte zu konvertieren. Es ist wichtig, das in Ihrer CSV-Datei verwendete Datumsformat zu kennen und sicherzustellen, dass es mit dem erwarteten Format in Ihrem Code übereinstimmt. Inkonsistente Datumsformate können zu Parsing-Fehlern oder falscher Dateninterpretation führen.

Schlussfolgerung

Sie haben soeben gelernt, wie man mit IronXL in C# die Daten einer CSV-Datei liest, parst und anzeigt. Dieser Ansatz kann auf verschiedene Arten von Datenstrukturen und Dateiformaten angewendet werden. Dies ist also eine insgesamt nützliche Fähigkeit für jeden Entwickler, der C# als Hauptsprache seiner Wahl einsetzt.

IronXL bietet eine kostenlose Testversion an, damit Nutzer die Funktionen erleben können. Sobald die Testphase endet, beginnt die Lizenzierung für IronXL zu einem Startpreis von $749.

Denken Sie daran, dass Ausnahmen und Randfälle behandelt werden müssen, um einen robusteren Code zu schreiben, insbesondere bei der Verwaltung verschiedener Datentypen und der Verwendung großer Dateien. Experimentieren Sie weiter und erkunden Sie weitere Funktionen von IronXL, um die Verarbeitung Ihrer Daten in C# zu verbessern. Viel Spaß beim Programmieren!