+ IMethodCallMessage mm = request as IMethodCallMessage;
+
+ if (mm != null) {
+ if (mm.MethodBase == _cache_GetHashCodeMethod)
+ return new MethodResponse(ObjectIdentity.GetHashCode(), null, null, mm);
+
+ if (mm.MethodBase == _cache_GetTypeMethod)
+ return new MethodResponse(GetProxiedType(), null, null, mm);
+ }
+
+ IInternalMessage im = request as IInternalMessage;
+ if (im != null) {
+ if (im.Uri == null) im.Uri = _targetUri;
+ im.TargetIdentity = _objectIdentity;
+ }
+
+ _objectIdentity.NotifyClientDynamicSinks (true, request, true, false);
+
+ IMessage response;
+ IMessageSink sink;
+
+ // Needs to go through the client context sink?
+ if (Thread.CurrentContext.HasExitSinks && !_hasEnvoySink)
+ sink = Thread.CurrentContext.GetClientContextSinkChain ();
+ else
+ sink = _sink;
+
+ MonoMethodMessage mMsg = request as MonoMethodMessage;
+ if (mMsg == null || mMsg.CallType == CallType.Sync)
+ response = sink.SyncProcessMessage (request);
+ else
+ {
+ AsyncResult ares = mMsg.AsyncResult;
+ IMessageCtrl mctrl = sink.AsyncProcessMessage (request, ares);
+ if (ares != null) ares.SetMessageCtrl (mctrl);
+ response = new ReturnMessage (null, new object[0], 0, null, mMsg);
+ }
+
+ _objectIdentity.NotifyClientDynamicSinks (false, request, true, false);
+
+ return response;
+ }
+
+ internal void AttachIdentity (Identity identity)
+ {
+ _objectIdentity = identity;
+
+ if (identity is ClientActivatedIdentity) // It is a CBO
+ {
+ ClientActivatedIdentity cai = (ClientActivatedIdentity)identity;
+ _targetContext = cai.Context;
+ AttachServer (cai.GetServerObject ());
+ cai.SetClientProxy ((MarshalByRefObject) GetTransparentProxy());
+ }
+
+ if (identity is ClientIdentity)
+ {
+ ((ClientIdentity)identity).ClientProxy = (MarshalByRefObject) GetTransparentProxy();
+ _targetUri = ((ClientIdentity)identity).TargetUri;
+ }
+ else
+ _targetUri = identity.ObjectUri;
+
+ if (_objectIdentity.EnvoySink != null)
+ {
+ _sink = _objectIdentity.EnvoySink;
+ _hasEnvoySink = true;
+ }
+ else
+ _sink = _objectIdentity.ChannelSink;