Effizientes zeilenweises Lesen von Textdateien in C#

Das effiziente zeilenweise Lesen von Textdateien ist eine entscheidende Fähigkeit für jeden C#-Entwickler. Ob Sie Logdateien verarbeiten, Konfigurationsdateien parsen oder Datensätze analysieren, die gewählte Methode kann die Performance und die Ressourcennutzung erheblich beeinflussen. Dieser Artikel untersucht drei gängige Ansätze und hebt deren Stärken und Schwächen hervor, um Ihnen bei der Auswahl der optimalen Technik für Ihre spezifischen Bedürfnisse zu helfen.

Inhaltsverzeichnis

• Verwendung von File.ReadLines()
• Verwendung von File.ReadAllLines()
• Verwendung von StreamReader.ReadLine()
• Die richtige Methode auswählen

Verwendung von File.ReadLines()

Die Methode File.ReadLines() ist im Allgemeinen die effizienteste und bequemste Option, insbesondere für große Dateien. Sie liefert ein IEnumerable<string> zurück, d. h. sie verarbeitet die Datei zeilenweise, ohne den gesamten Inhalt auf einmal in den Speicher zu laden. Dieses Lazy Loading verhindert potenzielle OutOfMemoryException-Fehler beim Umgang mit riesigen Datensätzen.

using System;
using System.IO;
using System.Linq;

public class ReadLinesExample
{
    public static void Main(string[] args)
    {
        string filePath = "myFile.txt"; 

        try
        {
            foreach (string line in File.ReadLines(filePath))
            {
                Console.WriteLine(line); 
                //Verarbeiten Sie jede Zeile hier
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Datei nicht gefunden: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ein Fehler ist aufgetreten: {ex.Message}");
        }
    }
}

Verwendung von File.ReadAllLines()

File.ReadAllLines() bietet eine einfachere Syntax und liest alle Zeilen in ein String-Array ein. Dieser Ansatz lädt jedoch die gesamte Datei in den Speicher, was ihn für große Dateien ineffizient und potenziell problematisch macht. Er eignet sich am besten für kleinere Dateien, bei denen der Speicherverbrauch keine große Rolle spielt.

using System;
using System.IO;

public class ReadAllLinesExample
{
    public static void Main(string[] args)
    {
        string filePath = "myFile.txt";

        try
        {
            string[] lines = File.ReadAllLines(filePath);
            foreach (string line in lines)
            {
                Console.WriteLine(line); 
                //Verarbeiten Sie jede Zeile hier
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Datei nicht gefunden: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ein Fehler ist aufgetreten: {ex.Message}");
        }
    }
}

Verwendung von StreamReader.ReadLine()

StreamReader.ReadLine() bietet die feinste Kontrolle. Sie lesen eine Zeile nach der anderen mit einer Schleife und ermöglichen die benutzerdefinierte Verarbeitung jeder Zeile, bevor die nächste gelesen wird. Diese Methode erfordert ein explizites Ressourcenmanagement mit einer using-Anweisung, um die ordnungsgemäße Entsorgung des StreamReader sicherzustellen.

using System;
using System.IO;

public class StreamReaderExample
{
    public static void Main(string[] args)
    {
        string filePath = "myFile.txt";

        try
        {
            using (StreamReader reader = new StreamReader(filePath))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    Console.WriteLine(line); 
                    //Verarbeiten Sie jede Zeile hier
                }
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Datei nicht gefunden: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ein Fehler ist aufgetreten: {ex.Message}");
        }
    }
}

Die richtige Methode auswählen

Für die meisten Szenarien, insbesondere bei großen Dateien, ist File.ReadLines() aufgrund seiner Effizienz und Benutzerfreundlichkeit der empfohlene Ansatz. File.ReadAllLines() eignet sich nur für kleinere Dateien. StreamReader.ReadLine() bietet mehr Kontrolle, erfordert aber ein sorgfältigeres Ressourcenmanagement. Denken Sie daran, immer eine robuste Fehlerbehandlung einzubauen, um potenzielle Ausnahmen wie Dateifehler sauber zu behandeln.