Explication détaillée du code graphique de la fonction C# 5.0 Async en un coup d'œil

Cela fait un mois que Microsoft a publié Async CTP, et tout le monde en parle Async. Si vous êtes déjà très familier avec Async, alors sautez-le... Si vous êtes comme moi, vous ne connaissez qu'un peu la programmation asynchrone, mais vous sentez que le précédent la programmation asynchrone est plus gênante, alors explorons ce que la prochaine génération de C# nous apportera. (Async CTP prend également en charge VB.)

L'exemple de cet article est basé sur Async CTP SP1 Refresh. Puisque Async est encore au stade CTP, beaucoup de choses sont encore en discussion, alors attendez peut-être C# 5.0 Les détails changeront lors de la sortie. Cependant, l’idée générale et le concept ne devraient pas beaucoup changer.

Allons à l'essentiel :

Tout d'abord, pour essayer la fonction Async, nous devons installerVisual Studio 2010 SP1 et Microsoft Visual Studio Async CTP (SP1 Refresh).

Commençons par configurer une tâche simple. Jetons un coup d'œil à la programmation synchrone, en utilisant des rappels pour améliorer la programmation asynchrone et AsyncLes méthodes de programmation, puis analysons-les à travers elles, AsyncDe quoi s'agit-il exactement et qu'est-ce que cela nous apporte.

Tâche :

Créer une application Windows Form, lorsque l'on clique sur le bouton, Affichez d'abord une ligne de mots, par exemple, commencez à calculer quelque chose pour indiquer le statut, puis calculez de 1 à int.Max/2 Accumulez et affichez le résultat.

Synchronisation, nous allons faire ceci :

Tout d'abord, écrivez une fonction pour implémenter l'algorithme de base :

 
private
 
void
 btnSync_Click(
object
 sender, 
EventArgs
 e)

                     {

                         lblResult.Text = 
"Start to do something . . ."
;

                         
long
 value = DoSomething(
int
.MaxValue / 2);

                         lblResult.Text = value.ToString();

                     }

然后，添加一个按钮的Click事件处理程序：

 
private
 
void
 btnSync_Click(
object
 sender, 
EventArgs
 e)

                     {

                         lblResult.Text = 
"Start to do something . . ."
;

                         
long
 value = DoSomething(
int
.MaxValue / 2);

                         lblResult.Text = value.ToString();

                     }

代码第一行改写Label的字样；第二行调用算法获得结果；第三行把结果输出。看似挺不算的。运行一下，就会发现有两个问题：

1. 这个算法需要四五秒钟左右的实现时间，并且在这几秒钟的时间里，界面是锁死的，也就是说应用程序就像死了一样，它不接受任何用户操作。（也许我的电脑比较差，呵呵，所以，如果你没有遇到这种情况，请加大输入参数的值，让它算一会儿。）

1. 我们没有看到Start to do something这一行字。

 

OK，出现这个现象也是可以理解的，因为我们把大量的运算添加到了UI线程里面了。所以，解决方法就是把它放到外面。我试了一下不用Async，实现的代码如下：

private
 
void
 btnCallback_Click(
object
 sender, 
EventArgs
 e)

                     {

                         lblResult.Text = 
"Start to do something . . ."
;

                         Func<
int
, 
long
> callBackDelegate = 
this
.DoSomething;
            callBackDelegate.BeginInvoke(

                             
int
.MaxValue / 2,

                             
new
 AsyncCallback(

                             a =>

                             {

                                 lblResult.Invoke(
new
 MethodInvoker(() =>

                                     {

                                         lblResult.Text = callBackDelegate.EndInvoke(a).ToString();

                                     }));

                             }),

                             
null
);

                     }

如果你觉得这段代码比较晕，那就跳过这一节吧。可能我代码写得不好，大家将就看我简单解释一下，我首先给DoSomething写了一个代理，然后，调用了代理的BeginInvoke方法，把算法放到了其它的Thread中去调用了。这个代理执行完了以后，因为它不会直接返回一个long型的值，而是会去执行一个AsyncCallBack，所以，就在这个Callback里，去调用这个代理的EndInvoke()。

 

好吧，且不论代码质量，这个就是有Async之前的一种实现异步的方法。

从这个代码里，我们完全看不到原来代码的影子，我也没有办法像解释同步代码一样解释：第一、第二、第三……有了Async之后呢？呵呵，代码说明一切：

public
 
Task
<
long
> DoSomethingAsync(
int
 n)

                     {

                        
return
 
TaskEx
.Run<
long
>(() => DoSomething(n));

                     }
 
        
