Erstellen und Löschen von Dateien

1. Einführung

Es mag so aussehen, als sei eine Datei etwas Einfaches, und sie zu erstellen sei kinderleicht: einfach Rechtsklick (unter Windows). In echten Projekten ist das programmatische Erstellen und Löschen von Dateien aber zentral für Automatisierung und Flexibilität. Zum Beispiel:

• In einem Texteditor klickt der Benutzer auf „Speichern“ — und dein Code erstellt eine neue Datei, in die er die Arbeit des Autors schreibt.
• Ein Logging-Service erstellt automatisch Log-Dateien beim Start der Anwendung.
• Ein Archivprogramm oder Backup-Tool erstellt regelmäßig temporäre Dateien und löscht sie danach.
• Ein Spiel in C# macht Auto-Save — es erstellt oder überschreibt eine Save-Datei.
• Und du (oder dein Script) räumst automatisch alte Temp-Dateien aus einem Ordner, damit die Festplatte nicht vollmüllt.

Automatisches Erstellen und Löschen von Dateien zu beherrschen ist eine der grundlegenden Fähigkeiten eines modernen .NET-Entwicklers.

2. Schnelle Operationen über File

Eine Datei erstellen

In C# kann man eine Datei auf verschiedene Arten erstellen. Der schnellste und einfachste Weg ist die statische Klasse File. Probieren wir's:

// Wir erstellen eine leere Datei "myfile.txt" im aktuellen Verzeichnis
File.Create("myfile.txt").Close(); // FileStream muss geschlossen werden!
Console.WriteLine("Die Datei 'myfile.txt' wurde erstellt.");

Wichtiger Hinweis:
Die Methode File.Create liefert ein FileStream-Objekt zurück, das geschlossen werden muss (Close()), damit das OS nicht meckert, dass die Datei „belegt“ ist. Ohne das Schließen können manche weiteren Operationen auf derselben Datei unerwartet fehlschlagen. Klassiker: "Datei wird von einem anderen Prozess verwendet", wobei dieser „andere Prozess“ oft noch dein eigenes Programm ist, das den Stream nicht geschlossen hat.

Wenn die Datei schon existierte, überschreibt File.Create sie (die alte wird entfernt, eine neue leere wird an ihrer Stelle angelegt). Wenn die Datei nicht da war — sie erscheint.

Und was bringt eine leere Datei?

Meist braucht man die neue Datei nicht leer, sondern will etwas hinein schreiben. Dafür gibt es praktische Methoden:

File.WriteAllText("welcome.txt", "Privet, mir faylov!");

Der Befehl erstellt die Datei, schreibt die Zeichenkette hinein und schließt die Tür (also die Datei) sauber hinter sich, damit nichts Schlimmes passiert.

Existenz einer Datei prüfen

Bevor man eine neue Datei erstellt, ist es sinnvoll zu prüfen, ob sie nicht schon existiert. Sonst besteht die Gefahr, etwas Wichtiges versehentlich zu löschen.

if (!File.Exists("important.txt"))
{
    File.WriteAllText("important.txt", "Sokhranyaem vazhnuyu informatsiyu.");
    Console.WriteLine("Datei erstellt.");
}
else
{
    Console.WriteLine("So eine Datei gibt es schon, man kann sich was anderes überlegen!");
}

3. Praxisbeispiel: "Wir speichern die Begrüßung des Benutzers"

Console.Write("Vvedite vashe imya: ");
string name = Console.ReadLine();

string filename = $"{name}_greeting.txt";
string message = $"Dobro pozhalovat, {name}!";

// Prüfen, ob so eine Datei existiert
if (!File.Exists(filename))
{
    File.WriteAllText(filename, message);
    Console.WriteLine($"Die persönliche Begrüßungsdatei {filename} wurde erstellt.");
}
else
{
    Console.WriteLine($"Die Datei {filename} existiert bereits! Überschreiben? (y/n)");
    string answer = Console.ReadLine();
    if (answer?.ToLower() == "y")
    {
        File.WriteAllText(filename, message);
        Console.WriteLine($"Die Datei {filename} wurde überschrieben.");
    }
    else
    {
        Console.WriteLine("Wir lassen alles wie es ist.");
    }
}

Was wir hier machen:

• Prüfen, ob die Datei existiert (File.Exists).
• Wenn nicht — erstellen und Text schreiben (File.WriteAllText).
• Wenn sie existiert — fragen wir den Benutzer, ob überschrieben werden soll.

4. Datei löschen

Dateien in C# zu löschen ist fast schon hackerhaft... aber sicher! Auch hier ist alles einfach:

Mit File.Delete arbeiten

File.Delete("myfile.txt");

Wenn die Datei nicht existiert — kein Drama! Es passiert einfach nichts (es werden keine Fehler geworfen, solange der Pfad korrekt ist).

Fallen für Anfänger

• Wenn die Datei bereits von deinem Programm (oder jemand anderem) geöffnet ist, wird eine Ausnahme geworfen.
• Wenn der Pfad falsch angegeben ist — gibt es eine ArgumentException.

Empfehlung: immer Existenz prüfen

if (File.Exists("victim.txt"))
{
    File.Delete("victim.txt");
    Console.WriteLine("Datei gelöscht.");
}
else
{
    Console.WriteLine("Nichts zu löschen — diese Datei wurde nicht gefunden.");
}

5. Ordner und Dateien: Datei-Struktur erstellen

Datei in einem Ordner erstellen

string folder = "Data";
Directory.CreateDirectory(folder); // wenn der Ordner nicht existiert — wird erstellt

string filename = Path.Combine(folder, "info.txt");
File.WriteAllText(filename, "Zdes khranit'sya sekretnoe poslanie!");

