Mastering C# Systemdatei

Einführung

In C# bietet der Namensraum System.IO leistungsfähige Klassen für die Interaktion mit dem Dateisystem. Diese Klassen, wie zum Beispiel File, FileInfo, Directory und DirectoryInfo, ermöglichen Ihnen, eine Vielzahl von Dateioperationen durchzuführen, wie das Erstellen von Dateien, Lesen von Daten, Schreiben in Dateien und Überprüfen, ob eine bestimmte Datei bereits in einem angegebenen Pfad existiert. Mit diesen Klassen können Sie mit Textdateien, Binärdateien und Dateien mit verschiedenen Erweiterungen arbeiten. Methoden wie Create(), Exists() und Delete() erlauben es Entwicklern, Dateien und Verzeichnisse effektiv zu verwalten.

Zum Beispiel enthält die File-Klasse statische Methoden, um zu überprüfen, ob eine Datei bereits existiert, eine neue Datei zu erstellen oder Dateien in verschiedenen Modi zu öffnen (wie Lesen, Schreiben oder Anhängen). Sie können auch die FileInfo-Klasse verwenden, um mehr Details über eine Datei zu erhalten, wie zum Beispiel die Erstellungszeit oder den vollständigen Pfad. Die DirectoryInfo-Klasse erlaubt es Ihnen, mit Verzeichnissen zu arbeiten, Dateien zu erhalten oder neue Verzeichnisse zu erstellen. Diese Klassen und Methoden bieten die Flexibilität, sowohl bestehende als auch neue Dateien zu behandeln, mehrere Dateien zu verwalten und sogar Dateidaten auf Byte-Ebene zu behandeln, was C# zu einem leistungsstarken Werkzeug für Dateisystemoperationen macht.

Tim beginnt damit, die leistungsstarken Funktionen von C# für die Automatisierung von Dateiaufgaben hervorzuheben, wie z. B. das Erstellen von Backups, das Organisieren von Dateien und das Abrufen von Dateiinformationen. Er leitet das Video ein, indem er sein Ziel erklärt, das Erlernen von C# durch praktische Beispiele und Schulungsressourcen zu erleichtern.

Erstellen einer Demo-Konsolenanwendung

Tim beginnt bei Null und erstellt eine neue Konsolenanwendung mit dem Namen "FileSystemDemo" unter Verwendung des .NET Frameworks. Er betont, dass er für diese Demonstration das .NET Framework gegenüber .NET Core bevorzugt.

using System;
using System.IO;

namespace FileSystemDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
        }
    }
}

using System;
using System.IO;

namespace FileSystemDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
        }
    }
}

Einrichten des Wurzelpfads

Tim richtet eine Root-Pfad-Variable ein, die auf ein bestimmtes Verzeichnis in seinem System für die Demo verweist.

string rootPath = @"C:\temp\demos\filesystem";

string rootPath = @"C:\temp\demos\filesystem";

Er erklärt, dass das @-Symbol ermöglicht, Backslashes im Pfad zu verwenden, ohne sie escapen zu müssen.

Lesen aller Verzeichnisse im Pfad

Tim demonstriert, wie man alle Verzeichnisse innerhalb des angegebenen Stammverzeichnispfades mit der Directory.GetDirectories-Methode abrufen kann.

string[] directories = Directory.GetDirectories(rootPath);
foreach (string directory in directories)
{
    Console.WriteLine(directory);
}

string[] directories = Directory.GetDirectories(rootPath);
foreach (string directory in directories)
{
    Console.WriteLine(directory);
}

Dieser Code gibt die vollständigen Pfade aller Unterverzeichnisse innerhalb des Stammverzeichnisses aus.

Rekursives Lesen von Unterverzeichnissen

Um Unterverzeichnisse in die Suche einzubeziehen, fügt Tim ein Suchmuster und Suchoptionen zur GetDirectories-Methode hinzu.

string[] allDirectories = Directory.GetDirectories(rootPath, "*", SearchOption.AllDirectories);
foreach (string directory in allDirectories)
{
    Console.WriteLine(directory);
}

string[] allDirectories = Directory.GetDirectories(rootPath, "*", SearchOption.AllDirectories);
foreach (string directory in allDirectories)
{
    Console.WriteLine(directory);
}

Durch diese Änderung wird sichergestellt, dass alle verschachtelten Unterverzeichnisse in die Suche einbezogen werden.

Lesen aller Dateien im Pfad

Tim zeigt, wie man alle Dateien innerhalb der Verzeichnisklasse und des angegebenen Stammverzeichnispfades mit der Directory.GetFiles-Methode abrufen kann.

