E/S sur fichier asynchrones

 

Date de publication : novembre 2016

Les opérations asynchrones vous permettent d'exécuter des opérations d'E/S consommant beaucoup de ressources sans bloquer le thread principal. Cette considération de performance est particulièrement importante dans une application Windows 8.x Store ou une application Entity with relative path '../Token/desktop_appname_md.md' can not be found, for source topic '{"project_id":"3fedad16-eaf1-41a6-8f96-0c1949c68f32","entity_id":"dbdd55e7-d6b9-4f9e-8abb-ab0edd4457f7","entity_type":"Article","locale":"fr-FR"}'. où une longue opération de flux peut bloquer le thread d'interface utilisateur et faire que l'application s'affiche comme si elle ne fonctionnait pas.

Depuis le .NET Framework 4.5, les types d'E/S incluent des méthodes async pour simplifier les opérations asynchrones. Une méthode asynchrone contient Async dans son nom, comme ReadAsync, WriteAsync, CopyToAsync, FlushAsync, ReadLineAsync, et ReadToEndAsync. Ces méthodes asynchrones sont implémentées sur les classes de flux, telles que Stream, FileStream, MemoryStream, et les classes qui sont utilisées pour lire ou écrire dans des flux, comme TextReader et l'TextWriter.

Dans .NET Framework 4 et les versions antérieures, on doit utiliser des méthodes telles que BeginRead et EndRead pour implémenter les opérations d'E/S asynchrones. Ces méthodes sont toujours disponibles dans .NET Framework 4.5 pour prendre en charge le code hérité. Toutefois, les méthodes asynchrones vous aident à implémenter les opérations d'E/S asynchrones plus facilement.

Depuis le Visual Studio 2012, Visual Studio fournit deux mots clés pour la programmation asynchrone :

  • Async (Visual Basic) ou async modificateur (C#), qui est utilisé pour marquer une méthode contenant une opération asynchrone.

  • Await (Visual Basic) ou await opérateur (C#), qui est appliqué au résultat d'une méthode asynchrone.

Pour implémenter des opérations d'E/S asynchrones, utilisez ces mots clés conjointement aux méthodes async, comme indiqué dans les exemples suivants. Pour plus d'informations, consultez Programmation asynchrone avec Async et Await.

L'exemple suivant montre comment utiliser deux objets FileStream pour copier des fichiers de façon asynchrone d'un répertoire à un autre. Notez que le gestionnaire d'événements Click pour le contrôle Button est marqué avec le modificateur async car il appelle une méthode asynchrone.

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);
                    }
                }
            }
        }
    }
}

L'exemple suivant est semblable au précédent, mais utilise des objets StreamReader et StreamWriter pour lire et écrire le contenu d'un fichier texte de façon asynchrone.

        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);
            } 
        } 

L'exemple suivant montre le fichier code-behind et le fichier XAML utilisés pour ouvrir un fichier comme Stream dans une application Windows 8.x Store, et lire son contenu en utilisant une instance de la classe StreamReader. Il utilise des méthodes asynchrones pour ouvrir le fichier en tant que flux et lire son contenu.

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>

Stream
Fichier et flux de données E/S
Programmation asynchrone avec Async et Await

Afficher: