Question

我的目标是将任何带有返回类型的函数传递给我的Execute方法，并序列化并存储其结果。下面是我想要做的一个粗略的想法，显然不会编译，但希望它能得到这个想法。我想我也应该能够递归地处理嵌套的任务。想法？

public static TResult Execute<TResult>(Func<TResult> method)
        where TResult : class
    {

        var result = method();
        if(result is Task)
        {
            var taskResult = await result;
            StoreResult(taskResult);
        }
        else
        {
            StoreResult(result);
        }
    }

Answer 1

这是一个人为的例子，展示了如何做到这一点。

我质疑这种模式的智慧。即使不总是需要任务，我也更愿意总是返回任务。 Task.FromResult()的开销通常可以忽略不计。

public async Task<T> Foo<T>()
{
    var mightBeATask = Bar<T>();
    var task = mightBeATask as Task<T>;

    if( task != null )
    {
        return await task;
    }

    return (T)mightBeATask;
}

private object Bar<T>()
{
    return Task.FromResult( default( T ) );
}

Answer 2

我同意Lee的意见，即对Func<Task<TResult>>单独重载是正确的解决方案。

但是如果你真的想使用一个重载来做这件事，你可以使用反射和dynamic来实现这个目的：

public async static Task Execute<TResult>(Func<TResult> method) where TResult : class
{
    var result = method();

    if (typeof(TResult).IsGenericType
        && typeof(TResult).GetGenericTypeDefinition() == typeof(Task<>))
    {
        var taskResult = await (dynamic)result;
        StoreResult(taskResult);
    }
    else
    {
        StoreResult(result);
    }
}

有可能确定一个方法是否返回一个Task并等待它，如果有的话？

2 个答案: