Question

I’ve recently moved back to C# from being in Objective-C land, and the async/await keywords in C# 5 look cool. But I’m still trying to get a handle on the proper syntax.

I want to declare a method that takes an asynchronous delegate as a parameter, but I am having trouble getting both the caller and the callee syntax correct. Can someone provide a code sample showing the method declaration, the call, and a call to the delegate?

I’m thinking the declaration would be something like the following. Note that this function isn’t asynchronous; i.e. its asynchronicity is independent of the delegate.

void DoSomethingWithCallback(async delegate foo(int)) 
{
    ...
    foo(42);
    ...
}

The call would be something like:

DoSomethingWithCallback(async (int x) => { this.SomeProperty = await SomeAsync(x); });

Of course none of this compiles and most of the samples I’ve seen assume that one has a field or property that’s the delegate, rather than the anonymous delegate I’d like to use.

Answer 1

A function that takes a delegate as a parameter must use a named delegate type; unlike in Objective-C you can’t declare an anonymous delegate type inline in the function definition. However, the generics Action<> and Func<> are provided so that you don’t have to declare a new type yourself. In the code below I’m assuming the delegate takes a single int as a parameter.

void DoSomethingWithCallback(Func<int,Task> callbackDelegate)
{
    Task t = callbackDelegate(42);
}

If this function doesn’t actually do anything with the Task object returned (as with the code shown above), you can instead use Action<int> as the delegate type. If you use Action, you can still declare the delegate async (below) but the implicit Task object returned is ignored.

The lambda syntax for calling the above function is straightforward and the syntax you used in the question is correct. Note that the parameter type doesn’t need to be specified here since it can be inferred:

DoSomethingWithCallback(async (intParam) => { this.myint = await Int2IntAsync(intParam); });

You can also pass a method or delegate variable, if you wish, instead of using the lambda syntax:

async Task MyInt2Int(int p) { ... }
Func<int,Task> myDelegate;
void OtherMethod()
{
    myDelegate = MyInt2Int;
    DoSomethingWithCallback(myDelegate); // this ...
    DoSomethingWithCallback(MyInt2Int);  // ... or this.
}