string[] files = Directory.GetFiles(rootPath, "*.*", SearchOption.AllDirectories);
foreach (string file in files)
{
    Console.WriteLine(file);
}

string[] files = Directory.GetFiles(rootPath, "*.*", SearchOption.AllDirectories);
foreach (string file in files)
{
    Console.WriteLine(file);
}

Dieser Code gibt die vollständigen Pfade aller Dateien innerhalb des Stammverzeichnisses und seiner Unterverzeichnisse aus.

Dateinamen und Pfade extrahieren

Tim erklärt, wie man Dateinamen und Pfade mit der Path-Klasse extrahiert. Dazu gehört auch, dass der Dateiname ohne die Dateierweiterung und der Verzeichnisname jeder Datei angegeben wird.

foreach (string file in files)
{
    Console.WriteLine(Path.GetFileName(file)); // File name with extension
    Console.WriteLine(Path.GetFileNameWithoutExtension(file)); // File name without extension
    Console.WriteLine(Path.GetDirectoryName(file)); // Directory name
}

foreach (string file in files)
{
    Console.WriteLine(Path.GetFileName(file)); // File name with extension
    Console.WriteLine(Path.GetFileNameWithoutExtension(file)); // File name without extension
    Console.WriteLine(Path.GetDirectoryName(file)); // Directory name
}

Dieses Codeschnipsel demonstriert, wie man verschiedene Teile derselben Datei im angegebenen Pfad extrahiert und druckt.

Abrufen von Dateiinformationen

Tim um (12:10) demonstriert, wie man detaillierte Informationen über eine Datei mit der FileInfo-Klasse abrufen kann. Dazu gehören die Dateigröße, die Zeit des letzten Zugriffs, die Erstellungszeit und andere Attribute.

foreach (string file in files)
{
    FileInfo info = new FileInfo(file);
    Console.WriteLine($"{Path.GetFileName(file)}: {info.Length} bytes");
}

foreach (string file in files)
{
    FileInfo info = new FileInfo(file);
    Console.WriteLine($"{Path.GetFileName(file)}: {info.Length} bytes");
}

Dieses Codeschnipsel gibt den Dateinamen und seine Größe in Bytes aus. Tim erwähnt, dass man diese Größe in Kilobytes oder Megabytes umrechnen kann, indem man sie wiederholt durch 1024 teilt.

Er erklärt weiter, dass die FileInfo-Klasse weitere nützliche Eigenschaften bietet:

• LastWriteTime: Das letzte Mal, als die Datei geändert wurde.

• LastAccessTime: Das letzte Mal, als die Datei zugegriffen wurde.

• CreationTime: Die Erstellungszeit der Datei.

• Attributes: Die Dateiattribute, wie zum Beispiel schreibgeschützt oder archivieren.

Automating File System Tasks with C

Tim (15:11) erörtert, wie man C# zur Automatisierung verschiedener Dateisystemaufgaben verwendet. Dies kann die Erstellung von Verzeichnissen, die Überprüfung der Existenz von Dateien oder Verzeichnissen und andere sich wiederholende Aufgaben umfassen.

Überprüfen, ob ein Verzeichnis vorhanden ist

Tim zeigt, wie man überprüft, ob ein Verzeichnis mit der Directory.Exists-Methode existiert. Dies ist nützlich, um sicherzustellen, dass die erforderlichen Verzeichnisse vorhanden sind, bevor Operationen durchgeführt werden.

string newPath = @"C:\temp\demos\filesystem\subfolderC";
if (Directory.Exists(newPath))
{
    Console.WriteLine("Directory exists");
}
else
{
    Console.WriteLine("Directory does not exist");
}

string newPath = @"C:\temp\demos\filesystem\subfolderC";
if (Directory.Exists(newPath))
{
    Console.WriteLine("Directory exists");
}
else
{
    Console.WriteLine("Directory does not exist");
}

Dieser Code prüft, ob ein Verzeichnis vorhanden ist, und gibt eine entsprechende Meldung aus.

Erstellen eines neuen Verzeichnisses

Tim erklärt, wie man ein neues Verzeichnis mit der Directory.CreateDirectory-Methode erstellt. Mit dieser Methode werden alle Verzeichnisse und Unterverzeichnisse im angegebenen Pfad erstellt, sofern sie noch nicht vorhanden sind.

string newPath = @"C:\temp\demos\filesystem\subfolderC\sub-subfolderD";
Directory.CreateDirectory(newPath);
Console.WriteLine("Directories created");

string newPath = @"C:\temp\demos\filesystem\subfolderC\sub-subfolderD";
Directory.CreateDirectory(newPath);
Console.WriteLine("Directories created");

Tim demonstriert, dass diese Methode den angegebenen Pfad und seine Unterverzeichnisse erstellt, ohne vorhandene Dateien oder Verzeichnisse zu überschreiben.

Kopieren von Dateien

Tim um (21:35) demonstriert, wie man Dateien von einem Verzeichnis in ein anderes mit der File.Copy-Methode kopiert. Dies kann für das Sichern von Dateien oder das Organisieren von Dateien in verschiedenen Ordnern nützlich sein.

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Copy(file, destFile, true);
}

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Copy(file, destFile, true);
}

In diesem Beispiel werden Dateien aus dem Stammverzeichnis nach subfolderA kopiert, und vorhandene Dateien werden aufgrund des true-Parameters überschrieben.

Umbenennung von Dateien beim Kopieren

Tim zeigt auch, wie man Dateien während des Kopiervorgangs umbenennen kann, indem man eine for-Schleife mit einem Index verwendet.

for (int i = 0; i < files.Length; i++)
{
    string destFile = Path.Combine(destinationFolder, $"{i}.txt");
    File.Copy(files[i], destFile, true);
}

for (int i = 0; i < files.Length; i++)
{
    string destFile = Path.Combine(destinationFolder, $"{i}.txt");
    File.Copy(files[i], destFile, true);
}

Dieser Code kopiert Dateien in das Zielverzeichnis und benennt sie sequentiell in 0.txt, 1.txt usw. um.

Behandlung von Dateiüberschreibungen

Tim erklärt, wie man vorhandene Dateien ohne Überschreibungen behandelt und Ausnahmen vermeidet, indem man den Überschreibparameter auf false setzt. Dadurch wird verhindert, dass bestehende Dateien überschrieben werden, und es wird eine Ausnahme ausgelöst, wenn eine Datei bereits existiert.

try
{
    File.Copy(sourceFile, destFile, false);
}
catch (IOException ex)
{
    Console.WriteLine($"File already exists: {ex.Message}");
}

try
{
    File.Copy(sourceFile, destFile, false);
}
catch (IOException ex)
{
    Console.WriteLine($"File already exists: {ex.Message}");
}

Dieser Ansatz hilft bei der sicheren Verwaltung von Dateikopien und beim Umgang mit Situationen, in denen Dateien nicht überschrieben werden sollten.

Dateien verschieben

Tim um (28:28) demonstriert, wie man Dateien mit der File.Move-Methode verschiebt. Im Gegensatz zu File.Copy hat die File.Move-Methode keine Überschreiboption und wirft eine Ausnahme, wenn die Zieldatei bereits existiert.

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Move(file, destFile);
}

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Move(file, destFile);
}

Dieser Code verschiebt Dateien vom Stammverzeichnis nach subfolderA und entfernt sie aus dem Quellverzeichnis.

Erstellung von Utility Apps

Tim ermutigt Entwickler, über verschiedene Möglichkeiten nachzudenken, wie sie C# verwenden können, um Dateisystemaufgaben zu automatisieren und Dienstprogramme zu erstellen. Er schlägt vor, mit einfachen Aufgaben zu beginnen und nach und nach komplexere Automatisierungslösungen zu entwickeln.

Beispiele für Utility-Apps:

• Temp-Dateien aufräumen: Automatisieren Sie den Prozess des Löschens temporärer Dateien, um Speicherplatz freizugeben.

• Backups auf externe Laufwerke: Erstellen Sie ein Backup-Tool, das wichtige Dateien auf ein externes Laufwerk kopiert.

• Projektordner-Synchronisierung: Synchronisieren Sie Projektordner zwischen einem Computer und einem USB-Stick, um sicherzustellen, dass die neuesten Änderungen immer gesichert und wiederhergestellt werden.

Abschluss

Tim Coreys Erkundung von Dateisystemoperationen in C# bietet praktische Einblicke in die Automatisierung von Dateiaufgaben und die Verwaltung von Verzeichnissen. Anhand seiner Beispiele können Entwickler routinemäßige Dateiverwaltungsaufgaben effizient automatisieren und benutzerdefinierte Dienstprogramme erstellen.

Um ein tieferes Verständnis zu erlangen und diese Konzepte in Aktion zu sehen, empfehle ich Ihnen, sich das vollständige Video von Tim Corey über das File System in C# anzusehen. Seine detaillierten Anleitungen und praktischen Beispiele werden Ihnen helfen, Ihr Verständnis zu festigen und Sie in die Lage versetzen, Ihre eigenen Dateiverwaltungsanwendungen zu erstellen.