Erstellen, Schreiben und Lesen einer Datei

Artikel
07/13/2023

Wichtige APIs

Lesen und Schreiben Sie eine Datei mithilfe eines StorageFile-Objekts.

Hinweis

Ein vollständiges Beispiel findest du im Beispiel zum Dateizugriff.

Voraussetzungen

Kenntnisse in der asynchronen Programmierung für Apps für die universelle Windows-Plattform (UWP)

Informationen zum Schreiben von asynchronen Apps in C# oder Visual Basic finden Sie unter Aufrufen asynchroner APIs in C# oder Visual Basic. Informationen zum Schreiben asynchroner Apps in C++/WinRT findest du unter Parallelität und asynchrone Vorgänge mit C++/WinRT. Informationen zum Schreiben von asynchronen Apps in C++/CX findest du unter Asynchrone Programmierung in C++/CX.
Kenntnisse darin, wie die Datei abgerufen wird, aus der du lesen und/oder in die du schreiben möchtest

Unter Öffnen von Dateien und Ordnern mit einer Auswahl erfahren Sie, wie Sie eine Datei mit einer Dateiauswahl abrufen können.

Erstellen einer Datei

Nachfolgend finden Sie Informationen zum Erstellen einer Datei im lokalen Ordner der App. Wenn sie bereits vorhanden ist, ersetzen Sie sie.

// Create sample file; replace if exists.
Windows.Storage.StorageFolder storageFolder =
    Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
    await storageFolder.CreateFileAsync("sample.txt",
        Windows.Storage.CreationCollisionOption.ReplaceExisting);

// MainPage.h
#include <winrt/Windows.Storage.h>
...
Windows::Foundation::IAsyncAction ExampleCoroutineAsync()
{
    // Create a sample file; replace if exists.
    Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
    co_await storageFolder.CreateFileAsync(L"sample.txt", Windows::Storage::CreationCollisionOption::ReplaceExisting);
}

// Create a sample file; replace if exists.
StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
concurrency::create_task(storageFolder->CreateFileAsync("sample.txt", CreationCollisionOption::ReplaceExisting));

' Create sample file; replace if exists.
Dim storageFolder As StorageFolder = Windows.Storage.ApplicationData.Current.LocalFolder
Dim sampleFile As StorageFile = Await storageFolder.CreateFileAsync("sample.txt", CreationCollisionOption.ReplaceExisting)

Schreiben in eine Datei

Im Folgenden finden Sie Informationen zum Schreiben in eine beschreibbare Datei auf dem Datenträger mithilfe der StorageFile-Klasse. Der allgemein erste Schritt für die verschiedenen Methoden zum Schreiben in eine Datei ist das Abrufen der Datei mit StorageFolder.GetFileAsync. (Es sei denn, Sie schreiben sofort nach dem Erstellen in die Datei.)

Windows.Storage.StorageFolder storageFolder =
    Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
    await storageFolder.GetFileAsync("sample.txt");

// MainPage.h
#include <winrt/Windows.Storage.h>
...
Windows::Foundation::IAsyncAction ExampleCoroutineAsync()
{
    Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
    auto sampleFile{ co_await storageFolder.CreateFileAsync(L"sample.txt", Windows::Storage::CreationCollisionOption::ReplaceExisting) };
    // Process sampleFile
}

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile) 
{
    // Process file
});

Dim storageFolder As StorageFolder = Windows.Storage.ApplicationData.Current.LocalFolder
Dim sampleFile As StorageFile = Await storageFolder.GetFileAsync("sample.txt")

Schreiben von Text in eine Datei

Du schreibst Text in die Datei, indem du die FileIO.WriteTextAsync-Methode aufrufst.

await Windows.Storage.FileIO.WriteTextAsync(sampleFile, "Swift as a shadow");

// MainPage.h
#include <winrt/Windows.Storage.h>
...
Windows::Foundation::IAsyncAction ExampleCoroutineAsync()
{
    Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
    auto sampleFile{ co_await storageFolder.GetFileAsync(L"sample.txt") };
    // Write text to the file.
    co_await Windows::Storage::FileIO::WriteTextAsync(sampleFile, L"Swift as a shadow");
}

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile) 
{
    //Write text to a file
    create_task(FileIO::WriteTextAsync(sampleFile, "Swift as a shadow"));
});

