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...
}