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

Verpackte Windows App SDK-Apps können .NET-APIs nutzen, um Dateien zu lesen und zu schreiben, mit Ordnern zu arbeiten sowie Laufwerks- und Volumeinformationen zu lesen. 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 zum Verwenden der . NET-System.IO-APIs zum Lesen und Schreiben von Dateien, zum Verwalten von Laufwerken und Ordnern und zum Arbeiten mit Speicherdatenströmen zum Codieren oder Decodieren von Zeichenfolgendaten.

Lesen und Schreiben von Dateien mit .NET-APIs

Im folgenden Beispiel ReadWriteFiles wird eine neue Datei erstellt, eine Reihe ganzzahliger Zahlen in die Datei geschrieben und dann die ganzzahligen Zahlen aus der Datei zurückgelesen. 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 und die BinaryReader-Klasse zu schreiben, 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 mithilfe der DirectoryInfo - und Verzeichnisklassen Ordner erstellen, löschen und 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 zum Durchlaufen von Verzeichnissen und Unterverzeichnissen bereit. Die Directory-Klasse stellt statische Methoden zum Erstellen, Verschieben und Durchlaufen von Verzeichnissen und Unterverzeichnissen bereit.

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 enthält Informationen zu einem Laufwerk, z. B. laufwerkstyp, Bezeichnung, Dateisystem und verfügbarem 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 Sie die MemoryStream-Klasse zum Codieren und Decodieren von Zeichenfolgendaten verwenden. Zunächst wird eine MemoryStream erstellt, um asynchron eine Zeichenfolge zu einem 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 die Byte-Array asynchron aus dem Speicherdatenstrom zu lesen und anschließend die Byte-Array 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 How to: Convert between .NET and 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