private
 
async
 
void
 btnAsync_Click(
object
 sender, 
EventArgs
 e)

                     {

                         lblResult.Text = 
"Start do something..."
;

                         
var
 x = 
await
 DoSomethingAsync(
int
.MaxValue / 2);

                         lblResult.Text = x.ToString();

                     }

Trois choses :

Première : Ajouter une référence de fichier : AsyncCtpLibrary.dll. Je crois qu'après la sortie officielle de Async, cela apparaîtra dans l'ensemble d'applications .NET.

Deuxième : Encapsuler DoSomething dans une Tâche.

Troisième : ajoutez quelques mots-clés, tels que async, tels que await.

Regardons de plus près le code :

Tout d'abord, j'écris la valeur de retour du code à exécuter de manière asynchrone sous la forme Tâche8742468051c85b06f0a0af9e3e506b5c. Cette valeur de retour a en fait trois options : void, Task et Task8742468051c85b06f0a0af9e3e506b5c, pour plus de détails sur la façon de l'utiliser, veuillez consulter Task dans MSDN sur C#4.0 Cours.

Ensuite, j'ai appelé la méthode Run4db15037c2d45d75b28ec2b6a696f099 dans TaskEx, Pass c'est une méthode qui renvoie une valeur de long - c'est l'algorithme pour notre tâche.

Si vous êtes intéressé à étudier, vous pouvez jeter un œil à Run8742468051c85b06f0a0af9e3e506b5c appelle en fait Tâche .Factory. StartNew8742468051c85b06f0a0af9e3e506b5c, et ce Start48c15ee73f6e332a8a171e10c6563c6c construit d'abord une Tâche, et puis sa méthode Start est appelée...

D'accord, scellez l'algorithme dans une tâche et terminez-la.

La deuxième partie du code est plus facile à expliquer :

La première ligne réécrit les mots Label; La deuxième ligne appelle l'algorithme pour obtenir le résultat ; la troisième ligne affiche le résultat. <--Copié dans cette ligne/collé de l'article précédent:-)

Héhé, regardons de plus près et comparons Sync et Async Code :

Sync	Async
privé void btnSync_Click(objet expéditeur, EventArgs e)                     {                         lblResult.Text = "Commencez à faire quelque chose. . .";                         long value = DoSomething(int.MaxValue / 2);                         lblResult.Text = value.ToString();                     }	privé async void btnAsync_Click(objet expéditeur, EventArgs e)                     {                         lblResult.Text = "Commencez à faire quelque chose...";                         var x = attendre DoSomethingAsync(int.MaxValue / 2);                         lblResult.Text = x.ToString();                     >

Tout d'abord, nous ajoutons la modification async au nom de la méthode pour déclarer qu'il s'agit d'une méthode avec des appels asynchrones

Ensuite, nous ajoutons un appel de fonction (DoSomethingAsync) avant de renvoyer le mot-clé await. Devinons quel est le type x ? La réponse est de type long. Avec await, même lors de la conception, le compilateur convertira automatiquement le type de Tâche8742468051c85b06f0a0af9e3e506b5c en Tapez T. Le code se termine ici, mais que nous apporte la nouvelle fonctionnalité

Async

? Est-ce la capacité de la programmation asynchrone ? Nous pouvons également utiliser Callback pour réaliser un fonctionnement asynchrone, et l'interface IAsyncCallback doit être dans .NET 1.1 ; l'espace de noms multithread existe également depuis longtemps Task a été introduit dans C# 4.0... Je pense que Async

apporte aux programmeurs un code centré sur la logique et programmation threadée multi-implémentation. Grâce à la comparaison finale, on voit que le code de

Async est presque le même que le code de Sync, et le programme non plus besoin de consacrer beaucoup d'efforts. Tenir compte des problèmes tels que les rappels, la synchronisation, etc... Cela est cohérent avec la direction dans laquelle C# a travaillé dur pour décrire ce qui est. fait plutôt que comment le faire. Enfin, joignez le téléchargement de l'application et le code source, ainsi que des captures d'écran de l'interface en cours d'exécution... (D'accord, je ne suis pas un artiste, veuillez pardonner moi :-) )

Cliquez pour télécharger le code source

Cliquez sur

Async

pour voir Accédez à l'invite d'exécution :

Affichez le résultat de l'exécution :

Les informations Async les plus récentes et les plus officielles sont ici : ^v^

http://msdn.microsoft.com/Async

Ce qui précède est le Explication graphique détaillée du code de la fonction C# 5.0 Async en un coup d'œil, pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !