（如何）我可以对代理对象进行弱引用，就像对代理对象的弱引用一样？

Question

As part of some IPC framework, the server-side code implements a mapping of integers to objects (such that IPC messages can use integers to reference objects).

The mapping doesn't store references straight to the objects though but to IGUIObject implementations, an interface to be implemented by proxy objects which wrap the actual objects. Ie there's an interface like

interface IGUIObject
{
    Rectangle Bounds { get; }
}

and then possible implementations like

class WindowsFormsControl : IGUIObject
{
    private Control m_control;

    public WindowsFormsControl( Control control )
    {
        m_control = control;
    }

    public virtual Rectangle Bounds
    {
        get
        {
            return m_control.Bounds;
        }
    }
}

The mapping class, a singleton, looks like this:

class ObjectDict
{
    private static readonly ObjectDict s_instance = new ObjectDict();
    private Dictionary<int, IGUIObject> m_idToObjectDict;
    private Dictionary<IGUIObject, int> m_objectToIdDict;
    private int m_lastObjectId;

    public static ObjectDict Instance
    {
        get
        {
            return s_instance;
        }
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    public IGUIObject objectForId( int id )
    {
        IGUIObject go;
        if ( m_idToObjectDict.TryGetValue( id, out go ) ) {
            return go;
        }
        return null;
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    public int idForObject( IGUIObject go )
    {
        // Lookup ID for objects, register object and return new ID if needed
    }

    // ...
}

The problem with this is that the ObjectDict class should not keep the application objects from being garbage collected, ie it should hold weak references and in such cases ObjectDict.objectForId should throw an exception.

Alas,

• holding weak references on the IGUIObject implementations doesn't seem to help, because the ObjectDict class is the owner of the wrapper objects. There's no other place where they are stored. The wrapper objects only get removed from the dictionaries if the IPC system receives an explicit 'release object with ID 12345' message. The issue I need to solve though is that it may be that the proxied object is garbage collected and I want to allow, detect and handle it gracefully. The wrapper objects should live as long as the proxied objects (potentially longer), but no shorter.

• making WindowsFormsExtension hold a weak reference to the Control object and then making ObjectCache hold a weak reference to the IGUIObject implementation doesn't help either, because the proxy object (ie WindowsFormsControl ) doesn't mirror the "null-ness" of the contained object. Another complicating factor is that there are many (a couple dozen) implementations of the IGUIObject interface, but only a single ObjectDict class. So any solution which does not require me to do the tedious and error-prone job of adjusting all IGUIObject implementations to start using weak references would be much preferred.

Does anybody know how to adjust the code such that ObjectDict does not (indirectly) hold strong references on any objects wrapped by IGUIObject implementations?

Answer 1

Maybe you can add another layer of abstraction :)

class WeakGUIObject : IGUIObject
{
    WeakReference wr;

    public WindowsFormsControl( IGUIObject inner )
    {
        wr = new WR(inner);
    }

    public virtual Rectangle Bounds
    {
        get
        {
            var inner = wr.Target;
            if (inner == null) throw ObjectDisposedException();
            return inner.Bounds;
        }
    }
}

Now you can make the dictionary reference and hand out WeakGUIObject instances. This automatically makes all proxied objects weak.

Not sure this whole design is a good idea. Clients of ObjectDict might find that their objects disappear at random times and start throwing. But that seems to be what you are aiming at.