Wichtig: Wenn du versuchst, eine Datei in einem nicht existierenden Ordner zu erstellen, wird eine Ausnahme geworfen. Daher macht es Sinn, zuerst Directory.CreateDirectory(folder) aufzurufen. Diese Methode erstellt den Ordner nicht nochmal, wenn er schon existiert — der Aufruf ist also sicher.

6. Arbeiten mit Instanzen: FileInfo

Für „oldschool“- und etwas fortgeschrittenere Szenarien ist die Klasse FileInfo praktisch:

FileInfo fi = new FileInfo("example.txt");

// Neue Datei erstellen (wie File.Create — erstellt eine leere Datei)
using (var fs = fi.Create())
{
    // man kann etwas schreiben, wenn man will
}

Console.WriteLine($"Die Datei 'example.txt' wurde mit FileInfo erstellt.");

Löschen mit FileInfo:

FileInfo fi = new FileInfo("oldfile.txt");
if (fi.Exists)
{
    fi.Delete();
    Console.WriteLine("Datei mit FileInfo gelöscht.");
}

Vorteile von FileInfo

Wenn du nicht nur erstellen/löschen willst, sondern oft auf Dateieigenschaften zugreifst oder verschiedene Aktionen auf derselben Datei ausführst, ist der instanzbasierte Ansatz praktisch (und manchmal performanter).

7. Wir erstellen und bereinigen "technische Dateien"

Angenommen, die Anwendung sammelt temporäre Dateien in einem Ordner "temp_data", und wir wollen alle Dateien in diesem Ordner löschen, deren Namen mit "temp_" beginnen.

string tempFolder = "temp_data";
Directory.CreateDirectory(tempFolder);

for (int i = 1; i <= 5; i++)
{
    string tempFile = Path.Combine(tempFolder, $"temp_{i}.txt");
    File.WriteAllText(tempFile, $"Testovye dannye {i}");
}
Console.WriteLine("5 temporäre Dateien erstellt.");

// Jetzt löschen wir alle temp_*.txt
foreach (string file in Directory.GetFiles(tempFolder, "temp_*.txt"))
{
    File.Delete(file);
    Console.WriteLine($"Gelöscht: {file}");
}

Funktioniert super zur automatischen Bereinigung alter und temporärer Dateien.

8. Wichtige Details: Ausnahmen und Sicherheit

Was schiefgehen kann:

• Keine Schreib-/Löschrechte im Ordner (z.B. C:\Windows).
• Die Datei ist bereits von einem anderen Programm (oder deinem!) belegt.
• Der Pfad enthält unzulässige Zeichen (z.B. *?<>).
• Die Datei wurde zwischen deiner Prüfung und dem Löschen von einem anderen Prozess entfernt (ja, das passiert!).

Wie man sich schützt

In Produktionscode sollte man solche Operationen immer in einen try-catch-Block packen:

try
{
    File.Delete("trickyfile.txt");
    Console.WriteLine("Datei gelöscht.");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine("Keine Berechtigung zum Löschen der Datei.");
}
catch (IOException ex)
{
    Console.WriteLine("Die Datei könnte von einem anderen Prozess verwendet werden.");
}
catch (Exception ex)
{
    Console.WriteLine($"Fehler: {ex.Message}");
}

9. Nützliche Feinheiten

Dateien, die man immer im Griff haben sollte

• Verwende Path.Combine zum Zusammensetzen von Pfaden. So vermeidest du Probleme mit fehlenden oder doppelten Slashes und dein Code bleibt cross-platform.
• Prüfe die Existenz der Datei vor Erstellen/Löschen, wenn du keine Überraschungen willst.
• Packe deinen Code in try-catch, besonders in Produktions- oder „Multiuser“-Anwendungen.
• Für häufige Operationen auf derselben Datei nutze FileInfo, für einmalige Operationen — File.
• Halte Dateien nicht länger offen als nötig. Datei offen? Frag dich: "Zachem?" und schließe sie! Nutze using, wo es möglich ist.

Technische Spickzettel

File.Create

File.WriteAllText

File.Exists

File.Delete

Directory.CreateDirectory + File.WriteAllText

new FileInfo(path).Create / Delete / Exists

10. Typische Fehler bei der Arbeit mit Dateien

Fehler Nr.1: Den Stream nach File.Create nicht schließen.
Viele Anfänger erstellen eine Datei mit File.Create, schließen den zurückgegebenen Stream aber nicht. Dadurch sieht der restliche Code die Datei nicht mehr — als wäre sie in einer parallelen Welt verschwunden. Schließe den Stream explizit (Close()) oder verwende die using-Konstruktion.

Fehler Nr.2: Versuch, eine Datei in einem nicht existierenden Ordner zu erstellen.
Typische Falle ist der Versuch, eine Datei in einem Verzeichnis zu erstellen, das noch nicht existiert. Vergiss nicht, vorher Directory.CreateDirectory aufzurufen. Das ist völlig sicher: es erstellt nichts „überflüssiges“, und der benötigte Ordner wird angelegt.

Fehler Nr.3: Datei ohne Prüfung löschen.
Manchmal ruft man einfach File.Delete auf, ohne zu prüfen, ob die Datei existiert. Das ist grundsätzlich okay — die Methode wirft keinen Fehler, wenn die Datei fehlt. Aber wenn der Pfad falsch ist oder es an Rechten mangelt, dann gibt es trotzdem eine Ausnahme. Besser ist es, das vorher abzufangen.

Fehler Nr.4: Verwechseln von File.Delete und Directory.Delete.
File.Delete ist nur für Dateien, Directory.Delete für Ordner. Wenn du versuchst, einen Ordner mit File.Delete zu löschen, ist das so, als würdest du versuchen, einen Ziegelstein mit einer Zahnbürste zu polieren: technisch nicht sinnvoll.