Zugreifen auf Dateien und Ordner mit Windows App SDK und .NET

Verpackte Windows App SDK-Apps können .NET-APIs zum Lesen und Schreiben von Dateien, zum Arbeiten mit Ordnern sowie zum Lesen von Laufwerks- und Volumeinformationen nutzen. Darüber hinaus kann jede verpackte Desktop-App sowohl WinRT- als auch Win32-APIs im Windows SDK sowie die im .NET SDK bereitgestellten APIs verwenden. Dieser Artikel enthält Anleitungen zur Verwendung der .NET-System.IO-APIs zum Lesen und Schreiben von Dateien, zum Verwalten von Laufwerken und Ordnern sowie zum Arbeiten mit Speicherstreams zum Codieren oder Decodieren von Zeichenfolgendaten.

Lesen und Schreiben von Dateien mit .NET-APIs

Im folgenden Beispiel erstellt ReadWriteFiles eine neue Datei, schreibt einen Satz ganzer Zahlen in die Datei und liest dann wiederum die ganzen Zahlen aus der Datei. Im Beispiel wird die FileStream-Klasse verwendet, um eine neue Datei zu erstellen und die Datei zum Lesen oder Schreiben zu öffnen. Im Beispiel wird die BinaryWriter-Klasse verwendet, um die ganzen Zahlen in die Datei zu schreiben, und die BinaryReader-Klasse, um die ganzen Zahlen aus der Datei zu lesen.

using System.IO;
...
ReadWriteFiles("test.bin");
...
private void ReadWriteFiles(string fileName)
{
    if (File.Exists(fileName))
    {
        Console.WriteLine($"{fileName} already exists!");
        return;
    }

    using (FileStream fs = new(fileName, FileMode.CreateNew))
    {
        using BinaryWriter writer = new(fs);
        for (int i = 0; i < 11; i++)
        {
            writer.Write(i);
        }
    }

    using (FileStream fs = new(fileName, FileMode.Open, FileAccess.Read))
    {
        using BinaryReader reader = new(fs);
        for (int i = 0; i < 11; i++)
        {
            Console.WriteLine(reader.ReadInt32());
        }
    }
}

Verwalten von Laufwerken und Ordnern in .NET

Das folgende Beispiel zeigt, wie Sie die DirectoryInfo- und Directory-Klassen verwenden, um Ordner zu erstellen, zu löschen und zu verwalten. Im Beispiel wird die DirectoryInfo-Klasse verwendet, um ein neues Verzeichnis zu erstellen, ein Unterverzeichnis zu erstellen und das Verzeichnis zu löschen. Die DirectoryInfo-Klasse stellt Methoden zum Erstellen, Verschieben und Auflisten von Verzeichnissen und Unterverzeichnissen zur Verfügung. Die Directory-Klasse stellt statische Methoden zum Erstellen, Verschieben und Auflisten von Verzeichnissen und Unterverzeichnissen zur Verfügung.

using System.IO;
...
private void FolderTest()
{
    FolderManagement(@"c:\MyDir", "Projects");
}
private void FolderManagement(string path, string subfolderName)
{
    DirectoryInfo di = new(path);
    try
    {
        // Create directory if it doesn't exist
        if (di.Exists)
        {
            Console.WriteLine("Path already exists.");
        }
        else
        {
            di.Create();
            Console.WriteLine("The directory was created successfully.");
        }

        // Create subdirectory if it doesn't exist
        string subfolderPath = Path.Combine(path, subfolderName);
        if (Directory.Exists(subfolderPath))
        {
            Console.WriteLine("Subfolder path already exists.");
        }
        else
        {
            di.CreateSubdirectory(subfolderName);
            Console.WriteLine("The subdirectory was created successfully.");
        }

        // Delete directory
        di.Delete(true);
        Console.WriteLine("The directory was deleted successfully.");
    }
    catch (Exception ex)
    {
        Console.WriteLine("The process failed: {0}", ex.ToString());
    }
}

In diesem Beispiel wird die statische GetDrives-Methode verwendet, um Informationen zu allen Laufwerken im System abzurufen. Die DriveInfo-Klasse stellt Informationen zu einem Laufwerk bereit, z. B. Laufwerktyp, Bezeichnung, Dateisystem und verfügbaren freien Speicherplatz.

using System.IO;
...
private void DriveManagement()
{
    DriveInfo[] drives = DriveInfo.GetDrives();

    foreach (DriveInfo d in drives)
    {
        Console.WriteLine($"Drive name: {d.Name}");
        Console.WriteLine($"  Drive type: {d.DriveType}");
        if (d.IsReady)
        {
            Console.WriteLine($"  Volume label: {d.VolumeLabel}");
            Console.WriteLine($"  File system type: {d.DriveFormat}");
            Console.WriteLine($"  Space available to user: {d.AvailableFreeSpace, 15} bytes");
            Console.WriteLine($"  Total available space: {d.TotalFreeSpace, 15} bytes");
            Console.WriteLine($"  Total size of drive: {d.TotalSize, 15} bytes ");
        }
    }
}

Codieren und Decodieren von Zeichenfolgen mit MemoryStream

In diesem Beispiel wird gezeigt, wie die MemoryStream-Klasse zum Codieren und Decodieren von Zeichenfolgendaten verwendet wird. Zuerst wird ein MemoryStream erstellt, um eine Zeichenfolge asynchron in einen Speicherdatenstrom zu schreiben und dann die Zeichenfolge aus dem Speicherdatenstrom zu lesen. Die Encoding-Klasse wird verwendet, um die Zeichenfolge in ein Bytearray zu konvertieren und dann das Bytearray in den Speicherdatenstrom zu schreiben. Ein StreamReader wird dann verwendet, um das Bytearray asynchron aus dem Speicherdatenstrom zu lesen und das Bytearray dann durch Aufrufen von ReadToEndAsync wieder in eine Zeichenfolge zu konvertieren.

using System.IO;
using System.Text;
...
private async Task EncodeDecodeStringAsync(string inputData)
{
    using MemoryStream stream = new();
    var inputBytes = Encoding.UTF8.GetBytes(inputData);
    await stream.WriteAsync(inputBytes, 0, inputBytes.Length);
    stream.Seek(0, SeekOrigin.Begin);

    using StreamReader reader = new(stream);
    string text = await reader.ReadToEndAsync();
    Console.WriteLine(text);
}

Hinweis

Informationen zum Konvertieren zwischen .NET-Streams und WinRT-Streams finden Sie unter Vorgehensweise: Konvertieren zwischen .NET- und Windows-Runtime-Streams.

Siehe auch

Zugreifen auf Dateien und Ordner mit Windows App SDK und WinRT-APIs

Dateien, Ordner und Bibliotheken mit Windows App SDK