Criar, gravar e ler um arquivo

Artigo
07/13/2023

APIs importantes

Leia e grave um arquivo usando um objeto StorageFile.

Observação

Para obter um exemplo completo, veja o Exemplo de acesso a arquivos.

Pré-requisitos

Entender a programação assíncrona para aplicativos UWP (Plataforma Universal do Windows)

Você pode aprender a escrever aplicativos assíncronos em C# ou Visual Basic, consulte Chamar APIs assíncronas em C# ou Visual Basic. Para aprender a escrever aplicativos assíncronos em C++/WinRT, consulte Simultaneidade e operações assíncronas com C++/WinRT. Para saber como escrever aplicativos assíncronos em C++/CX, consulte Programação assíncrona em C++/CX.
Saiba como obter o arquivo que você quer ler, gravar ou ambos

Você pode aprender a obter um arquivo usando um seletor de arquivos em Abrir arquivos e pastas com um seletor.

Criando um arquivo

Consulte aqui como criar um arquivo na pasta local do aplicativo. Se ele já existir, nós o substituiremos.

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

Gravando em um arquivo

Veja aqui como gravar em um arquivo gravável no disco usando a classe StorageFile. A primeira etapa comum para cada uma das maneiras de gravar em um arquivo (a menos que você grave no arquivo imediatamente depois de criá-lo) é obter o arquivo com 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")

Gravando texto em um arquivo

Escreva texto em seu arquivo chamando o método 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")

Gravando bytes em um arquivo usando um buffer (2 etapas)

Primeiro, chame CryptographicBuffer.ConvertStringToBinary para obter um buffer dos bytes (com base em uma cadeia de caracteres arbitrária) que você deseja gravar no arquivo.

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)

Em seguida, grave os bytes do buffer no arquivo chamando o método 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)

Gravando texto em um arquivo usando um fluxo (4 etapas)

Primeiramente, abra o arquivo chamando o método StorageFile.OpenAsync. Ele retorna um fluxo de conteúdo do arquivo quando a operação de abertura é concluída.

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)

Em seguida, obtenha um fluxo de saída chamando o método IRandomAccessStream.GetOutputStreamAt de stream. Se estiver usando C#, coloque isso em uma declaração using para gerenciar o tempo de vida do fluxo de saída. Se estiver usando C++/WinRT, você poderá controlar seu tempo de vida colocando-o em um bloco ou configurando-a como nullptr quando terminar com ele.

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

Agora, adicione esse código (se estiver usando C#, dentro da instrução using existente) para gravar no fluxo de saída, criando um novo objeto DataWriter e chamando o método 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.")

Por fim, adicione esse código (se estiver usando C#, na instrução using interna) para salvar o texto em seu arquivo com DataWriter.StoreAsync e feche o fluxo com 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()

Práticas recomendadas para gravar em um arquivo

Para obter mais detalhes e diretrizes de práticas recomendadas, consulte Práticas recomendadas para gravar em arquivos.

Lendo um arquivo

Veja aqui como ler um arquivo no disco usando a classe StorageFile. A primeira etapa comum para cada uma das maneiras de ler um arquivo é obter o arquivo com 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")

Lendo texto de um arquivo

Leia texto de seu arquivo chamando o método 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)

Lendo texto de um arquivo usando um buffer (2 etapas)

Primeiro, chame o método 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)

Em seguida, use o objeto DataReader para ler primeiro o tamanho do buffer e depois seu conteúdo.

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)

Lendo texto de um arquivo usando um fluxo (4 etapas)

Abra um fluxo para o seu arquivo chamando o método StorageFile.OpenAsync. Ele retorna um fluxo de conteúdo do arquivo quando a operação é concluída.

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)

Obtenha o tamanho do fluxo para usar mais tarde.

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

Obtenha um fluxo de entrada chamando o método IRandomAccessStream.GetInputStreamAt. Coloque isso em uma declaração using para gerenciar o ciclo de vida do fluxo de entrada. Especifique 0 ao chamar GetInputStreamAt para definir a posição para o início do fluxo.

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

Por fim, adicione este código à instrução using existente para obter um objeto DataReader no fluxo e, em seguida, leia o texto chamando DataReader.LoadAsync e 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)

Veja também

Práticas recomendadas para gravar em arquivos

Partilhar via