Comment faire pour exécuter et d'interagir avec un async Tâche à partir d'une interface graphique WPF

Rapide astuce:

private async void Button_Click_3(object sender, RoutedEventArgs e)
{
    txt.Text = "started";
    await Task.Run(()=> HeavyMethod(this));
    txt.Text = "done";
}
internal void HeavyMethod(MainWindow gui)
{
    while (stillWorking)
    {
        UpdateGUIMethod(gui, ".");
        System.Threading.Thread.Sleep(51);
    }
}
void UpdateGUIMethod(MainWindow gui, string text)
{
    gui.Dispatcher.Invoke(() =>
    {
        txt.Text += text;
    });
} 

---

Explication:

1. async et await doit être utilisé selon la même méthode.

2. Task.Run files d'attente une méthode (comme un Task ou Task<T>) dans le pool de threads (il utilise/crée un autre thread pour exécuter la tâche)

3. L'exécution attend à await pour la fin de la tâche et jette en arrière de ses résultats, sans bloquer le thread principal en raison de la async mot clé capacité magique.

4. La magie de async mot-clé est qu'il ne pas créer un autre thread. Elle seule permet au compilateur de abandonner et reprendre le contrôle sur cette méthode.

Donc

Votre thread principal appelle la async méthode (Button_Click_3) comme une méthode normale et pas de filetage jusqu'à... Maintenant, vous pouvez exécuter une tâche à l'intérieur de la Button_Click_3 comme ceci:

private async void Button_Click_3(object sender, RoutedEventArgs e)
{
    //queue a task to run on threadpool
    Task task = Task.Run(()=>
        ExecuteLongProcedureAsync(this, intParam1, intParam2, intParam3));
    //wait for it to end without blocking the main thread
    await task;
}

ou tout simplement

private async void Button_Click_3(object sender, RoutedEventArgs e)
{
    await Task.Run(()=>
        ExecuteLongProcedureAsync(this, intParam1, intParam2, intParam3));
}

ou si ExecuteLongProcedureAsync a une valeur de retour de type string

private async void Button_Click_3(object sender, RoutedEventArgs e)
{
    Task<string> task = Task.Run(()=>
        ExecuteLongProcedureAsync(this, intParam1, intParam2, intParam3));
    string returnValue = await task;
}

ou tout simplement

private async void Button_Click_3(object sender, RoutedEventArgs e)
{
    string returnValue = await Task.Run(()=>
        ExecuteLongProcedureAsync(this, intParam1, intParam2, intParam3));

    //or in cases where you already have a "Task returning" method:
    // var httpResponseInfo = await httpRequestInfo.GetResponseAsync();
}

La méthode à l'intérieur de la tâche (ou ExecuteLongProcedureAsync) s'exécute de manière asynchrone et ressemble à ceci:

//change the value for the following flag to terminate the loop
bool stillWorking = true;

//calling this method blocks the calling thread
//you must run a task for it
internal void ExecuteLongProcedureAsync(MainWindow gui, int param1, int param2, int param3)
{
    //Start doing work
    gui.UpdateWindow("Work Started");

    while (stillWorking)
    {
        //put a dot in the window showing the progress
        gui.UpdateWindow(".");
        //the following line will block main thread unless
        //ExecuteLongProcedureAsync is called with await keyword
        System.Threading.Thread.Sleep(51);
    }

    gui.UpdateWindow("Done and Done");
} 

Note 1:

Task.Run est plus récente (.NetFX4.5) et la version plus simple de Task.Factory.StartNew

await est pas Task.Wait()

Note 2:

Sleep blocs le thread principal, même qu'elle est appelée dans la méthode avec async mot-clé.

await empêche la tâche de bloquer le thread principal en raison de la async mot-clé.

private async void Button_Click(object sender, RoutedEventArgs e)
{
        ExecuteLongProcedureAsync();//blocks
        await Task.Run(() => ExecuteLongProcedureAsync());//does not block
}

Note 3 (GUI):

