Question

好的，所以，我几乎就在那里，只需要一点建议来克服这个驼峰！所以，我问这个questoin Async delegate - What is proper syntax?的原因是因为我试图异步调用委托函数（使用等待...）。

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

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!
}

库中回调此delgate的逻辑看起来像这样

Example.Question.Library{
public ...{
    public ... SomeMethod(Delegate func){
        func.DynamicInvoke();
    }
}
}

这很好用。我需要的是能够异步地从库中调用Delegate。

需要一些帮助才能到达那里

所以我想要一些看起来像这样的东西......

...来自调用委托的图书馆......

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

但问题是我收到编译错误，说“不能等待'方法组'”

Answer 1

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

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

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

1 个答案: