Ending asynchronous delegate invocation with partial type information

Question

When writing async method implementations using the BeginInvoke/EndInvoke pattern the code might look something like the following (and to save you guessing this is an async wrapper around a cache):

IAsyncResult BeginPut(string key, object value)
{
    Action<string, object> put = this.cache.Put;
    return put.BeginInvoke(key, value, null, null);
}

void EndPut(IAsyncResult asyncResult)
{
    var put = (Action<string, object>)((AsyncResult)asyncResult).AsyncDelegate;
    put.EndInvoke(asyncResult);
}

This works perfectly well because it's known what the type of delegate is, so it can be cast. However it starts to get messy when you have two Put methods, because although the method returns void you seemingly have to cast it to a strongly typed delegate to end the invocation, e.g.

IAsyncResult BeginPut(string key, object value)
{
    Action<string, object> put = this.cache.Put;
    return put.BeginInvoke(key, value, null, null);
}

IAsyncResult BeginPut(string region, string key, object value)
{
    Action<string, string, object> put = this.cache.Put;
    return put.BeginInvoke(region, key, value, null, null);
}

void EndPut(IAsyncResult asyncResult)
{
    var put = ((AsyncResult)asyncResult).AsyncDelegate;

    var put1 = put as Action<string, object>;
    if (put1 != null) 
    {
        put1.EndInvoke(asyncResult);
        return;
    }

    var put2 = put as Action<string, string, object>;
    if (put2 != null) 
    {
        put2.EndInvoke(asyncResult);
        return;
    }

    throw new ArgumentException("Invalid async result", "asyncResult");
}

I'm hoping there is a cleaner way to do this, because the only thing I care about the delegate is the return type (in this case void) and not the arguments that were supplied to it. But I've racked my brains and asked others in the office, and nobody can think of the answer.

I know one solution is to write a custom IAsyncResult, but that's such a difficult task with the potential threading issues around things like lazy instantiation of the WaitHandle that I'd rather have this slightly hacky looking code than go down that route.

Any ideas on how to end the invocation without a cascading set of is checks?

Answer 1

Why not avoid the problem by just going back to the more general overload:

IAsyncResult BeginPut(string key, object value) {
   return this.BeginPut(null, key, value);
}

IAsyncResult BeginPut(string region, string key, object value) {
   Action<string, string, object> put = this.Put;
   return put.BeginInvoke(region, key, value, null, null);
}

void EndPut(IAsyncResult asyncResult) {
   var put = (Action<string, string, object>)((AsyncResult)asyncResult).AsyncDelegate;
   put.EndInvoke(asyncResult);
}

Answer 2

Edit: Please see my other answer. It can be cleaner.

I don't think there is a way to make this cleaner. You essentially made this inevitable by using the same EndPut method to end more than one type of async call. You could just as well be following the normal pattern by passing EndPut and the put delegate as the last two parameters to BeginInvoke() (callback and asyncstate), and you would still have to test what type the delegate is in order call EndInvoke().

Casting them to Delegate doesn't help at all.

I like Mark Brackett's idea. I think it comes down to these options:

• Join them completely by having one overload call another. One delegate, one callback.
• Separate them completely by having two callbacks for calling EndInvoke().

Aside from those, the only thing is to make your code just a little cleaner and use a switch or lookup dictionary using asyncResult.AsyncState.GetType(), passing the put delegate as that state object.

Answer 3

I was wrong, there is a cleaner way.

You create Action( IAsyncResult ) delegates for the specific EndInvoke() method in the same context where you already know the specific type of the delegate, passing it as the AsyncState. I'm passing EndPut() as the callback for convenience.

IAsyncResult BeginPut( string key, object value ) {
    Action<string, object> put = this.Put;
    return put.BeginInvoke( key, value, EndPut,
        new Action<IAsyncResult>( put.EndInvoke ) );
}

IAsyncResult BeginPut( string region, string key, object value ) {
    Action<string, string, object> put = this.Put;
    return put.BeginInvoke( region, key, value, EndPut,
        new Action<IAsyncResult>( put.EndInvoke ) );
}

And then you finish it off.

void EndPut( IAsyncResult asyncResult ) {
    var del = asyncResult.AsyncState as Action<IAsyncResult>;
    del( asyncResult );
}