C# 是否可以确定一个方法是否返回一个任务并等待它返回？

我的目标是将任何具有返回类型的函数传递给我的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);
        }
    }

publicstatictresult执行（Func方法）
结果：在哪里上课
{
var result=method（）；
如果（结果是任务）
{
var taskResult=等待结果；
StoreResult（taskResult）；
}
其他的
{
存储结果（result）；
}
}

下面是一个精心设计的示例，展示了如何实现这一点

我怀疑这种模式是否明智。我更喜欢总是返回任务，即使任务并不总是需要的。

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 ) );
}

公共异步任务Foo（）
{
var mightBeATask=Bar（）；
var task=作为任务的可能任务；
如果（任务！=null）
{
返回等待任务；
}
返回（T）可能的任务；
}
私有对象栏（）
{
返回Task.FromResult（默认值（T））；
}

我同意Lee的意见，即为

Func

单独设置重载是正确的解决方案

但是，如果您真的想使用一个重载来实现这一点，您可以使用反射和

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);
    }
}

公共异步静态任务执行（Func方法），其中TResult:class
{
var result=method（）；
if（typeof（TResult）.IsGenericType
&&typeof（TResult）.GetGenericTypeDefinition（）==typeof（任务））
{
var taskResult=等待（动态）结果；
StoreResult（taskResult）；
}
其他的
{
存储结果（result）；
}
}

创建两个重载，一个接受

Func

，另一个接受

Func

。谢谢！我想我要做的是超负荷，但这正是我想要的。