async ctp recursion

Question

İlk oyunuma yaklaşık 15 dakika yaşıyorum async CTP ... (güzel).

Burada birlikte çaldı ettik gerçekten basit sunucu var:

internal class Server 
{ 
    private HttpListener listener; 
    public Server() 
    { 
     listener = new HttpListener(); 
     listener.Prefixes.Add("http://*:80/asynctest/"); 
     listener.Start(); 
     Go(); 
    } 

    async void Go() 
    { 
     HttpListenerContext context = await listener.GetContextAsync(); 
     Go(); 
     using (var httpListenerResponse = context.Response) 
     using (var outputStream = httpListenerResponse.OutputStream) 
     using (var sw = new StreamWriter(outputStream)) 
     { 
      await sw.WriteAsync("hello world"); 
     } 
    } 
} 

olarak görülebilir , kendisini çağıran Go zaman uyumsuz yöntem. Klasik olmayan asenkron dünyada, bu bir yığın taşmasına neden olur. Async yöntemiyle durumun böyle olmadığını sanıyorum, ama emin olmak isterdim, bir şekilde ya da diğeri. Kimse?

Answer 1

en basit bir şey içine yıkmak edelim:

async static void Go() 
{ 
    await Something(); 
    Go(); 
    await SomethingElse(); 
} 

Bu nasıl ile derleyici anlaşma? hatırlamak zorunda tüm her uyumsuz işlem tamamlandığında, "DoIt" Uygun üzerine (ileti döngüsü tarafından tekrar çağrılacak planlanan olmasıdır Şimdi

class HelperClass 
{ 
    private State state = STARTSTATE; 
    public void DoIt() 
    { 

     if (state == STARTSTATE) goto START; 
     if (state == AFTERSOMETHINGSTATE) goto AFTERSOMETHING; 
     if (state == AFTERSOMETHINGELSESTATE) goto AFTERSOMETHINGELSE; 

     START: 
     { 
      state = AFTERSOMETHINGSTATE; 
      var awaiter = Something().MakeAnAwaiter(); 
      awaiter.WhenDoneDo(DoIt); 
      return; 
     } 

     AFTERSOMETHING: 
     { 
      Go(); 
      state = AFTERSOMETHINGELSESTATE; 
      var awaiter = SomethingElse().MakeAnAwaiter(); 
      awaiter.WhenDoneDo(DoIt); 
      return; 
     } 

     AFTERSOMETHINGELSE: 

     return; 
    } 

    static void Go() 
    { 
     var helper = new HelperClass(); 
     helper.DoIt(); 
    } 

:

Temelde bu taslak gibi bir şey olur dersin yardımcısı örneği).

Peki ne oluyor? Çalış o zaman. İlk kez Go’yu ara. Bu bir numaralı yardımcı olur ve DoIt çağırır. Bu, Something() işlevini çağırır, bir görevi geri alır, bu görev için bir bekçiyi yapar, "işiniz bittiğinde, helper1.DoIt 'i çağırır" ve geri döndüğünde bekçiyi anlatır.

Bir saniye sonra, görev tamamlanır ve ileti döngüsü helper1'in DoIt işlevini çağırır. helper1'in durumu AFTERSOMETHINGSTATE olduğundan, goto’yu alıp Go’yu arayalım. Bu yardımcı 2 yapar ve bunun üzerine DoIt çağırır. Bu, Something() işlevini çağırır, bir görev alır, bu görev için bir bekçiyi yapar, "işiniz bittiğinde, yardımciye DoIt'i çağırır" bekleyicisine söyler ve kontrolü yardımcinin DoIt'e geri döndürür. Bu, SomethingElse'i çağırır, bu görev için bir bekçiyi yapar ve “başka bir şey yaptığınız zaman, helper1'in DoIt'ını arayın” diye söyler. Daha sonra geri döner.

Artık iki görevimiz sıra dışı ve yığında kod yok. Görevlerden biri ilk önce tamamlanacak. SomethingElse görevinin önce tamamlandığını varsayalım. Mesaj döngüsü, hemen geri dönen helper1.DoIt() öğesini çağırır. Helper1 şimdi çöp.

Daha sonra ileti döngüsü helper2.DoIt() yöntemini çağırır ve dalları AFTERSOMETHING. Şimdi Go() çağrılır, bu da helper3 ...

Burada hayır, burada sınırsız bir tekrarlama yok. Go her zaman çalıştırıldığında, asenkronize bir şekilde Something() işlevini başlatır ve daha sonra arayan kişiye geri döner. Bir şeyden sonra eşyalara yapılan çağrı daha sonra olur. "Git", her seferinde bir defada sadece bir defada.