C# Datei lesen und schreiben

Tim Corey

24m 34s

Dateieingabe- und -ausgabeoperationen (E/A) in C# sind ein wesentlicher Bestandteil vieler Softwareanwendungen, die es Entwicklern ermöglichen, effizient von Dateien zu lesen und in Dateien zu schreiben. Ob Sie Daten speichern, Anwendungsereignisse protokollieren oder große Mengen an Text- oder Binärdaten verarbeiten, C# bietet robuste Werkzeuge für die Arbeit mit Dateien. Im Video von Tim Corey, "C# Data Access: Text Files" bietet er einen detaillierten Überblick über diese Dateioperationen, wobei er sich darauf konzentriert, wie man Textdateien sowohl für die Datenspeicherung als auch für den Datenabruf verwendet. Dieser Artikel fasst die wichtigsten Konzepte und Techniken zusammen, die Tim im Video behandelt, und gibt Ihnen einen praktischen Einblick in die Datei-I/O-Operationen in C#.

Einführung

In C# sind Dateieingabe- und -ausgabeoperationen für das Lesen von und Schreiben in Textdateien unerlässlich. Die File-Klasse bietet statische Methoden zum Interagieren mit vorhandenen Dateien oder Erstellen neuer an. StreamReader und StreamWriter werden häufig zum Lesen und Schreiben von Dateien verwendet. StreamReader liest Dateien zeilenweise, sodass Sie auf jede Textzeile oder ein Array von Zeichenketten zugreifen können. Sie können auch die while Schleife verwenden, um größere Dateien effizient zu lesen. Die StreamWriter-Klasse wird verwendet, um Daten in eine Datei zu schreiben, und unterstützt das Schreiben von Zeichenketten und Arrays. Sie kann verwendet werden, um Text an eine bestehende Datei anzuhängen oder die gesamte Datei zu überschreiben. Methoden wie WriteLine und WriteText ermöglichen eine einfache Datenmanipulation innerhalb von Textdateien.

Diese Operationen werden typischerweise innerhalb der static void Main-Methode durchgeführt, wo Sie den Dateipfad angeben. Zum Beispiel können Sie einen Dateinamen angeben und StreamWriter verwenden, um eine einzelne Zeichenkette oder ein ganzes Zeichenkettenarray zu schreiben. Die using-Anweisung stellt sicher, dass die Datei nach den Operationen ordnungsgemäß geschlossen wird, um Ressourcenlecks zu verhindern. StreamReader kann auch verwendet werden, um Dateien zeilenweise zu lesen, und Ausnahmen können gehandhabt werden, um potenzielle Fehler zu verwalten, wenn die Datei nicht existiert oder nicht zugänglich ist. Diese Datei-E/A-Fähigkeiten machen C# zu einer ausgezeichneten Wahl für die effiziente und effektive Arbeit mit Dateien.

Tim führt in das Thema ein, indem er die Einfachheit des Lesens aus und Schreibens in Textdateien in C# hervorhebt. Er zeigt, wie ein paar Zeilen Code diese Aufgaben erfüllen können und Textdateien zu einer praktikablen Option für die Datenspeicherung machen.

Erstellen einer Demo-Konsolenanwendung

Tim beginnt mit der Erstellung einer neuen Konsolenanwendung namens "TextFileDataAccessDemo" mit Visual Studio.

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace TextFileDataAccessDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine(); // Keeps the console window open to view the output
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace TextFileDataAccessDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine(); // Keeps the console window open to view the output
        }
    }
}

Imports System
Imports System.IO
Imports System.Collections.Generic
Imports System.Linq

Namespace TextFileDataAccessDemo
    Class Program
        Shared Sub Main(ByVal args As String())
            Console.ReadLine() ' Keeps the console window open to view the output
        End Sub
    End Class
End Namespace

Imports System
Imports System.IO
Imports System.Collections.Generic
Imports System.Linq

Namespace TextFileDataAccessDemo
    Class Program
        Shared Sub Main(ByVal args As String())
            Console.ReadLine() ' Keeps the console window open to view the output
        End Sub
    End Class
End Namespace

Er erklärt die Verwendung von Console.ReadLine, um das Konsolenfenster offen zu halten, damit Benutzer die Ausgabe sehen können.

Lesen aus einer Textdatei

Tim demonstriert, wie man mithilfe der File.ReadAllLines-Methode aus einer Textdatei liest. Er zeigt, wie man Dateipfade behandelt und Stringliterale verwendet, um Escape-Zeichen zu vermeiden.

string filePath = @"C:\demos\test.txt";
List<string> lines = File.ReadAllLines(filePath).ToList();

string filePath = @"C:\demos\test.txt";
List<string> lines = File.ReadAllLines(filePath).ToList();

Dim filePath As String = "C:\demos\test.txt"
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

Dim filePath As String = "C:\demos\test.txt"
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

Die File.ReadAllLines-Methode liest alle Zeilen aus der angegebenen Datei und gibt sie als Array von Zeichenketten zurück. Tim konvertiert dieses Array in eine Liste, um die Bearbeitung zu erleichtern.

Schreiben in eine Textdatei

Tim erklärt, wie man Daten mithilfe der File.WriteAllLines-Methode in eine Textdatei schreibt. Er demonstriert, wie man der Liste neue Zeilen hinzufügt und die aktualisierte Liste in die Datei zurückschreibt.

lines.Add("Sue,Storm,WWIStorm.com");
File.WriteAllLines(filePath, lines);

lines.Add("Sue,Storm,WWIStorm.com");
File.WriteAllLines(filePath, lines);

lines.Add("Sue,Storm,WWIStorm.com")
File.WriteAllLines(filePath, lines)

lines.Add("Sue,Storm,WWIStorm.com")
File.WriteAllLines(filePath, lines)

Dieser Code fügt der Liste einen neuen Eintrag hinzu und schreibt die gesamte Liste zurück in die Datei.

Erstellen eines Datenmodells und dessen Befüllung aus einer Datei

Tim erstellt eine Person-Klasse, um die Datenstruktur für jeden Eintrag in der Textdatei darzustellen.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string URL { get; set; }
}

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string URL { get; set; }
}

Public Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property URL As String
End Class

Public Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property URL As String
End Class

Er liest dann die Datei und füllt eine Liste von Person-Objekten.

List<Person> people = new List<Person>();
List<string> lines = File.ReadAllLines(filePath).ToList();

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    Person newPerson = new Person
    {
        FirstName = entries[0],
        LastName = entries[1],
        URL = entries[2]
    };
    people.Add(newPerson);
}

List<Person> people = new List<Person>();
List<string> lines = File.ReadAllLines(filePath).ToList();

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    Person newPerson = new Person
    {
        FirstName = entries[0],
        LastName = entries[1],
        URL = entries[2]
    };
    people.Add(newPerson);
}

Dim people As New List(Of Person)()
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    Dim newPerson As New Person With {
        .FirstName = entries(0),
        .LastName = entries(1),
        .URL = entries(2)
    }
    people.Add(newPerson)
Next

Dim people As New List(Of Person)()
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    Dim newPerson As New Person With {
        .FirstName = entries(0),
        .LastName = entries(1),
        .URL = entries(2)
    }
    people.Add(newPerson)
Next

Dieser Code liest jede Zeile, teilt sie durch Kommata und erstellt ein Person-Objekt mit den extrahierten Daten.

Zeichenfolgen-Interpolation

Tim stellt die String-Interpolation vor, eine Funktion in C# 6.0, die das Kombinieren von Variablen und Strings vereinfacht. Diese Methode verwendet das $-Symbol vor der Zeichenkette und geschweifte Klammern {}, um Variablen direkt innerhalb der Zeichenkette einzubetten.

foreach (var person in people)
{
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}");
}

foreach (var person in people)
{
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}");
}

For Each person In people
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}")
Next

For Each person In people
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}")
Next

Diese Syntax ist prägnanter und effizienter im Vergleich zu traditioneller Verkettung mit dem +-Operator.

Datenüberprüfung