Await Windows.Storage.FileIO.WriteTextAsync(sampleFile, "Swift as a shadow")

Schreiben von Bytes in eine Datei mithilfe eines Puffers (2 Schritte)

Rufe zuerst CryptographicBuffer.ConvertStringToBinary auf, um einen Puffer der Bytes (basierend auf einer Zeichenfolge) zu erhalten, die du in die Datei schreiben möchtest.

var buffer = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(
    "What fools these mortals be", Windows.Security.Cryptography.BinaryStringEncoding.Utf8);

// MainPage.h
#include <winrt/Windows.Security.Cryptography.h>
#include <winrt/Windows.Storage.h>
#include <winrt/Windows.Storage.Streams.h>
...
Windows::Foundation::IAsyncAction ExampleCoroutineAsync()
{
    Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
    auto sampleFile{ co_await storageFolder.GetFileAsync(L"sample.txt") };
    // Create the buffer.
    Windows::Storage::Streams::IBuffer buffer{
        Windows::Security::Cryptography::CryptographicBuffer::ConvertStringToBinary(
            L"What fools these mortals be", Windows::Security::Cryptography::BinaryStringEncoding::Utf8)};
    // The code in step 2 goes here.
}

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile)
{
    // Create the buffer
    IBuffer^ buffer = CryptographicBuffer::ConvertStringToBinary
    ("What fools these mortals be", BinaryStringEncoding::Utf8);
});

Dim buffer = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(
    "What fools these mortals be",
    Windows.Security.Cryptography.BinaryStringEncoding.Utf8)

Schreibe dann die Bytes aus dem Puffer in die Datei, indem du die FileIO.WriteBufferAsync-Methode aufrufst.

await Windows.Storage.FileIO.WriteBufferAsync(sampleFile, buffer);

co_await Windows::Storage::FileIO::WriteBufferAsync(sampleFile, buffer);

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile)
{
    // Create the buffer
    IBuffer^ buffer = CryptographicBuffer::ConvertStringToBinary
    ("What fools these mortals be", BinaryStringEncoding::Utf8);      
    // Write bytes to a file using a buffer
    create_task(FileIO::WriteBufferAsync(sampleFile, buffer));
});

Await Windows.Storage.FileIO.WriteBufferAsync(sampleFile, buffer)

Schreiben von Text in eine Datei mithilfe eines Datenstroms (4 Schritte)

Öffnen Sie zunächst die Datei durch Aufrufen der StorageFile.OpenAsync-Methode. Wenn der Vorgang zum Öffnen abgeschlossen ist, wird ein Datenstrom des Dateiinhalts zurückgegeben.

var stream = await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);

// MainPage.h
#include <winrt/Windows.Storage.h>
#include <winrt/Windows.Storage.Streams.h>
...
Windows::Foundation::IAsyncAction ExampleCoroutineAsync()
{
    Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
    auto sampleFile{ co_await storageFolder.GetFileAsync(L"sample.txt") };
    Windows::Storage::Streams::IRandomAccessStream stream{ co_await sampleFile.OpenAsync(Windows::Storage::FileAccessMode::ReadWrite) };
    // The code in step 2 goes here.
}

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile)
{
    create_task(sampleFile->OpenAsync(FileAccessMode::ReadWrite)).then([sampleFile](IRandomAccessStream^ stream)
    {
        // Process stream
    });
});

Dim stream = Await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)

Rufe dann einen Ausgabestream ab, indem du in stream die IRandomAccessStream.GetOutputStreamAt-Methode aufrufst. Füge diesen bei Verwendung von C# in eine using-Anweisung ein, um die Lebensdauer des Ausgabestreams zu verwalten. Bei Verwendung von C++/WinRT kannst du die Lebensdauer steuern, indem du sie in einen Block einschließt oder auf nullptr festlegst, wenn du damit fertig bist.

using (var outputStream = stream.GetOutputStreamAt(0))
{
    // We'll add more code here in the next step.
}
stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well.

Windows::Storage::Streams::IOutputStream outputStream{ stream.GetOutputStreamAt(0) };
// The code in step 3 goes here.