Si vous avez accès à GUI de manière asynchrone (à l'intérieur de ExecuteLongProcedureAsync méthode), invoquer toute opération qui implique l'accès à l'interface graphique champs:

void UpdateWindow(string text)
{
    //safe call
    Dispatcher.Invoke(() =>
    {
        txt.Text += text;
    });
}

Cependant, Si une tâche est démarrée à la suite d'une propriété a changé de rappel à partir de ce Dernier, il n'est pas nécessaire d'utiliser Dispatcher.Invoke car le rappel est exécuté à partir de la thread de l'INTERFACE utilisateur.

Accès à des collections sur la non-Threads UI

WPF vous permet d'accéder et de modifier des collections de données sur les threads d'autres que celui qui a créé la collection. Cela vous permet d'utiliser un thread d'arrière-plan pour recevoir des données provenant d'une source externe, telle qu'une base de données et afficher les données sur le thread d'INTERFACE utilisateur. En utilisant un autre thread pour modifier la collection, votre interface utilisateur reste sensible à l'interaction de l'utilisateur.

Les changements de la valeur de feu tiré par INotifyPropertyChanged sont automatiquement placés en arrière sur le répartiteur.

Comment faire pour activer la croix-thread accès

Rappelez-vous, async méthode qui s'exécute sur le thread principal. C'est donc valide:

private async void Button_Click_3(object sender, RoutedEventArgs e)
{
    txt.Text = "starting";
    await Task.Run(()=> ExecuteLongProcedureAsync1());
    txt.Text = "waiting";
    await Task.Run(()=> ExecuteLongProcedureAsync2());
    txt.Text = "finished";
}

Lire plus

MSDN explique Tâche

MSDN explique async

async attendent - les coulisses

async attendent - FAQ

Vous pouvez également lire un simple fichier asynchrone écrivain de savoir où vous devriez simultanées.

Enquêter sur simultanée de l'espace de noms

Enfin lire ce livre électronique: Patterns_of_Parallel_Programming_csharp

OriginalL'auteur Bizhan

C'est une version simplifiée de la réponse la plus populaire ici par Bijan. Je l'ai simplifié Bijan réponse pour m'aider à penser à travers le problème à l'aide de la belle mise en forme fournie par le Débordement de la Pile.

De lire attentivement et de l'édition de Bijan du post, j'ai enfin compris: Comment attendre méthode asynchrone à remplir?

Dans mon cas, la réponse choisie pour que d'autres post, c'est ce qui m'a finalement conduit à résoudre mon problème:

"Éviter async void. Avez vos méthodes de retour Task au lieu de void. Ensuite, vous pouvez await."

Ma version simplifiée de Bijan (excellent) suit la réponse:

1) Il démarre une tâche à l'aide de async et await:

private async void Button_Click_3(object sender, RoutedEventArgs e)
{
    //if ExecuteLongProcedureAsync has a return value
    var returnValue = await Task.Run(()=>
        ExecuteLongProcedureAsync(this, intParam1, intParam2, intParam3));
}

2) C'est la méthode à exécuter de manière asynchrone:

bool stillWorking = true;
internal void ExecuteLongProcedureAsync(MainWindow gui, int param1, int param2, int param3)
{
    //Start doing work
    gui.UpdateWindow("Work Started");

    while (stillWorking)
    {
        //put a dot in the window showing the progress
        gui.UpdateWindow(".");

        //the following line blocks main thread unless
        //ExecuteLongProcedureAsync is called with await keyword
        System.Threading.Thread.Sleep(50);
    }

    gui.UpdateWindow("Done and Done");
} 

3) appelez l'opération qui implique une propriété à partir de l'interface graphique:

void UpdateWindow(string text)
{
    //safe call
    Dispatcher.Invoke(() =>
    {
        txt.Text += text;
    });
}

Ou,

void UpdateWindow(string text)
{
    //simply
    txt.Text += text;
}

Commentaires de clôture) Dans la plupart des cas, vous disposez de deux méthodes.

• Première méthode (Button_Click_3) appelle la deuxième méthode et a la async modificateur qui indique au compilateur de permettre à enfiler pour cette méthode.

  • Thread.Sleep dans un async méthode bloque le thread principal. mais en attente d'une tâche ne.
  • L'exécution s'arrête sur le thread en cours (deuxième thread) sur await états jusqu'à ce que la tâche est terminée.
  • Vous ne pouvez pas utiliser await à l'extérieur d'un async méthode

• Deuxième méthode (ExecuteLongProcedureAsync) est emballé dans une tâche et renvoie un générique Task<original return type> objet qui peut être instruit pour être traité de manière asynchrone par l'ajout de await avant.

  • Tout dans cette méthode exécutée de manière asynchrone

Important:

Liero apporté une question importante. Lorsque vous êtes à la Liaison d'un élément à un ViewModel de la propriété, la propriété a changé de rappel est exécuté dans le thread de l'INTERFACE utilisateur. Donc, il n'est pas nécessaire d'utiliser Dispatcher.Invoke. Les changements de la valeur de feu tiré par INotifyPropertyChanged sont automatiquement placés en arrière sur le répartiteur.

OriginalL'auteur Eric D

Il a été pendant plusieurs années depuis que la question a été posée, mais je pense qu'il est intéressant de noter que la classe BackgroundWorker est conçu précisément pour obtenir A, B et C exigences.

Complète de l'échantillon de référence msdn page: https://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker(v=vs. 110).aspx

OriginalL'auteur rbenavides