C# 异步委托-什么是正确的方法

好了，我就快到了，需要一点建议来克服这个困难！所以，我问这个问题的原因是因为我试图异步调用委托函数（使用wait…）

所以，这里我有一个类，它使用一个接受委托的库。库在触发时调用委托。看起来像这样

Example.Question.Base{
public static class Consumer{
    private delegate bool Redo();
    private static Redo callbackFunction;

    public static async Task<T> Go(){
        // Do some stuff ...

        // now I want to set up my delegate so this library 
        // I'm using can call back my delgate function when 
        // an event occurs that it manages
        callbackFunction = NonAsync;
        SomeLibrary someLibrary = new SomeLibary();
        await someLibrary.SomeMethod(callbackFunction);
    }

    public static bool NonAsync()
    {
        // Do some work ...
        return false;
    }
}

// so now the callbackFunction is called from 
// the libary when some event occurs.  So that 
// means the actual method "NonAsync()" is called!
} 

---

这个很好用。我需要的是能够从库异步调用委托

需要帮忙才能到达那里吗

所以我想要这样的东西

…从调用委托的库中

public ... SomeMethod(Delegate func){
        await func.DynamicInvoke();
    }

。。。从定义委托的库的使用者

Example.Question.Base{
    public static class Consumer{
        // ...

        public static async Task<T> Go(){
            // ...
            callbackFunction = await Async;
            // ...
        }

        public static async Task<bool> Async()
        {
            // Do some work ...
            return await Task.FromResult<bool>(false);
        }
    }
}

Example.Question.Base{
公共静态类消费者{
// ...
公共静态异步任务Go（）{
// ...
callbackFunction=等待异步；
// ...
}
公共静态异步任务async（）
{
//做一些工作。。。
返回等待任务。FromResult（false）；
}
}
}

但问题是我得到一个编译器错误，说“不能等待‘方法组’”

---

只需使用类似的东西，例如：

public static class Consumer
    {

        public static async Task<T> Go<T>()
        {
            var someLibrary = new SomeLibrary();
            return await someLibrary.SomeMethod(Async<T>);
        }

        public static async Task<T> Async<T>()
        {
            return await Task.FromResult(default(T));
        }
    }

public class SomeLibrary
    {
        public async Task<T> SomeMethod<T>(Func<Task<T>> func)
        {
            return await func.Invoke();
        }
    }

公共静态类使用者
{
公共静态异步任务Go（）
{
var someLibrary=new someLibrary（）；
return wait someLibrary.SomeMethod（异步）；
}
公共静态异步任务async（）
{
返回wait Task.FromResult（默认值（T））；
}
}
公共图书馆
{
公共异步任务方法（Func Func）
{
return wait func.Invoke（）；
}
}

“我需要的是能够从库中异步调用委托”-这到底是什么意思？异步委托是您调用的委托，它返回某种类型的

任务。不是调用是异步的，而是委托内的处理。请注意，
Async
返回一个
任务
而不是
bool
，因此它不适用于
callbackFunction
。我怀疑问题的核心不在于代码，而在于如何考虑异步。1。我试图使用wait/async模型调用委托。所以我需要类似于
callbackFunction=await Async我把代码示例放在上面。2.在上面的代码示例中，我还简单地展示了我能够通过wait/async完成对委托的调用，但我的问题很简单（请原谅，如果我的措辞有点不正确），我如何使用
wait
调用委托？
wait
并不是调用委托的一部分。如果您的代理返回任务，您将等待该任务。这就是为什么
await Async
不起作用的原因-您正在思考异步性的错误之处。您需要考虑“如何使我的委托返回任务？”（因此委托类型需要声明它返回任务，例如，
task
）然后您可以调用委托，并等待结果。同样，您需要准确理解“我希望它异步回叫”的含义。目前还不清楚你的意思，这可能是因为你不确定自己。（这是完全可以理解的——异步是复杂的。）我将首先尝试弄清楚在没有任何动态调用的情况下它会是什么样子，以及您希望效果是什么——您可以从那里继续。
public static class Consumer
    {

        public static async Task<T> Go<T>()
        {
            var someLibrary = new SomeLibrary();
            return await someLibrary.SomeMethod(Async<T>);
        }

        public static async Task<T> Async<T>()
        {
            return await Task.FromResult(default(T));
        }
    }

public class SomeLibrary
    {
        public async Task<T> SomeMethod<T>(Func<Task<T>> func)
        {
            return await func.Invoke();
        }
    }