Source: http://blog.csdn.net/cjq1234/article/details/7536644
Absrtact: Using the serial running state machine simulation to realize the asynchronous
Today in the StackOverflow website see a good explanation, excerpt and play it,
It works similarly to the yield return keyword in C # 2.0.
An asynchronous method isn't actually a ordinary sequential method. It is compiled to a state machine (a) and some state (local variables are turned into fields of the object). Each blocks of code between two uses of await is one ' step ' of the state machine.
This means the starts, it just runs the "the" "the" Les some work to be done-when the work are done, it would run the next step of the state machine. For example this code:
[CSharp] view plain copy print? Async task demo () { var v1 = foo (); var v2 = await bar (); more (v1, v2); }
Async Task Demo () {
var v1 = foo ();
var v2 = await bar ();
More (v1, v2);
}
Would be translated to something like:
[CSharp] class _demo { int _v1, _v2; int _state = 0; Task<int> _await1; public void step () { switch (this._state) { case 0: foo (); this._v1 = foo (); this._await1 = bar (); // When the async operation completes, it will call this method this._state = 1; op. Setcontinuation (step); case 1: this._v2 = this._Await1. result; // get the result of the operation more (THIS._V1,&NBSP;THIS._V2); } }
Class _demo {
int _v1, _V2;
int _state = 0;
Task<int> _await1;
public void Step () {
switch (this._state) {case
0:
foo ();
THIS._V1 = foo ();
This._await1 = Bar ();
When the async operation completes, it'll call this method
this._state = 1;
Op. Setcontinuation (step);
Case 1:
this._v2 = this._await1. result; Get the ' result
' of the Operation More (THIS._V1, THIS._V2);
}
The important part is this it just uses the Setcontinuation method to specify operation, it completes Call the "step" Method Again (and "method knows" that it should run the second bit of the original code using the _state field). You can easily imagine this setcontinuation would be something like btn. Click + = step, which would run completely on a single thread.
The asynchronous programming model in C # is very close to F # asynchronous workflows (in fact, it is essentially the same t Hing, aside from some technical details), and writing reactive single-threaded GUI applications using Async is quite a in teresting Area-at Least I So-see for example this article (maybe I should write a C # version now:-)).
The translation is similar to iterators (with yield return) and in fact, it was possible to use iterators to implement Asyn Chronous Programming in C # earlier. I wrote an article about this a while ago-and I I am the it can still give you some insight on how the translation works.
answered by Tomas Petricek
Roughly speaking, async and await simulate a state machine (the above _state variable to maintain state), async the work of a sequential execution into 3 pieces, one is time-consuming work of the first order, one is time-consuming work, there is a time-consuming work of the follow-up,
[CSharp]Async Task Demo () {var v1 = pre-order work (); var v2 = await time consuming work (); Follow-up work (V1, v2); }
Async Task Demo () {
var v1 = pre-order work ();
var v2 = await time consuming work ();
Follow-up work (V1, v2);
}
Be translated into a state machine
[CSharp] class state machine { int _v1, _v2; int state variable = starting state; Task<int> _await1; public void step () { switch (this. Status variable) { case starting State: this._v1 = Pre-order work (); this._await1 = time-consuming work (); //&nBSP;, asynchronous work will change the state variable value when the time consuming work is done asynchronously this. State variable = successfully completed; continue to call itself that step function; //op. Setcontinuation (step); case successfully completed: this._v2 = this._ Await1. result; //time-consuming work results follow-up work (THIS._V1,&NBSP;THIS._V2); } }
Class state machine {
int _v1, _V2;
int state variable = starting state;
Task<int> _await1;
public void Step () {
switch (this. State variable) {case
start state:
THIS._V1 = pre-order work ();
This._await1 = time-consuming work ();
When a time-consuming work completes asynchronously, the asynchronous work will change the state variable value this
. state variable = successfully completed;
Continue to call itself the step function; //op. Setcontinuation (step);
Case successfully completed:
THIS._V2 = this._await1. result; Time-consuming work Results
follow-up (THIS._V1, THIS._V2);
}
In fact, we can also invoke asynchronous functions like the state machine class above in the. NET Framework 4, so that the logic of the synchronous invocation is maintained and understood, and the biggest benefit is that the loop is much simpler to handle.