Streams schließen und Ressourcen freigeben ( using)

1. Wie gibt man Ressourcen in C# richtig frei?

Stell dir das Betriebssystem wie einen strengen Bibliothekar vor. Du hast ein Buch ausgeliehen (eine Datei/Stream geöffnet), liest darin und... vergisst es zurückzugeben! Der Bibliothekar ist sauer: "Wie, das Buch ist immer noch bei dir?!" Genau so ist es mit Streams. Ein offener Stream belegt Ressourcen: einen File Descriptor, ein Stück Speicher und blockiert die Datei für andere Programme.

Wenn du den Stream nicht schließt, kann das Ergebnis von "irgendwas funktioniert nicht" bis zu "alles ist kaputt, niemand kann mehr in diese Datei schreiben" reichen. Und wenn im Programm viele Streams nicht geschlossen werden, kann das System anfangen, Ressourcen zu "verlieren" und einfach nicht mehr funktionieren.

Wo liegt die Gefahr?

• Datei wird nicht geschlossen, Befehle kommen nicht auf die Festplatte (zum Beispiel beim Schreiben – Daten können im Puffer bleiben).
• Datei wird für andere Prozesse blockiert – Kollegen und andere Programme sind genervt.
• Descriptor-Limit: Unter Windows/Linux gibt es Limits für offene Dateien/Streams pro Prozess.

Interface IDisposable

Jede Klasse, die mit unmanaged Ressourcen arbeitet (Streams, Dateien, Datenbanken, Sockets), muss das Interface IDisposable implementieren.

public interface IDisposable
{
    void Dispose();
}

Im Dispose()-Methode werden normalerweise alle unglücklichen Ressourcen freigegeben: Die Datei wird endlich geschlossen, Verbindungen getrennt, Speicher freigegeben.

Streams sind Objekte, die wichtige Ressourcen halten: Dateien, Verbindungen, Speicher. Wenn du sie nicht schließt, bleibt die Datei vielleicht gesperrt (dein Word sagt dann "Datei ist von einer anderen Anwendung geöffnet!"), und das System bleibt ohne Speicher. Deshalb ist es superwichtig, den Stream nach der Arbeit freizugeben.

In .NET implementieren Streams das Interface IDisposable. Das heißt: Du musst sie schließen, indem du Dispose() aufrufst (oder sie einfach in einen using-Block packst).

2. Varianten, einen Stream zu schließen: von gefährlich bis zuverlässig

Variante 1. "Manuelles" Schließen: Mach das lieber nicht!

Das ist die alte Methode. Und auch wenn ich sie in früheren Beispielen gezeigt habe, benutzt das heute eigentlich niemand mehr :P

var stream = new FileStream("file.txt", FileMode.Open);
// Wir arbeiten mit dem Stream
stream.Close(); // oder stream.Dispose()

Problem: Wenn zwischen Öffnen und Schließen ein Fehler/Ausnahme passiert, bleibt die Datei offen und gesperrt. Das ist, als würdest du mit dem ausgeliehenen Buch aus der Bibliothek rennen, weil du plötzlich Pizzaduft riechst...

Variante 2. Mit try...finally

FileStream stream = null;
try
{
    stream = new FileStream("file.txt", FileMode.Open);
    // Wir arbeiten mit dem Stream
}
finally
{
    if (stream != null)
        stream.Dispose();
}

Diese Variante ist zuverlässig: finally wird garantiert auch bei Fehlern ausgeführt. Aber mal ehrlich, das zu schreiben ist schon nervig.

Variante 3. Schön und sicher: Der using-Operator

Klassische Syntax (using ( ... ) { ... })

using (var stream = new FileStream("file.txt", FileMode.Open))
{
    // Wir arbeiten mit dem Stream
}
// Hier wird stream.Dispose() automatisch aufgerufen!

Der springende Punkt: Alles, was im using-Block steht, arbeitet mit dem Stream, und wenn der Block endet, wird die Datei geschlossen – selbst wenn etwas schiefgeht (z.B. eine Ausnahme geworfen wird).

Variante 4. Moderne Syntax

Moderne Syntax (using var)

using var stream = new FileStream("file.txt", FileMode.Open);
// Wir arbeiten mit dem Stream
// ... Dispose wird automatisch aufgerufen, wenn die Variable aus dem Scope geht

Nice! Keine unnötigen Einrückungen und geschweiften Klammern mehr.

Wie funktioniert das "unter der Haube"?

Der using-Operator wird vom Compiler in genau dieses try...finally umgewandelt – aber für dich automatisch. Witz: "using schreibt sauberen Code für dich – vielleicht trinkt es bald auch Kaffee und hängt auf Stack Overflow ab?".

Unterschied zwischen klassischem und modernem using

using (var x = ...) { ... }

using var x = ...; ...

3. Was sind using-Deklarationen?

Vor 5 Jahren hat die Welt eine neue, kompakte Art gesehen, mit IDisposable-Objekten zu arbeiten.

using-Deklaration – das ist, wenn du statt eines Blocks eine Variable mit dem Schlüsselwort using deklarierst, und sie wird automatisch am Ende des aktuellen Blocks (z.B. Methode oder Schleife) freigegeben, nicht am Ende der geschweiften Klammern eines extra Blocks.

using var stream = new FileStream("file.txt", FileMode.Open);
// Wir arbeiten mit dem Stream
Console.WriteLine(stream.Length);

// Hier ist die Datei immer noch offen!

// ... Ende der Methode
// stream.Dispose() wird hier automatisch aufgerufen

Wichtige Unterschiede zum klassischen using:

