public partial class MainWindow : Window    {        private async void StartButton_Click(object sender, RoutedEventArgs e)        {            int contentLength = await AccessTheWebAsync();            resultsTextBox.Text +=                String.Format("\r\nLength of the downloaded string: {0}.\r\n", contentLength);        }        async Task
    
      AccessTheWebAsync()        {             HttpClient client = new HttpClient();            Task
     
       getStringTask = client.GetStringAsync("http://msdn.microsoft.com");            DoIndependentWork();            string urlContents = await getStringTask;            return urlContents.Length;        }        void DoIndependentWork()        {            resultsTextBox.Text += "Working . . . . . . .\r\n";        }    }
     
    

1         private void StartButton_Click(object sender, RoutedEventArgs e)2         {3             int contentLength = AccessTheWebAsync().Result;4 5             resultsTextBox.Text +=6                 String.Format("\r\nLength of the downloaded string: {0}.\r\n", contentLength);7         }

class Foo    {        public IEnumerable
    
      AnIterator()        {            yield return "1";            yield return "2";            yield return "3";        }    }    class Program    {        static void Main()        {            var collection = new Foo();            foreach (var s in collection.AnIterator())            {                Console.WriteLine(s);            }        }    }
    

private bool MoveNext()        {            switch (this.<>1__state)            {                case 0:                    this.<>1__state = -1;                    this.<>2__current = "1";                    this.<>1__state = 1; //修改当前状态为1                    return true;                case 1:                    this.<>1__state = -1;                    this.<>2__current = "2";                    this.<>1__state = 2; //修改当前状态为2                    return true;                case 2:                    this.<>1__state = -1;                    this.<>2__current = "3";                    this.<>1__state = 3; //修改当前状态为3                    return true;                case 3:                    this.<>1__state = -1;                    break;            }            return false;        }

private static IEnumerator
    
      PipeServerAsyncEnumerator(AsyncEnumerator ae) {   // Each server object performs asynchronous operations on this pipe   using (var pipe = new NamedPipeServerStream(      "Echo", PipeDirection.InOut, -1, PipeTransmissionMode.Message,      PipeOptions.Asynchronous | PipeOptions.WriteThrough)) {      // Asynchronously accept a client connection      pipe.BeginWaitForConnection(ae.End(), null);      yield return 1;       // A client connected, let's accept another client      var aeNewClient = new AsyncEnumerator();      aeNewClient.BeginExecute(PipeServerAsyncEnumerator(aeNewClient),         aeNewClient.EndExecute);      // Accept the client connection      pipe.EndWaitForConnection(ae.DequeueAsyncResult());      // Asynchronously read a request from the client      Byte[] data = new Byte[1000];　　　　pipe.BeginRead(data, 0, data.Length, ae.End(), null);       yield return 1;                // The client sent us a request, process it.       Int32 bytesRead = pipe.EndRead(ae.DequeueAsyncResult());               // My sample server just changes all the characters to uppercase               // But, you can replace this code with any compute-bound operation       data = Encoding.UTF8.GetBytes(                  Encoding.UTF8.GetString(data, 0, bytesRead).ToUpper().ToCharArray());               // Asynchronously send the response back to the client       pipe.BeginWrite(data, 0, data.Length, ae.End(), null);               　　　　        yield return 1;               // The response was sent to the client, close our side of the connection       pipe.EndWrite(ae.DequeueAsyncResult());       } // Close happens in a finally block now!}
    

private static async Task
    
      MyMethodAsync(Int32 argument) {   Int32 local = argument;   try {      Type1 result1 = await Method1Async();      for (Int32 x = 0; x < 3; x++) {         Type2 result2 = await Method2Async();      }   }   catch (Exception) {      Console.WriteLine("Catch");   }   finally {      Console.WriteLine("Finally");　　}   return "Done";}
    

// This is the state machine method itselfvoid IAsyncStateMachine.MoveNext() {   String result = null;   // Task's result value   // Compiler­inserted try block ensures the state machine’s task completes   try {      // Assume we're logically leaving the 'try' block      // If 1st time in state machine method,      // execute start of original method      Boolean executeFinally = true;      if (m_state == ­1) {         m_local = m_argument;      }      // Try block that we had in our original code      try {         TaskAwaiter
    
      awaiterType1;         TaskAwaiter
     
       awaiterType2;         switch (m_state) {            case ­1: // Start execution of code in 'try'               // Call Method1Async and get its awaiter               awaiterType1 = Method1Async().GetAwaiter();               if (!awaiterType1.IsCompleted) {                  m_state = 0;                   // 'Method1Async' is completing asynchronously                  m_awaiterType1 = awaiterType1; // Save the awaiter for when we come back 　　　　　　　　　　// Tell awaiter to call MoveNext when operation completes                  m_builder.AwaitUnsafeOnCompleted(ref awaiterType1, ref this);                  // The line above invokes awaiterType1's OnCompleted which approximately calls ContinueWith(t => MoveNext()) on the Task being awaited.                                    executeFinally = false;        // We're not logically leaving the 'try' block                  return;                        // Thread returns to caller               }               // 'Method1Async' completed synchronously               break;            case 0:  // 'Method1Async' completed asynchronously               awaiterType1 = m_awaiterType1;  // Restore most­recent awaiter               break;      　　　　case 1:  // 'Method2Async' completed asynchronously                        awaiterType2 = m_awaiterType2;  // Restore most­recent awaiter                        goto ForLoopEpilog;      　　}　　　　　　　 //下面省略的是loop部分和异常处理部分，分开看比较容易看懂
     
    

　　　　　　　　.....      }   m_builder.SetResult(result);}

// After the first await, we capture the result & start the 'for' loop                  m_resultType1 = awaiterType1.GetResult(); // Get awaiter's result               ForLoopPrologue:                  m_x = 0;          // 'for' loop initialization                  goto ForLoopBody; // Skip to 'for' loop body               ForLoopEpilog:                  m_resultType2 = awaiterType2.GetResult();                  m_x++;            // Increment x after each loop iteration                  // Fall into the 'for' loop’s body               ForLoopBody:                  if (m_x < 3) {  // 'for' loop test                     // Call Method2Async and get its awaiter                     awaiterType2 = Method2Async().GetAwaiter();                     if (!awaiterType2.IsCompleted) {                        m_state = 1;                   // 'Method2Async' is completing asynchronously                        m_awaiterType2 = awaiterType2; // Save the awaiter for when we come back                        // Tell awaiter to call MoveNext when operation completes                        m_builder.AwaitUnsafeOnCompleted(ref awaiterType2, ref this);                        executeFinally = false;        // We're not logically leaving the 'try' block                        return;                        // Thread returns to caller                     }                     // 'Method2Async' completed synchronously                     goto ForLoopEpilog;  // Completed synchronously, loop around               }