Tim betont, wie wichtig die Validierung von Daten beim Lesen aus einer Textdatei ist. Er weist auf die Risiken hin, die entstehen, wenn man von der Struktur der Daten ausgeht, und empfiehlt, die Länge der geteilten Einträge zu überprüfen.

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    if (entries.Length == 3)
    {
        Person newPerson = new Person
        {
            FirstName = entries[0],
            LastName = entries[1],
            URL = entries[2]
        };
        people.Add(newPerson);
    }
    else
    {
        // Handle error
        Console.WriteLine("Invalid data format.");
    }
}

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    if (entries.Length == 3)
    {
        Person newPerson = new Person
        {
            FirstName = entries[0],
            LastName = entries[1],
            URL = entries[2]
        };
        people.Add(newPerson);
    }
    else
    {
        // Handle error
        Console.WriteLine("Invalid data format.");
    }
}

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    If entries.Length = 3 Then
        Dim newPerson As New Person With {
            .FirstName = entries(0),
            .LastName = entries(1),
            .URL = entries(2)
        }
        people.Add(newPerson)
    Else
        ' Handle error
        Console.WriteLine("Invalid data format.")
    End If
Next

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    If entries.Length = 3 Then
        Dim newPerson As New Person With {
            .FirstName = entries(0),
            .LastName = entries(1),
            .URL = entries(2)
        }
        people.Add(newPerson)
    Else
        ' Handle error
        Console.WriteLine("Invalid data format.")
    End If
Next

Dadurch wird sichergestellt, dass nur Zeilen mit der richtigen Anzahl von Einträgen verarbeitet werden, um mögliche Laufzeitfehler zu vermeiden.

Hinzufügen von Objekten zu einer Liste

Tim demonstriert, wie man neue Objekte zur Liste hinzufügt. Er verwendet eine anonyme Instanz der Person-Klasse, um eine neue Person zur Liste hinzuzufügen.

people.Add(new Person { FirstName = "Greg", LastName = "Jones", URL = "WOWT.com" });

people.Add(new Person { FirstName = "Greg", LastName = "Jones", URL = "WOWT.com" });

people.Add(New Person With {.FirstName = "Greg", .LastName = "Jones", .URL = "WOWT.com"})

people.Add(New Person With {.FirstName = "Greg", .LastName = "Jones", .URL = "WOWT.com"})

Dies erstellt und initialisiert ein neues Person-Objekt in einer einzigen Zeile, das dann zur people-Liste hinzugefügt wird.

Daten in eine Textdatei zurückschreiben

Tim erklärt, wie man die Liste von Person-Objekten zurück in die Textdatei schreibt. Er konvertiert die Liste von Person-Objekten in eine Liste von Zeichenketten, wobei jede Zeichenkette eine Zeile in der Datei darstellt.

List<string> output = new List<string>();
foreach (var person in people)
{
    output.Add($"{person.FirstName},{person.LastName},{person.URL}");
}
File.WriteAllLines(filePath, output);

List<string> output = new List<string>();
foreach (var person in people)
{
    output.Add($"{person.FirstName},{person.LastName},{person.URL}");
}
File.WriteAllLines(filePath, output);

Dim output As New List(Of String)()
For Each person In people
    output.Add($"{person.FirstName},{person.LastName},{person.URL}")
Next
File.WriteAllLines(filePath, output)

Dim output As New List(Of String)()
For Each person In people
    output.Add($"{person.FirstName},{person.LastName},{person.URL}")
Next
File.WriteAllLines(filePath, output)

Dieser Code durchläuft die people-Liste, erstellt einen CSV-String für jedes Person-Objekt und schreibt die Liste von Zeichenketten in die Datei.

Abschluss

Tim Coreys detaillierter Leitfaden zu Datei-E/A-Operationen in C# bietet praktische Einblicke in das Lesen von und Schreiben in Textdateien. Anhand seiner Beispiele können Entwickler Daten mithilfe von Textdateien effektiv verwalten und robuste Datenspeicherlösungen implementieren. Für ein tieferes Verständnis und eine praktische Lernerfahrung empfehle ich Ihnen das Video von Tim Corey, in dem er diese Konzepte anhand von Beispielen aus der Praxis vertieft.