method - task c# ejemplo

¿Es segura la recursión asincrónica en C#(async ctp/.net 4.5)?

Question

En C # con async ctp o la versión beta de vs.net 2011 podemos escribir código recursivo como este:

public async void AwaitSocket()
{
    var socket = await this.AcceptSocketAsync(); //await socket and >>return<< to caller
    AwaitSocket(); //recurse, note that the stack will never be deeper than 1 step since await returns..
    Handle(socket); // this will get called since "await" returns
}

En esta muestra específica, el código async espera un zócalo tcp y una vez que ha sido aceptado, se repetirá y sincronizará en espera de otro.

Esto parece funcionar bien, ya que la sección de espera hará que el código regrese a la persona que llama y, por lo tanto, no cause un desbordamiento de la pila.

Entonces dos preguntas aquí:

1. si ignoramos el hecho, estamos tratando con tomas de esta muestra. ¿Está bien hacer la recursión sin pila de esta manera? o hay inconvenientes que me falta?

2. desde una perspectiva IO, ¿el código anterior sería suficiente para manejar todas las solicitudes entrantes? Me refiero a solo esperar uno, y una vez que sea aceptado, empiece a esperar otro. ¿Algunas solicitudes fallarán debido a esto de alguna manera?

Answer 1

De la discusión anterior, creo que algo así será el mejor enfoque. Por favor, den sus comentarios

public async void StartAcceptingSockets()
{
    await Task.Yield(); 
    // return to caller so caller can start up other processes/agents
    // TaskEx.Yield in async ctp , Task.Yield in .net 4.5 beta

    while(true)
    {
        var socket = await this.AcceptSocketAsync();
        HandleAsync(socket); 
        //make handle call await Task.Yield to ensure the next socket is accepted as fast 
        //as possible and dont wait for the first socket to be completely handled
    } 
}

private async void HandleAsync(Socket socket)
{
      await Task.Yield(); // return to caller

      ... consume the socket here...
}