I am currently using this code to attempt to dynamically execute a saved Func<object>:

public async Task<object> GetFuncResult(string funcName),c#,delegates,generic-programming"/>
	














    

		

        

            
            时间戳
        

		

		

        
		

    
















	
首页  > 解决方案 > 获取 Func 的结果 when object is a Task

I am currently using this code to attempt to dynamically execute a saved Func<object>:



public async Task<object> GetFuncResult(string funcName)












c# - 获取 Func 的结果 when object is a Task

I am currently using this code to attempt to dynamically execute a saved Func<object>:



public async Task<object> GetFuncResult(string funcName)





问题描述



I am currently using this code to attempt to dynamically execute a saved Func<object>:



public async Task<object> GetFuncResult(string funcName) {
    Func<object> func = _savedFuncs[funcName];
    bool isAwaitable = func.Method.ReturnType.GetMethod(nameof(Task.GetAwaiter)) != null;
    if (!isAwaitable) return func();
    else return await ((Func<Task<object>>)func)();
}




If somebody stores a Func<Task<object>> or a Func<[anything]> this code works fine.  But if somebody stores a Func<Task<string>> (or any other generic argument in the Task), it breaks.



Unable to cast object of type Func<Task<System.String>> to type Func<Task<System.Object>>



My question is: How do I await the result of the Func<Task<Something>> at this point and just return that value as an object?



Full Test Code:



using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsole
{
    class Program
    {
        static Dictionary<string, Func<object>> _savedFuncs;

        static async Task Main(string[] args)
        {
            _savedFuncs = new Dictionary<string, Func<object>>();
            Func<Task<string>> myTask = async () => { return "Test Success"; };
            _savedFuncs.Add("myFunc", myTask);
            Console.WriteLine((await GetFuncResult("myFunc")) ?? "No Value Returned");
            Console.ReadKey();
        }

        public static async Task<object> GetFuncResult(string funcName)
        {
            Func<object> func = _savedFuncs[funcName];
            bool isAwaitable = func.Method.ReturnType.GetMethod(nameof(Task.GetAwaiter)) != null;
            if (!isAwaitable) return func();
            return await ((Func<Task<object>>)func)();
        }
    }
}










I'm not entirely clear on what your intent here is, because the code is not clear. You are looking for a GetAwaiter() method on the return type, but of course there are types other than Task which have this method. Also, your code will miss things that are awaitable by virtue of extension method.



If you are going to assume the function returns a task object (which the code currently does), then you should just check for that instead of the GetAwaiter() method. Conversely, you should just invoke the GetAwaiter() method dynamically, so that anything with the method is accommodated.



Personally, if this code isn't going to be invoked very often, I would use dynamic, try to call GetAwaiter(), catch the exception if that fails (because the method isn't present) and just invoke the delegate directly. If perf is important, you can memoize the type-to-awaiter status so that the exception can be skipped after you hit it once. Note that using dynamic, you'll accommodate most awaitable scenarios (it still won't find extension-method GetAwaiter()s).



Here is an example of that:



private static readonly HashSet<MethodInfo> _notAwaitable = new HashSet<MethodInfo>();

public static async Task<object> GetFuncResult(string funcName)
{
    Func<object> func = _savedFuncs[funcName];
    dynamic result = func();

    if (!_notAwaitable.Contains(func.Method))
    {
        try
        {
            return await result;
        }
        catch (RuntimeBinderException) { } // not awaitable

        _notAwaitable.Add(func.Method);
    }

    return result;
}




This should do what you want, and should also be performant. The dynamic runtime support already caches the resolution of the awaitable scenario, and by storing the non-awaitable MethodInfo instances in the hash set, the code avoids ever suffering the RuntimeBinderException more than once for any given delegate target method.



Once the code's "warmed up" (i.e. has been invoked in the way it will on subsequent passes), it should not be a bottleneck.



Note that the implementation above assumes you are not using multicast delegates. Given the context, that seems like a reasonable assumption, since there's no built-in language support for awaitable multicast delegates (or rather, it will work, but nothing in the runtime resolves the ambiguity as to which awaitable is awaited). But you could of course extend the above to support multicast delegates if you really needed that.



If you don't care about supporting all awaitable scenarios, but only Task-based ones, you can simplify the above a bit like this:



public static async Task<object> GetFuncResult(string funcName)
{
    Func<object> func = _savedFuncs[funcName];
    object result = func();

    if (result is Task task)
    {
        await task;
        return ((dynamic)task).Result;
    }

    return result;
}




Here, the type-check for Task is used in lieu of the hash set. Again, the dynamic runtime support will cache the Result accessor for each type of task used with this method, so once warmed up will perform just as well as any other dynamically-oriented solution.



Finally, note that if you have a Func<Task>, the above won't work, because it assumes all Task objects have a valid result. One might argue that given the ambiguity, it'd be best to not populate the dictionary with anything like that in the first place. But assuming that scenario is of concern, the above can be modified to account for the possibility:



