Hi Robert,

This behavior is by design: the aggregation hides the identity of
your object. The object passed back is not the object that was
created by the runtime.

When the aggregator does "blind aggregation", you may be able to
cast the object to one of its interfaces.

I think the aggregation could be controlled with
System.Runtime.InteropServices.ExtensibleClassFactory.
You have to apply the code on all classes that get eaten by
the COM object.

(Untested)

[ComVisile(true)]
public class A {
  const int CLASS_E_NOAGGREGATION =  unchecked((int)0x80040110);

  static A {
    ExtensibleClassFactory.RegisterObjectCreationCallback(
      new ObjectCreationDelegate(Create));

  }

  static IntPtr Create(IntPtr aggregator) {
    if (aggregator != IntPtr.Zero) {
      // we don't want to be agg*ted
      throw new COMException("", CLASS_E_NOAGGREGATION)
    }
    else {
       // create a new instance and return its CCW
       return Marshal.GetIUnknownForObject(new A());
    }
  }

  public A() {
  }
}

bye
Rob

AH HA!  I finally got it!

The trick was to use an interface with a property (as you had suggested) but
instead of returning the object or late-binding invoke to get the object, the
trick is to wrap the object in an ObjectHandle() class and unwrap it on the
receiving side.

Alternatively, I was able to return any MarshalByRef object that then in
turn exposed a property which returned the actual object I was trying to get
in the first place.