Contracting

Abstract: Thoughts on implementing an Action-type delegate that holds only a weak reference to the target object.

Background

I recently started evaluating MVVM libraries for my client’s project. Though I often share parts of my own unpublished library with a client I had inherited this project and it already had it’s share of commonly-used MVVM types. What it lacked, and I added, was a quickie "message bus" implementation. Not the distributed, enterprise-class sort of message bus, but an intra-app messaging service that decouples senders from receivers. It’s the message bus that I really wanted to replace with a more robust, tested version that must surely already exist in one of the established MVVM libraries.

As luck would have it the first library I downloaded touted a messaging service but, as is too often the case, you get what you pay for. After perusing the code for a bit I could see that the messaging functionality wasn’t thread-safe, a feature I require. My app is a multi-threaded WPF app with both managed and native threads and takes pains to keep work off the UI thread in order to achieve smooth and somewhat real-time rendering of data. Wrapping the library’s messaging code for synchronization would be easy, but it doesn’t feel like fine enough granularity of locking for good performance.

Weak Action is Weak

Another driver in looking for an established library is that my quickie message bus implementation holds references to subscribed listeners. Not really a problem unless a listener fails to unsubscribe, in this case the listener will never be garbage collected. I consider that an undesirable situation. So I took a look at the above library’s implementation of a weak action; I quickly saw that this code used not a weak reference but a strong reference; it suffered the very problem it purported to fix. FYI, I did verify that the problem is known to the library’s author.

Now, at this time I haven’t finished evaluating libraries, and this was a bit of a rough start. Maybe I’ll just set aside some time to come up with a solution myself. Like… now.

An Elegant Solution (maybe…)

The problem I’d like to solve is that Action holds a reference to the target object of non-static delegates, preventing that target from being GC’d. The most elegant solution would allow me to simply replace my use of Action and Action<T> with an implementation that holds only a weak reference to the target. And here it is:

static Action CreateWeakAction(Action action)
{
    if (action == null)
        throw new ArgumentNullException("action");
  
    // If it's a static delegate there's no need to create a weak reference.
    if (action.Target == null)
        return action;
  
    Type type = action.GetType();
    WeakReference targetRef = new WeakReference(action.Target);
    MethodInfo method = action.Method;
  
    return () =>
        {
            // Don't reference 'action' in this lambda expression.
            object target = targetRef.Target;
            if (target == null)
            {
                // Target was GC'd; don't do anything. (Ick.)
            }
            else
            {
                Delegate.CreateDelegate(type, target, method).DynamicInvoke();
            }
        };
}

Using CreateWeakAction is pretty easy:

Action action = CreateWeakAction(() => receiver.DoSomething(42));
// Time passes...
action();

Now the target (‘receiver’ in the above example) is free to be collected, but I have a new Action delegate returned from CreateWeakAction that will not be collected unless I release my reference to it. More than that, I have no way of telling whether the delegate I’m holding no longer has a live reference to the target. I could conceivably change my Action to a Func<> that returns an indicator of whether the target was GC’d, but that would require me to actually call the delegate to determine its state. And I would lose the elegant drop-in replacement I was hoping for.

A More Measured Solution

Setting aside my personal desire for elegance solutions, the actual requirements I’m looking to satisfy in my message bus are twofold: 1) don’t hold a reference to the target listener and 2) don’t hold unnecessary objects in the heap. A weak action implementation that satisfies these needs might look something like this:

class WeakAction
{
    public WeakAction(Action action);
    public bool IsTargetAlive { get; }
    public WeakActionInvocationResult Invoke();
}

This would allow me to create an instance of my weak action, invoke it’s behavior when needed, and check whether the target is still alive so that I can cull stale instances from my message bus implementation. And, thanks to an uninterrupted morning at my local coffee joint I have what I wanted. You may note that I’ve made an abstraction for invoking instance delegates; this makes that code more easily reusable for generic implementations (e.g., WeakAction<T>).

internal class WeakAction
{
    private readonly InvocationAgent _instanceAction;
    private readonly Action _staticAction;
  
    public WeakAction(Action action)
    {
        if (action == null)
            throw new ArgumentNullException("action");
  
        if (action.Target != null)
        {
            _instanceAction = new InvocationAgent(action);
        }
        else
        {
            _staticAction = action;
        }
  
        Debug.Assert(_instanceAction == null || _staticAction == null);
        Debug.Assert(!(_instanceAction == null && _staticAction == null));
    }
  
    public bool IsTargetAlive { get { return IsStatic || _instanceAction.IsTargetAlive; } }
  
    private bool IsStatic { get { return _staticAction != null; } }
  
    public WeakActionInvocationResult Invoke()
    {
        if (_instanceAction != null)
            return _instanceAction.Invoke();
  
        _staticAction();
        return WeakActionInvocationResult.Invoked;
    }
}

Note that I’ve made an optimization for static delegates—there’s no need to incur the cost of dynamic invocation in that case because a static delegate has no target, therefore it won’t prevent anything from being GC’d.

Now imagine we have a messaging implementation that needs to track listeners with Action delegates but would rather not keep a reference to listeners forever if they happen not to unsubscribe. We can now create an instance of WeakAction and use it to invoke the listener’s Action when we wish; we can also query the WeakAction on occasion to determine whether it still has a live listener.

Finally here are the missing parts to make it work, the interesting bits. What makes this work is pulling apart the delegate into its component parts, holding the target part with a weak reference, and reassembling the parts into a delegate only when needed to invoke the original delegate. No reference to the original delegate is held.

internal enum WeakActionInvocationResult
{
    Invoked,
    Collected,
}
  
internal class InvocationAgent
{
    private readonly Type _type;
    private readonly WeakReference _targetRef;
    private readonly MethodInfo _method;
  
    public InvocationAgent(Delegate action)
    {
        Debug.Assert(action.Target != null, "Expected a non-static delegate");
  
        _type = action.GetType();
        _targetRef = new WeakReference(action.Target);
        _method = action.Method;
    }
  
    public bool IsTargetAlive { get { return _targetRef.IsAlive; } }
  
    public WeakActionInvocationResult Invoke(params object[] args)
    {
        object target = _targetRef.Target;
        if (target == null)
            return WeakActionInvocationResult.Collected;
  
        // Don't keep a reference to this delegate.
        Delegate.CreateDelegate(_type, target, _method).DynamicInvoke(args);
        return WeakActionInvocationResult.Invoked;
    }
}

I’ll leave it as an interesting challenge to the reader to implement WeakAction<T>. Here’s what it might look like:

class WeakAction<T>
{
    public WeakAction(Action<T> action);
    public bool IsTargetAlive { get; }
    public WeakActionInvocationResult Invoke(T t);
}

Grab a cup of coffee and have at it. Please note: I’ve tested only on the desktop CLR, not Silverlight or Phone, so caveat emptor.

pc

Just another WordPress site

Category Archives: Contracting

WeakAction, or delegates with a weak reference to their target

Background

Weak Action is Weak

An Elegant Solution (maybe…)

A More Measured Solution

Moving On…