// Add to "Process stream" in part 1
IOutputStream^ outputStream = stream->GetOutputStreamAt(0);

Using outputStream = stream.GetOutputStreamAt(0)
' We'll add more code here in the next step.
End Using

Füge jetzt bei Verwendung von C# diesen Code in die vorhandene using-Anweisung ein, um in den Ausgabestream zu schreiben, indem du ein neues DataWriter-Objekt erstellst und die DataWriter.WriteString-Methode aufrufst.

using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
    dataWriter.WriteString("DataWriter has methods to write to various types, such as DataTimeOffset.");
}

Windows::Storage::Streams::DataWriter dataWriter;
dataWriter.WriteString(L"DataWriter has methods to write to various types, such as DataTimeOffset.");
// The code in step 4 goes here.

// Added after code from part 2
DataWriter^ dataWriter = ref new DataWriter(outputStream);
dataWriter->WriteString("DataWriter has methods to write to various types, such as DataTimeOffset.");

Dim dataWriter As New DataWriter(outputStream)
dataWriter.WriteString("DataWriter has methods to write to various types, such as DataTimeOffset.")

Abschließend fügst du diesen Code (bei Verwendung von C# innerhalb der inneren using-Anweisung) mit DataWriter.StoreAsync hinzu, um den Text in der Datei zu speichern, und schließt den Datenstrom mit IOutputStream.FlushAsync.

await dataWriter.StoreAsync();
await outputStream.FlushAsync();

dataWriter.StoreAsync();
outputStream.FlushAsync();

// Added after code from part 3
dataWriter->StoreAsync();
outputStream->FlushAsync();

Await dataWriter.StoreAsync()
Await outputStream.FlushAsync()

Bewährte Methoden zum Schreiben in eine Datei

Weitere Details und bewährte Vorgehensweisen findest du unter Bewährte Methoden zum Schreiben in Dateien.

Lesen aus einer Datei

Nachfolgend finden Sie Informationen zum Lesen aus einer Datei auf dem Datenträger mithilfe der StorageFile-Klasse. Der allgemein erste Schritt für die einzelnen Methoden zum Lesen von Daten aus einer Datei ist das Abrufen der Datei mit StorageFolder.GetFileAsync.

Windows.Storage.StorageFolder storageFolder =
    Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
    await storageFolder.GetFileAsync("sample.txt");

Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
auto sampleFile{ co_await storageFolder.GetFileAsync(L"sample.txt") };
// Process file

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile)
{
    // Process file
});

Dim storageFolder As StorageFolder = Windows.Storage.ApplicationData.Current.LocalFolder
Dim sampleFile As StorageFile = Await storageFolder.GetFileAsync("sample.txt")

Lesen von Text aus einer Datei

Lies Text aus einer Datei, indem du die FileIO.ReadTextAsync-Methode aufrufst.

string text = await Windows.Storage.FileIO.ReadTextAsync(sampleFile);

Windows::Foundation::IAsyncOperation<winrt::hstring> ExampleCoroutineAsync()
{
    Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
    auto sampleFile{ co_await storageFolder.GetFileAsync(L"sample.txt") };
    co_return co_await Windows::Storage::FileIO::ReadTextAsync(sampleFile);
}

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile)
{
    return FileIO::ReadTextAsync(sampleFile);
});

Dim text As String = Await Windows.Storage.FileIO.ReadTextAsync(sampleFile)

Lesen von Text aus einer Datei mithilfe eines Puffers (2 Schritte)

Ruf zuerst die FileIO.ReadBufferAsync-Methode auf.

var buffer = await Windows.Storage.FileIO.ReadBufferAsync(sampleFile);

Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
auto sampleFile{ co_await storageFolder.GetFileAsync(L"sample.txt") };
Windows::Storage::Streams::IBuffer buffer{ co_await Windows::Storage::FileIO::ReadBufferAsync(sampleFile) };
// The code in step 2 goes here.

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile)
{
    return FileIO::ReadBufferAsync(sampleFile);

}).then([](Streams::IBuffer^ buffer)
{
    // Process buffer
});

Dim buffer = Await Windows.Storage.FileIO.ReadBufferAsync(sampleFile)

