c# - programming - Encadenando dos funciones()-> Tarea<A> y A-> Tarea<B>

task c# example

Question

No sé si estoy pensando de forma incorrecta sobre TPL, pero tengo dificultades para entender cómo obtener lo siguiente:

Tengo dos funciones

Task<A> getA() { ... }
Task<B> getB(A a) { ... }

Esto parece ocurrir a menudo: puedo obtener asincrónicamente una A. Y con una A, puedo obtener asincrónicamente una B.

No puedo descifrar la forma correcta de encadenar estas funciones juntas en TPL.

Aquí hay un intento:

Task<B> Combined()
{
    Task<A> ta = getA();
    Task<Task<B>> ttb = ta.ContinueWith(a => getB(a.Result));
    return ttb.ContinueWith(x => x.Result.Result);
}

El ContinueWith es donde me confundo. El tipo devuelto es una "Tarea doble", Task<Task<B>> . Esto de alguna manera me parece incorrecto.

ACTUALIZACIÓN 30-09-2011:

Por coincidencia, encontré el método de extensión TaskExtensions.Unwrap que opera en una Task<Task<T>> para dar una Task<T> . Hasta que obtengamos C # 5.0, puedo hacer ta.ContinueWith (a => ...). UnWrap () en situaciones como esta donde la continuación en sí misma devuelve una tarea.

Answer 1

¿Su getB tiene que ser un método que devuelva la Task<B> lugar de B ?

El problema es que ContinueWith es:

public Task<TNewResult> ContinueWith<TNewResult>(
    Func<Task<TResult>, TNewResult> continuationFunction,
    CancellationToken cancellationToken
)

Entonces, en su caso, porque getB devuelve la Task<B> , está pasando un Func<Task<A>, Task<B>> , entonces TNewResult es la Task<B> .

Si puede cambiar getB para simplemente devolver una B con una A , eso funcionaría ... o podría usar:

return ta.ContinueWith(a => getB(a.Result).Result);

Entonces la expresión lambda será del tipo, Func<Task<A>, B> entonces ContinueWith devolverá una Task<B> .

EDITAR: En C # 5 podrías escribir fácilmente:

public async Task<B> CombinedAsync()
{
    A a = await getA();
    B b = await getB(a);
    return b;
}

... así que es "solo" cuestión de averiguar cómo termina eso. Sospecho que es algo como esto, pero con manejo de errores:

public Task<B> CombinedAsync()
{
    TaskCompletionSource<B> source = new TaskCompletionSource();
    getA().ContinueWith(taskA => {
        A a = taskA.Result;
        Task<B> taskB = getB(a);
        taskB.ContinueWith(t => source.SetResult(t.Result));
    });
    return source.Task;
}

¿Tiene sentido?

Answer 2

En caso de que esté familiarizado con LINQ (y el concepto de Monad que lo respalda), a continuación encontrará una mónada Tarea simple que le permitirá componer las Tareas.

Implementación de Monad:

public static class TaskMonad
    {
        public static Task<T> ToTask<T>(this T t)
        {
            return new Task<T>(() => t);
        }

        public static Task<U> SelectMany<T, U>(this Task<T> task, Func<T, Task<U>> f)
        {
            return new Task<U>(() =>
            {
                task.Start();
                var t = task.Result;
                var ut = f(t);
                ut.Start();
                return ut.Result;
            });
        }

        public static Task<V> SelectMany<T, U, V>(this Task<T> task, Func<T, Task<U>> f, Func<T, U, V> c)
        {
            return new Task<V>(() =>
            {
                task.Start();
                var t = task.Result;
                var ut = f(t);
                ut.Start();
                var utr = ut.Result;
                return c(t, utr);
            });            
        }
    }

Ejemplo de uso:

        public static void Main(string[] arg)
        {
            var result = from a in getA()
                         from b in getB(a)
                         select b;
            result.Start();
            Console.Write(result.Result);
        }

Answer 3

Si bien la respuesta aceptada probablemente funcione

Task<B> Combined()
{
    Task<A> ta = getA();
    Task<B> ttb = ta.ContinueWith(a => getB(a.Result)).Unwrap();
    return ttb;
}

Es una forma mucho más elegante de implementar esto.

Answer 4

Si no puede usar await , puede usar Unwrap , pero maneja las excepciones de manera subóptima. El método que prefiero es Then como se describe en este artículo . La composición se vuelve simple y elegante:

Task<B> Combined()
{
  return getA().Then(getB);
}

Para aquellos interesados ​​en los detalles, hace un tiempo escribí una publicación en el blog sobre exactamente este problema de composición de métodos asíncronos, y cómo las mónadas proporcionan una solución elegante.