Discussion :

[Deesmon]

Bonjour,

J'utilise depuis un ans async/await pour mon code asynchrone dans mon appli wpf pour garder mon UI réactive et j'aimerais savoir ce qui différencie les trois codes suivants.
Le premier est élégants et marche très bien. Le deuxième donne le même résultat que le premier mais le code devient vite un jolie sac de nœud. Le troisième ressemble beaucoup au premier mais le thread de l'UI n'apprécie pas du tout qu'on essaye de la tripoter depuis un autre thread (RaisePropertyChanged). Il est évident que async/await utilise Task. Qu'est ce qui fait que le code de la méthode asynchrone soit sur le thread de l'UI et pas celui de la Task ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
public async Task DoSomething()
{
    Progress = "Start something long enough which will freeze the UI if not asynchronous";
    RaisePropertyChanged(nameof(Progress));
    await Task.Factory.StartNew(() => Thread.Sleep(5000));
    Progress = "Step2";
    RaisePropertyChanged(nameof(Progress));
    await Task.Factory.StartNew(() => Thread.Sleep(5000));
    Progress = "Done";
    RaisePropertyChanged(nameof(Progress));
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
public void DoSomething()
{
    Progress = "Start something long enough which will freeze the UI if not asynchronous";
    RaisePropertyChanged(nameof(Progress));
    var t1 = Task.Factory.StartNew(() => Thread.Sleep(5000));
    t1.GetAwaiter().OnCompleted(() => 
    {
        Progress = "Step2";
        RaisePropertyChanged(nameof(Progress));
        var t2 = Task.Factory.StartNew(() => Thread.Sleep(5000));
        t2.GetAwaiter().OnCompleted(() =>
        {
            Progress = "Done";
            RaisePropertyChanged(nameof(Progress));
        });
    });
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public Task DoSomething()
{
    return Task.Factory.StartNew(() => 
    {
        Progress = "Start something long enough which will freeze the UI if not asynchronous";
        RaisePropertyChanged(nameof(Progress));
        Thread.Sleep(5000);
        Progress = "Step2";
        RaisePropertyChanged(nameof(Progress));
        Thread.Sleep(5000);
        Progress = "Done";
        RaisePropertyChanged(nameof(Progress));
    });
}

Je comprends pas bien non plus la différence entre les notions d'asynchrone et de parallèle.
Lorsque je créer une task, le code est exécuté en parallèle.
Le mot clé async permet de faire du code asynchrone.
Pourtant lorsque l'on fait un await. L'UI reste réactive et je peux de nouveau appuyer sur mon bouton et relancer ma méthode asynchrone. Ce qui veut bien dire que je peux avoir plusieurs méthode asynchrone en parallèle. Alors c'est quoi la différences entres ces Task qui s'exécute en parallèle et celles que je créer à l'aide de Task ?

[worm83]

Bonjour,

En fait, pour Async/Await et Task il n'y a pas vraiment de différence

Async et Await sont du "sucre syntaxique" qui permette de faire de l'asynchronisme de façon plus simple, mais en réalité le compilateur écrira lui même la partie qui comprend la Task plus l'abonnement au CallBack (ou le ContinueWith).

Task est une classe qui est apparue avec le Framework 4.0, cette classe "remplace" (ou simplifie) la classe Thread. Microsoft s'est aperçu que les développeur utiliser mal "Thread", et à décidé de créer "Task" qui est une abstraction de plus haut niveau, et qui encapsule toute les problématiques mal gérés par les developpeur, Task se veux plus sûre à l'utilisation.

Asynchronisme et parallélisme sont des notions très proches, on entend souvent par parallélisme le fait que les taches se lance en même temps et se termine au même moment (pas forcément), et que l'utilisation de plusieurs processeur soit optimisé (le plus important dans la notion de parallélisme).
Par asynchronisme on entend le fait que l'on lance une tache et que lorsque elle se termine un évènement appelé "CallBack" nous est envoyé (sans savoir quand commence réllement la tâche et si le processeur le fait en "parallèle").

Dans parallélisme on entend aussi le fait que pour chaque tache, un temps de processeur quasi similaire nous est affecté, et que si l'on a 4 tâches en parallèles, et 4 processeurs inactifs, chaque processeur travaille en parallèle.
Si l'on veut faire du "vrai" parallélisme, Microsoft encourage l'utilisation d'une bibliothèque créé pour l'occasion (par Intel)

https://msdn.microsoft.com/fr-fr/lib...VS.110%29.aspx

http://blog.netapsys.fr/amelioration...asynchronisme/

[Arnard]

Olivier Dahan a écrit plusieurs articles sur Task, dont voici le premier et 5e article qui décrivent la différence

Il y fait la distinction entre la Task classique qui fait un traitement parallèle, et la task awaitable, qui correspond à l'attente d'un événement.