Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido manualmente. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

E/S de arquivo assíncrona

As operações assíncronas permite executar operações que utilizam muitos recursos de E/S sem bloquear o thread principal. Esta consideração de desempenho é particularmente importante em um aplicativo de Windows Store ou no aplicativo de área de trabalho em que uma operação demorada de fluxo pode bloquear o thread de interface do usuário e fazer seu aplicativo aparecer como se não estiver trabalhando.

A partir .NET Framework 4,5, os tipos de E/S incluem métodos de async para simplificar operações assíncronas. Um método de async contém Async em seu nome, como ReadAsync, WriteAsync, CopyToAsync, FlushAsync, ReadLineAsync, e ReadToEndAsync. Esses métodos de async são implementados em classes de fluxo, como Stream, FileStream, e MemoryStream, e nas classes de usados para leitura ou gravação aos fluxos, a essa TextReader e o TextWriter.

No .NET Framework 4 e nas versões anteriores, você deve usar métodos como BeginRead e EndRead para implementar operações assíncronas de E/S. Esses métodos ainda estão disponíveis em .NET Framework 4,5 para oferecer suporte ao código herdado; no entanto, os métodos de async ajudam a implementação mais facilmente operações assíncronas de E/S.

A partir Visual Studio 2012, o Visual Studio fornece duas palavras-chave para programação assíncrona:

  • Async (Visual Basic) ou modificador de async (C#), que é usada para marcar um método que contém uma operação assíncrona.

  • Await (Visual Basic) ou operador de await (C#), que é aplicada ao resultado de um método de async.

Para implementar operações assíncronas de E/S, use essas palavras-chave junto com os métodos de async, como mostrado nos exemplos. Para obter mais informações, consulte Programação assíncrona com Async e Await (C# e Visual Basic).

O exemplo a seguir demonstra como usar de forma assíncrona dois objetos de FileStream para copiar arquivos de um diretório para outro. Observe que o manipulador de eventos de Click para o controle de Button está marcado com o modificador de async como chama um método assíncrona.


using System;
using System.Threading.Tasks;
using System.Windows;
using System.IO;

namespace WpfApplication
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            string StartDirectory = @"c:\Users\exampleuser\start";
            string EndDirectory = @"c:\Users\exampleuser\end";

            foreach (string filename in Directory.EnumerateFiles(StartDirectory))
            {
                using (FileStream SourceStream = File.Open(filename, FileMode.Open))
                {
                    using (FileStream DestinationStream = File.Create(EndDirectory + filename.Substring(filename.LastIndexOf('\\'))))
                    {
                        await SourceStream.CopyToAsync(DestinationStream);
                    }
                }
            }
        }
    }
}


O exemplo a seguir é semelhante ao anterior mas usa StreamReader e objetos de StreamWriter de forma assíncrona ler e gravar o conteúdo de um arquivo de texto.


private async void Button_Click(object sender, RoutedEventArgs e)
{
    string UserDirectory = @"c:\Users\exampleuser\";

    using (StreamReader SourceReader = File.OpenText(UserDirectory + "BigFile.txt"))
    {
        using (StreamWriter DestinationWriter = File.CreateText(UserDirectory + "CopiedFile.txt"))
        {
            await CopyFilesAsync(SourceReader, DestinationWriter);
        }
    }
}

public async Task CopyFilesAsync(StreamReader Source, StreamWriter Destination) 
{ 
    char[] buffer = new char[0x1000]; 
    int numRead; 
    while ((numRead = await Source.ReadAsync(buffer, 0, buffer.Length)) != 0) 
    {
        await Destination.WriteAsync(buffer, 0, numRead);
    } 
} 


O exemplo seguinte mostra codinome atrás de arquivo e do arquivo XAML que são usados para abrir um arquivo como Stream em um aplicativo de Windows Store , e para ler o conteúdo usando uma instância da classe de StreamReader . Usa métodos assíncronas para abrir o arquivo como um fluxo e para ler seu conteúdo.


Imports System.Text
Imports System.IO
Imports Windows.Storage.Pickers
Imports Windows.Storage

NotInheritable Public Class BlankPage
    Inherits Page



    Private Async Sub Button_Click_1(sender As Object, e As RoutedEventArgs)
        Dim contents As StringBuilder = New StringBuilder()
        Dim nextLine As String
        Dim lineCounter As Integer = 1

        Dim openPicker = New FileOpenPicker()
        openPicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary

        openPicker.FileTypeFilter.Add(".txt")
        Dim selectedFile As StorageFile = Await openPicker.PickSingleFileAsync()

        Using reader As StreamReader = New StreamReader(Await selectedFile.OpenStreamForReadAsync())
            nextLine = Await reader.ReadLineAsync()
            While (nextLine <> Nothing)
                contents.AppendFormat("{0}. ", lineCounter)
                contents.Append(nextLine)
                contents.AppendLine()
                lineCounter = lineCounter + 1
                If (lineCounter > 3) Then
                    contents.AppendLine("Only first 3 lines shown.")
                    Exit While
                End If
                nextLine = Await reader.ReadLineAsync()
            End While
        End Using
        DisplayContentsBlock.Text = contents.ToString()
    End Sub
End Class



using System;
using System.IO;
using System.Text;
using Windows.Storage.Pickers;
using Windows.Storage;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace ExampleApplication
{
    public sealed partial class BlankPage : Page
    {
        public BlankPage()
        {
            this.InitializeComponent();
        }

        private async void Button_Click_1(object sender, RoutedEventArgs e)
        {
            StringBuilder contents = new StringBuilder();
            string nextLine;
            int lineCounter = 1;

            var openPicker = new FileOpenPicker();
            openPicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
            openPicker.FileTypeFilter.Add(".txt");
            StorageFile selectedFile = await openPicker.PickSingleFileAsync();

            using (StreamReader reader = new StreamReader(await selectedFile.OpenStreamForReadAsync()))
            {
                while ((nextLine = await reader.ReadLineAsync()) != null)
                {
                    contents.AppendFormat("{0}. ", lineCounter);
                    contents.Append(nextLine);
                    contents.AppendLine();
                    lineCounter++;
                    if (lineCounter > 3)
                    {
                        contents.AppendLine("Only first 3 lines shown.");
                        break;
                    }
                }
            }
            DisplayContentsBlock.Text = contents.ToString();
        }
    }
}



<Page
    x:Class="ExampleApplication.BlankPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:ExampleApplication"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <StackPanel Background="{StaticResource ApplicationPageBackgroundBrush}" VerticalAlignment="Center" HorizontalAlignment="Center">
        <TextBlock Text="Display lines from a file."></TextBlock>
        <Button Content="Load File" Click="Button_Click_1"></Button>
        <TextBlock Name="DisplayContentsBlock"></TextBlock>
    </StackPanel>
</Page>


Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft