Detaillierte grafische Code-Erklärung der C# 5.0-Funktion Async auf einen Blick

Es ist einen Monat her, seit Microsoft Async CTP veröffentlicht hat, und alle reden darüber Async. Wenn Sie mit Async bereits sehr vertraut sind, dann überspringen Sie es bitte ... Wenn Sie wie ich sind, kennen Sie sich nur ein wenig mit asynchroner Programmierung aus, haben aber das Gefühl, dass das vorherige Da die asynchrone Programmierung problematischer ist, wollen wir erkunden, was uns die nächste Generation von C# bringen wird. (Async CTP unterstützt auch VB.)

Das Beispiel in diesem Artikel basiert auf Async CTP SP1 Refresh. Da sich Async noch im CTP-Stadium befindet, werden viele Dinge noch besprochen, also warten Sie vielleicht bis C# 5.0 Details werden sich bei Veröffentlichung ändern. An der allgemeinen Idee und dem Konzept dürfte sich jedoch nicht viel ändern.

Kommen Sie auf den Punkt:

Probieren Sie zunächst die Funktion Async aus, Wir müssenVisual Studio 2010 SP1 und Microsoft Visual Studio Async CTP (SP1 Refresh) installieren.

Lassen Sie uns zunächst einen Blick auf die synchrone Programmierung werfen, wobei Callbacks zur Verbesserung der asynchronen Programmierung und AsyncProgrammiermethoden, und dann analysieren wir sie anhand dieser, AsyncWas genau ist das und was bringt es uns?

Eine Windows Form-Anwendung erstellen, wenn auf die Schaltfläche geklickt wird, Zeigen Sie zunächst eine Wortzeile an, beginnen Sie beispielsweise mit der Berechnung, um den Status anzuzeigen, und berechnen Sie dann von 1 bis int.Max/2 Sammeln Sie das Ergebnis und zeigen Sie es an.

  #region
 Do things

                     
public
 
long
 DoSomething(
int
 n)

                     {

                         
long
 result = 1;

                         
for
 (
int
 i = 1; i <= n; i++)

                         {

                             result += i;

                         }

                         
return
 result;

                     }
        #endregion

 
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，实现的代码如下：

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

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

从这个代码里，我们完全看不到原来代码的影子，我也没有办法像解释同步代码一样解释：第一、第二、第三……有了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
);

                     }

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

                     }

Drei Dinge:

Erstens: Dateiverweis hinzufügen: AsyncCtpLibrary.dll. Ich glaube, dass dies nach der offiziellen Veröffentlichung von Async im Anwendungssatz .NET erscheinen wird.

Zweitens: Kapseln Sie DoSomething in eine Aufgabe.

Drittens: Fügen Sie einige Schlüsselwörter hinzu, z. B. async, z. B. await.

Schauen wir uns den Code genauer an:

Zuerst schreibe ich den Rückgabewert des Codes, der asynchron ausgeführt werden soll, als Aufgabe. Dieser Rückgabewert hat tatsächlich drei Optionen: void, Task und Task, Einzelheiten zur Verwendung finden Sie unter Aufgabe in MSDN auf C#4.0 Klasse.

Dann habe ich die Methode Run in TaskEx Pass genannt Es ist eine Methode, die einen Wert von long zurückgibt – das ist der Algorithmus für unsere Aufgabe.

Wenn Sie Interesse am Lernen haben, können Sie einen Blick auf Runtatsächliche Aufrufe Aufgabe werfen .Factory. StartNew, und dieser Start erstellt zunächst eine Aufgabe, und dann wird die Methode Start aufgerufen...

Okay, versiegeln Sie den Algorithmus in einer Aufgabe und schließen Sie sie ab.

Der zweite Teil des Codes ist einfacher zu erklären:

Die erste Zeile schreibt die Wörter Label; Die zweite Zeile ruft den Algorithmus auf, um das Ergebnis zu erhalten; die dritte Zeile gibt das Ergebnis aus. <--In diese Zeile kopiert/aus dem vorherigen Artikel eingefügt:-)

Hehe, schauen wir mal genauer hin und vergleichen Sync und Async Code:

Zuerst fügen wir async zum Methodennamen hinzu, um zu deklarieren, dass es sich um eine Methode mit asynchronen Aufrufen handelt;

DoSomethingAsync) hinzu, bevor wir das Schlüsselwort await zurückgeben. Lassen Sie uns raten, welcher Typ x ist? Die Antwort ist vom Typ lang. Mit await konvertiert der Compiler bereits während des Entwurfs automatisch den Typ von Task in Typ T. Der Code endet hier, aber was bringt uns die neue Funktion

Callback verwenden, um einen asynchronen Betrieb zu erreichen, und die Schnittstelle IAsyncCallback sollte sich in .NET 1.1 befinden implementiert; der Multithread-Namespace existiert auch schon seit langem; Task wurde in C# 4.0... Ich denke, Async

fast derselbe ist wie der Code von Sync und die Programm-Nr Es muss mehr Aufwand betrieben werden. Berücksichtigen Sie Probleme wie Rückrufe, Synchronisierung usw. Dies steht im Einklang mit der Richtung, in der C# hart gearbeitet hat getan, statt wie man es macht. Schließlich fügen Sie den Anwendungs-Download und den Quellcode sowie Screenshots der laufenden Benutzeroberfläche bei ... (Okay, ich bin kein Künstler, bitte verzeihen Sie ich:-) )

Klicken Sie hier, um den Quellcode herunterzuladen

Klicken Sie auf

Zeigen Sie das Ausführungsergebnis an:

Die neuesten und offiziellsten Async-Informationen finden Sie hier: ^v^