Continuación de una tarea <T> en una tarea <U> sin bloqueo en el resultado

Question

Tengo dos métodos asincrónicos Task<int> DoInt() y Task<string> DoString(int value). Tengo un tercer método asincrónico Task<string> DoBoth(int value) cuyo objetivo es ejecutar de forma asincrónica DoInt(), la salida de la tubería es DoString(int) y el resultado es el resultado de DoBoth().

Las limitaciones importantes son:

1. Puede que no tenga el código fuente a DoInt() o DoString(), así que no puedo modificarlos.
2. no quiero bloquear en cualquier punto
3. salida (resultado) de una tarea debe ser pasado como entrada a la siguiente
4. La salida final (resultado) es lo que yo quiero ser el resultado de DoBoth()

La clave es que ya tengo métodos que son asíncronos (es decir, devolver tarea) y quiero canalizar datos de tarea a tarea, sin bloquear en el camino, devolviendo el resultado final en la tarea inicial. Puedo hacer todo lo siguiente, excepto no bloquear en el siguiente código:

Código ejemplo:

// Two asynchronous methods from another library, i.e. can't be changed 
Task<int> DoInt(); 
Task<string> DoString(int value); 

Task<string> DoBoth() 
{ 
    return DoInt().ContinueWith<string>(intTask => 
    { 
     // Don't want to block here on DoString().Result 
     return DoString(intTask.Result).Result; 
    }); 
} 

Desde Task<string> DoString(int) ya es un método asíncrono, ¿cómo puedo crear una continuación limpiamente sin bloqueo a ella? De hecho, quiero crear una continuación de una Tarea existente y no de una Func.

Answer 1

Usted puede escribir toda la cadena usando TaskExtensions.Unwrap como:

Task<string> DoBoth(int value) 
{ 
    Task<Task<string>> task = DoInt(value).ContinueWith(valueTask => 
    { 
     return DoString(valueTask.Result); 
    }); 

    return task.Unwrap(); 
} 

Tenga en cuenta que esto supone que DoInt se define como Task<int> DoInt(int value);, que difiere de su descripción, sino que sigue el ejemplo de código.

Si DoInt no toma un argumento int (coincidentes con sus declaraciones), esto podría convertirse en:

Task<string> DoBoth() 
{ 
    return DoInt().ContinueWith(t => DoString(t.Result)).Unwrap(); 
} 

---

Como extra - usando C# 5 y .NET 4.5 (o el paquete asíncrono de orientación) , puede escribir esto como:

async Task<string> DoBoth(int value) 
{ 
    int first = await DoInt(value); 
    return await DoString(first); 
} 

Answer 2

Necesita algo así como el método flatMap en lenguajes funcionales. http://en.wikipedia.org/wiki/Monad_%28functional_programming%29#fmap_and_join