Verwenden Sie dann ein DataReader-Objekt, um zunächst die Länge des Puffers und dann dessen Inhalt zu lesen.

using (var dataReader = Windows.Storage.Streams.DataReader.FromBuffer(buffer))
{
    string text = dataReader.ReadString(buffer.Length);
}

auto dataReader{ Windows::Storage::Streams::DataReader::FromBuffer(buffer) };
winrt::hstring bufferText{ dataReader.ReadString(buffer.Length()) };

// Add to "Process buffer" section from part 1
auto dataReader = DataReader::FromBuffer(buffer);
String^ bufferText = dataReader->ReadString(buffer->Length);

Dim dataReader As DataReader = Windows.Storage.Streams.DataReader.FromBuffer(buffer)
Dim text As String = dataReader.ReadString(buffer.Length)

Lesen von Text aus einer Datei mithilfe eines Datenstroms (4 Schritte)

Öffnen Sie einen Datenstrom für die Datei, indem Sie die StorageFile.OpenAsync-Methode aufrufen. Wenn der Vorgang abgeschlossen ist, wird ein Datenstrom des Dateiinhalts zurückgegeben.

var stream = await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.Read);

Windows::Storage::StorageFolder storageFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };
auto sampleFile{ co_await storageFolder.GetFileAsync(L"sample.txt") };
Windows::Storage::Streams::IRandomAccessStream stream{ co_await sampleFile.OpenAsync(Windows::Storage::FileAccessMode::Read) };
// The code in step 2 goes here.

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
create_task(storageFolder->GetFileAsync("sample.txt")).then([](StorageFile^ sampleFile)
{
    create_task(sampleFile->OpenAsync(FileAccessMode::Read)).then([sampleFile](IRandomAccessStream^ stream)
    {
        // Process stream
    });
});

Dim stream = Await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.Read)

Rufen Sie die Größe des Datenstroms zur späteren Verwendung ab.

ulong size = stream.Size;

uint64_t size{ stream.Size() };
// The code in step 3 goes here.

// Add to "Process stream" from part 1
UINT64 size = stream->Size;

Dim size = stream.Size

Ruf einen Eingabedatenstrom ab, indem du die IRandomAccessStream.GetInputStreamAt-Methode aufrufst. Fügen Sie ihn in eine using-Anweisung ein, um die Lebensdauer des Eingabedatenstroms zu verwalten. Geben Sie beim Aufrufen von GetInputStreamAt 0 an, um die Position auf den Anfang des Datenstroms festzulegen.

using (var inputStream = stream.GetInputStreamAt(0))
{
    // We'll add more code here in the next step.
}

Windows::Storage::Streams::IInputStream inputStream{ stream.GetInputStreamAt(0) };
Windows::Storage::Streams::DataReader dataReader{ inputStream };
// The code in step 4 goes here.

// Add after code from part 2
IInputStream^ inputStream = stream->GetInputStreamAt(0);
auto dataReader = ref new DataReader(inputStream);

Using inputStream = stream.GetInputStreamAt(0)
' We'll add more code here in the next step.
End Using

Abschließend fügen Sie diesen Code in die vorhandene using-Anweisung zum Abrufen eines DataReader-Objekts im Datenstrom ein. Lesen Sie dann den Text durch den Aufruf von DataReader.LoadAsync und DataReader.ReadString.

using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream))
{
    uint numBytesLoaded = await dataReader.LoadAsync((uint)size);
    string text = dataReader.ReadString(numBytesLoaded);
}

unsigned int cBytesLoaded{ co_await dataReader.LoadAsync(size) };
winrt::hstring streamText{ dataReader.ReadString(cBytesLoaded) };

// Add after code from part 3
create_task(dataReader->LoadAsync(size)).then([sampleFile, dataReader](unsigned int numBytesLoaded)
{
    String^ streamText = dataReader->ReadString(numBytesLoaded);
});

Dim dataReader As New DataReader(inputStream)
Dim numBytesLoaded As UInteger = Await dataReader.LoadAsync(CUInt(size))
Dim text As String = dataReader.ReadString(numBytesLoaded)

Siehe auch

Bewährte Methoden zum Schreiben in Dateien