public static async Task<object> GetFuncResult(string funcName)
{
    Func<object> func = _savedFuncs[funcName];
    object result = func();

    if (result is Task task)
    {
        Type resultType = result.GetType();

        // Some non-result task scenarios return Task<VoidTaskResult> instead
        // of a plain non-generic Task, so check for both.
        if (resultType != typeof(Task) &&
            resultType.GenericTypeArguments[0].FullName != "System.Threading.Tasks.VoidTaskResult")
        {
            await task;
            return ((dynamic)task).Result;
        }
    }

    return result;
}




Unfortunately, because in some cases the compiler uses Task<VoidTaskResult> instead of the non-generic Task type, it's not sufficient to just check for Task. In addition, because VoidTaskResult is not a public type, the code has to check for the type name as a string value instead of typeof(Task<VoidTaskResult>). So, it's a little awkward. But it will address the scenarios where the thing being returned is the Task itself, not the result of the task.



Of course, the GetAwaiter() approach doesn't have this issue. So if this was actually of concern, that would be one reason to choose the GetAwaiter() approach instead of the is Task approach.


标签： c#delegatesgeneric-programming


解决方案









我不完全清楚你的意图是什么，因为代码不清楚。您正在寻找GetAwaiter()返回类型的方法，但当然还有其他类型Task具有此方法。此外，您的代码将错过通过扩展方法等待的内容。



如果您要假设该函数返回一个任务对象（代码当前所做的），那么您应该只检查它而不是GetAwaiter()方法。相反，您应该只GetAwaiter()动态调用该方法，以便容纳该方法的任何内容。



就个人而言，如果不经常调用此代码，我会使用dynamic, try to call GetAwaiter()，如果失败则捕获异常（因为该方法不存在），然后直接调用委托。如果 perf 很重要，您可以记住 type-to-awaiter 状态，以便在您点击一次后可以跳过异常。请注意，使用dynamic，您将适应大多数等待的场景（它仍然找不到 extension-method GetAwaiter()）。



这是一个例子：



private static readonly HashSet<MethodInfo> _notAwaitable = new HashSet<MethodInfo>();

public static async Task<object> GetFuncResult(string funcName)
{
    Func<object> func = _savedFuncs[funcName];
    dynamic result = func();

    if (!_notAwaitable.Contains(func.Method))
    {
        try
        {
            return await result;
        }
        catch (RuntimeBinderException) { } // not awaitable

        _notAwaitable.Add(func.Method);
    }

    return result;
}




这应该做你想做的，也应该是高性能的。运行时支持已经缓存了可等待场景的dynamic分辨率，并且通过将不可等待的MethodInfo实例存储在哈希集中，代码避免了RuntimeBinderException任何给定的委托目标方法不止一次遭受的痛苦。



一旦代码“热身”（即以它在后续传递中的方式调用），它不应该成为瓶颈。



请注意，上面的实现假设您没有使用多播委托。鉴于上下文，这似乎是一个合理的假设，因为没有内置语言支持可等待的多播委托（或者更确切地说，它会起作用，但运行时中没有任何东西可以解决等待等待的歧义）。但是，如果您确实需要，您当然可以扩展上述内容以支持多播委托。



如果您不关心支持所有可等待的场景，而只关心Task基于 - 的场景，您可以将上面的内容简化如下：



public static async Task<object> GetFuncResult(string funcName)
{
    Func<object> func = _savedFuncs[funcName];
    object result = func();

    if (result is Task task)
    {
        await task;
        return ((dynamic)task).Result;
    }

    return result;
}




在这里，类型检查用于Task代替散列集。同样，dynamic运行时支持将缓存Result与此方法一起使用的每种类型的任务的访问器，因此一旦预热，将与任何其他面向动态的解决方案一样执行。



最后，请注意，如果您有 a Func<Task>，则上述内容将不起作用，因为它假定所有Task对象都有有效的结果。有人可能会争辩说，考虑到歧义，最好不要一开始就用类似的东西填充字典。但假设这种情况值得关注，可以修改上述内容以解决这种可能性：



public static async Task<object> GetFuncResult(string funcName)
{
    Func<object> func = _savedFuncs[funcName];
    object result = func();

    if (result is Task task)
    {
        Type resultType = result.GetType();

        // Some non-result task scenarios return Task<VoidTaskResult> instead
        // of a plain non-generic Task, so check for both.
        if (resultType != typeof(Task) &&
            resultType.GenericTypeArguments[0].FullName != "System.Threading.Tasks.VoidTaskResult")
        {
            await task;
            return ((dynamic)task).Result;
        }
    }

    return result;
}




不幸的是，因为在某些情况下编译器使用非泛型类型Task<VoidTaskResult>而不是非泛型Task类型，仅检查Task. 此外，由于VoidTaskResult不是公共类型，代码必须检查类型名称作为string值而不是typeof(Task<VoidTaskResult>). 所以，有点尴尬。但它将解决返回的东西是它Task本身而不是任务结果的场景。



当然，该GetAwaiter()方法不存在这个问题。因此，如果这确实令人担忧，那将是选择该GetAwaiter()方法而不是该is Task方法的原因之一。










推荐阅读