Hi,
When GetType is called on a TransparentProxy, the CLR attempts to get the
real type of the object being proxied by calling
RemotingServices.GetType(TransparentProxy), loading assemblies as necessary.
In a normal remoting scenario where the implementation assembly is
unavailable, this will fail and GetType will return
typeof(MarshalByRefObject). However, it the CLR can find the appropriate
assembly, it will load it and return the actual Type of the object being
proxied. I don't think this is desirable in all situations.
I've got a program that uses many AppDomains which communicate via remoting.
There is one main internal assembly with a number of MarshalByRefObjects
that implement public interfaces in a shared assembly. I do NOT want my
internal assembly loaded into the "client" AppDomains, but the assembly
needs to be available for my "server" AppDomain. The "client" AppDomains
should only have knowledge of the interface and should be completely
detached from the implementation of these objects. My main motivation is
just that its WRONG to have my implementation code loaded into my client
AppDomains, but there are some real problems like memory footprint (the
client AppDomains are supposed to be light weight).
When an object is made available via remoting, there must be some way to
specify that only one of its base types or interfaces is to be exposed.
After a lot of hunting through the SSCLI, I decided that the "right" way to
do this was to override MarshalByRefObject.CreateObjRef(Type requestedType)
to explicitly request an ObjRef for the type I wanted to expose (the
interface my MRBO implements). Does this seem right? I couldn't find any
documentation or other discussion about doing this, but this feels right to
me based on all the code to deal with the "requestedType" parameter (which
seems to always be null, meaning use the real type, in practice).
Doing this causes the Remoting.TypeInfo held in the ObjRef to only contain
information about my interface, not my concrete type. This works perfectly
almost all of the time, but in certain situations causes the JIT-compiler to
generate an InvalidCastException when storing the proxy in a variable of the
interface type. I won't go into too much detail here because I suspect that
overriding CreateObjRef to supply an interface type might be the wrong thing
to do anyway. If this should actually work properly, then I can provide
some sample code that explores the JIT bug in more detail. Using an
abstract base class instead of an interface works fine, but doesn't seem
right because it is just an interface I want to expose, and I may want my
actual implementation to inherit functionality from some other class.
Does anyone know what the right way to achieve this is? Can anyone provide
me with some information on how CreateObjRef is supposed to be overridden
and what the requirements are for ObjRefs TypeInfo object? I've read a
number of books on remoting (Ingo Rammer's Advanced .NET remoting, and the
MS Press .Net remoting book), but haven't found this level of details
anywhere.
Thanks,
Rick
