Créer, écrire et lire un fichier

Article
07/13/2023

API importantes

Lisez et écrivez un fichier à l’aide d’un objet StorageFile.

Notes

Pour un exemple complet, voir l’Exemple d’accès aux fichiers.

Prérequis

Comprendre la programmation asynchrone pour les applications pour la plateforme Windows universelle (UWP)

Pour apprendre à écrire des applications asynchrones en C# ou Visual Basic, voir Appeler des API asynchrones en C# ou Visual Basic. Pour apprendre à écrire des applications asynchrones en C++/WinRT, voir Opérations concurrentes et asynchrones avec C++/WinRT. Pour apprendre à écrire des applications asynchrones en C++/CX, voir Programmation asynchrone en C++/CX.
Savoir comment vous procurer le fichier que vous voulez lire et dans lequel vous voulez écrire, ou les deux

Pour apprendre à vous procurer un fichier à l’aide d’un sélecteur de fichiers, voir Ouvrir des fichiers et dossiers à l’aide d’un sélecteur.

Création d’un fichier

Voici comment créer un fichier dans le dossier local de l'application. S'il existe déjà, nous le remplaçons.

// 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)

Écriture dans un fichier

Voici comment écrire dans un fichier accessible en écriture sur le disque à l’aide de la classe StorageFile. La première étape pour chacune des méthodes d'écriture dans un fichier (sauf si vous écrivez dans le fichier immédiatement après sa création) consiste à obtenir le fichier à l’aide de la méthode StorageFolder.GetFileAsync.

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")

Écriture de texte dans un fichier

Écrivez du texte dans votre fichier en appelant la méthode FileIO.WriteTextAsync.

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")

Écriture d’octets dans un fichier par le biais d’une mémoire tampon (2 étapes)

Tout d’abord, appelez la méthode CryptographicBuffer.ConvertStringToBinary pour obtenir une mémoire tampon des octets (basés sur une chaîne) que vous voulez écrire dans votre fichier.

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)

Ensuite, écrivez les octets de votre mémoire tampon dans votre fichier en appelant la méthode FileIO.WriteBufferAsync.

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)

Écriture de texte dans un fichier par le biais d’un flux (4 étapes)

Premièrement, ouvrez le fichier en appelant la méthode StorageFile.OpenAsync. Cette dernière renvoie un flux du contenu du fichier lorsque l’opération d’ouverture se termine.

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)

Ensuite, obtenez un flux de sortie en appelant la méthode IRandomAccessStream.GetOutputStreamAt à partir du stream Si vous utilisez C#, puis placez cela dans une instruction using pour gérer la durée de vie du flux de sortie. Si vous utilisez C++/WinRT, vous pouvez contrôler sa durée de vie en le plaçant dans un bloc ou en le définissant sur nullptr lorsque vous avez terminé.

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

À présent, ajoutez ce code (si vous utilisez C# dans l’instruction using existante) pour écrire dans le flux de sortie en créant un objet DataWriter et en appelant la méthode DataWriter.WriteString.

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.")

Pour finir, ajoutez ce code (si vous utilisez C# dans l’instruction using interne) pour enregistrer le texte dans votre fichier avec DataWriter.StoreAsync et fermer le flux avec 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()

Meilleures pratiques pour l’écriture dans un fichier

Pour plus d’informations et les meilleures pratiques, voir Meilleures pratiques pour l’écriture dans des fichiers.

Lecture d’un fichier

Voici comment lire un fichier sur disque en utilisant la classe StorageFile. La première étape de lecture d'un fichier consiste à obtenir le fichier à l’aide de la méthode 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")

Lecture de texte dans un fichier

Lisez du texte de votre fichier en appelant la méthode FileIO.ReadTextAsync.

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)

Lecture de texte dans un fichier via une mémoire tampon (2 étapes)

Tout d’abord, appelez la méthode FileIO.ReadBufferAsync.

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)

Utilisez ensuite un objet DataReader pour lire la longueur de la mémoire tampon, puis son contenu.

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)

Lecture de texte dans un fichier via un flux (4 étapes)

Ouvrez un flux pour votre fichier en appelant la méthode StorageFile.OpenAsync. Celle-ci renvoie un flux du contenu du fichier pendant l’exécution de l’opération.

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)

Obtenez la taille du flux à utiliser ultérieurement.

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

Obtenez un flux d’entrée en appelant la méthode IRandomAccessStream.GetInputStreamAt. Placez ce code dans une instruction using pour gérer la durée de vie du flux. Spécifiez 0 quand vous appelez GetInputStreamAt pour définir la position sur le début du flux.

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

Enfin, ajoutez ce code dans l’instruction using existante pour obtenir un objet DataReader sur le flux, puis lisez le texte en appelant les méthodes DataReader.LoadAsync et 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)

Voir aussi

Bonnes pratiques pour l’écriture dans les fichiers

Partager via