• Keine geschweiften Klammern nötig, kein verschachtelter Codeblock wird erzeugt.
• Die Variable ist bis zum Ende des gesamten Blocks verfügbar, in dem sie deklariert wurde (meist Methode, manchmal Schleife, Klasse, wenn auf Klassenebene deklariert).
• Die Ressource wird erst freigegeben, wenn der Ausführungsblock endet.

Warum ist das cool?

• Weniger Verschachtelung – der Code ist viel kürzer und lesbarer.
• Einfacher mit mehreren Ressourcen – deklariere mehrere using-Variablen hintereinander, alles wird freigegeben, wenn die Methode endet.
• Weniger Fehlerquellen – du verpasst nicht den Scope, in dem du Dispose() hättest aufrufen müssen.

4. Vergleich: klassisch vs. modern using

Lass uns den Vergleich als Code anschauen.

Klassische Methode

using (var reader = new StreamReader("input.txt"))
{
    using (var writer = new StreamWriter("output.txt"))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            writer.WriteLine(line.ToUpper());
        }
    }
} // Hier werden beide Dateien geschlossen

Moderne Methode (C# 8+)

using var reader = new StreamReader("input.txt");
using var writer = new StreamWriter("output.txt");

string line;
while ((line = reader.ReadLine()) != null)
{
    writer.WriteLine(line.ToUpper());
}
// Beide Dateien werden hier, beim Verlassen der Methode, geschlossen

Sieht einfacher aus, oder? Besonders wenn du noch mehr verschachtelst – die moderne Methode macht das Leben deutlich leichter.

5. Wann und wo wird Dispose() aufgerufen?

Hier machen Anfänger oft einen Fehler: Sie denken, dass Dispose direkt nach der Benutzung aufgerufen wird – aber das stimmt nicht!

Schau dir dieses Beispiel an:

void MyMethod()
{
    using var fileStream = new FileStream("data.bin", FileMode.Open);
    // ... viel Code, vielleicht sogar Schleifen und verschachtelte Aufrufe
    // fileStream ist immer noch offen!

    // Hier kannst du noch auf fileStream zugreifen
}
// Hier, bei der } der Methode, wird fileStream.Dispose() aufgerufen

Wichtig: Wenn du eine using-Variable in einer Schleife deklarierst, wird Dispose nach jeder Iteration aufgerufen.

foreach (var path in filePaths)
{
    using var reader = new StreamReader(path);
    // wir arbeiten mit reader
} // reader.Dispose() wird nach jeder Iteration aufgerufen (schließt die Datei)

6. Fehler beim Übertragen von altem Code

Manchmal überträgst du alten Code oder kopierst ein Beispiel mit klassischem using, aber die Variable braucht eine längere "Lebensdauer" als der Scope der Klammern. Dann passt die klassische Variante nicht, aber using-Deklarationen sind perfekt.

Aber es gibt Feinheiten. Zum Beispiel, wenn du in einer Schleife zwei Ressourcen hast, aber eine davon soll länger "leben" als die andere – deklariere sie in der richtigen Reihenfolge:

using var resource1 = ...;
for (int i = 0; i < 10; i++)
{
    using var resource2 = ...;
    // resource2 lebt eine Iteration
    // resource1 – die ganze Funktion
}

7. Praxis

Wir machen weiter mit unserer Lern-App – einem kleinen Kaffee-Bestell-Simulator, den du in den letzten Tagen verbessert hast. Jetzt soll er die Bestellhistorie in eine Textdatei speichern und sie beim Start einlesen können.

Schritt 1: Bestellung in Datei speichern

using var writer = new StreamWriter("orders.txt", append: true);
writer.WriteLine("Kaffee: Latte; Milch: Hafer; Größe: Groß");

// Der zweite Parameter im StreamWriter-Konstruktor append: true gibt an, dass wir anhängen und nicht überschreiben wollen.

Schritt 2: Bestellhistorie lesen

using var reader = new StreamReader("orders.txt");
string? line;
while ((line = reader.ReadLine()) != null)
{
    Console.WriteLine($"Bestellung: {line}");
}

Und sobald das Programm diese Methode verlässt, werden die Dateien automatisch geschlossen.

8. Best Practices für using-Deklarationen

1. Verwende immer using für Objekte, die IDisposable implementieren
In .NET implementieren die meisten Klassen für Dateien, Streams, Ressourcen dieses Interface. Das ist das Signal: Gib mich mit using frei!

2. Denk an die Sichtbarkeit: Deklariere using-var nicht dort, wo die Variable "stört"
Wenn du die Variable nur für ein paar Zeilen brauchst – benutze sie da, wo du sie brauchst, und nicht früher.

3. Vergiss die Freigabereihenfolge nicht
Wenn du mehrere using-Variablen hintereinander deklarierst – Dispose wird in umgekehrter Reihenfolge aufgerufen:

using var first = new Resource("Erste");
using var second = new Resource("Zweite");
// ... Arbeit
// Erst Dispose für second, dann für first

Das ist manchmal wichtig, wenn eine Ressource von einer anderen abhängt (z.B. sollte der Schreibstream vor der Datei freigegeben werden).

4. Verwende using-Deklarationen nicht außerhalb von Methoden
using-Deklarationen sind auf Klassenebene (z.B. für Felder) verboten. Sie funktionieren nur innerhalb von Methoden, Konstruktoren usw.

5. Kombiniere mit Fehlerbehandlung
Denk daran, dass auch mit using nicht alle Ausnahmen bequem sind – es ist sinnvoll, try-catch hinzuzufügen, wenn du Fehler beim Lesen/Schreiben kontrollieren willst.