Esta página foi útil?
Seus comentários sobre este conteúdo são importantes. Queremos saber sua opinião.
Comentários adicionais?
1500 caracteres restantes
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:
© 2015 Microsoft