[System.Security.SecurityCritical] // auto-generated_required protected RealProxy(Type classToProxy, IntPtr stub, Object stubData) { if (!classToProxy.IsMarshalByRef && !classToProxy.IsInterface) { throw new ArgumentException( Environment.GetResourceString("Remoting_Proxy_ProxyTypeIsNotMBR")); } Contract.EndContractBlock(); if ((IntPtr)0 == stub) { Contract.Assert((IntPtr)0 != _defaultStub, "Default stub not set up"); // The default stub checks for match of contexts defined by us stub = _defaultStub; // Start with a value of -1 because 0 is reserved for the default context stubData = _defaultStubData; } _tp = null; if (stubData == null) { throw new ArgumentNullException("stubdata"); } _tp = RemotingServices.CreateTransparentProxy(this, classToProxy, stub, stubData); RemotingProxy rp = this as RemotingProxy; if (rp != null) { _flags |= RealProxyFlags.RemotingProxy; } }
[System.Security.SecurityCritical] // auto-generated public virtual RealProxy CreateProxy(ObjRef objRef, Type serverType, Object serverObject, Context serverContext) { RemotingProxy rp = new RemotingProxy(serverType); // If this is a serverID, set the native context field in the TP if (null != serverContext) { RealProxy.SetStubData(rp, serverContext.InternalContextID); } if (objRef != null && objRef.GetServerIdentity().IsAllocated) { rp.SetSrvInfo(objRef.GetServerIdentity(), objRef.GetDomainID()); } // Set the flag indicating that the fields of the proxy // have been initialized rp.Initialized = true; // Sanity check Type t = serverType; if (!t.IsContextful && !t.IsMarshalByRef && (null != serverContext)) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_MBR_ProxyAttribute")); } return rp; }
internal static IConstructionReturnMessage Activate(RemotingProxy remProxy, IConstructionCallMessage ctorMsg) { IConstructionReturnMessage message = null; if (((ConstructorCallMessage) ctorMsg).ActivateInContext) { message = ctorMsg.Activator.Activate(ctorMsg); if (message.Exception != null) { throw message.Exception; } return message; } GetPropertiesFromAttributes(ctorMsg, ctorMsg.CallSiteActivationAttributes); GetPropertiesFromAttributes(ctorMsg, ((ConstructorCallMessage) ctorMsg).GetWOMAttributes()); GetPropertiesFromAttributes(ctorMsg, ((ConstructorCallMessage) ctorMsg).GetTypeAttributes()); IMethodReturnMessage message2 = (IMethodReturnMessage) Thread.CurrentContext.GetClientContextChain().SyncProcessMessage(ctorMsg); message = message2 as IConstructionReturnMessage; if (message2 == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_Failed")); } if (message2.Exception != null) { throw message2.Exception; } return message; }
// Default implementation of CreateProxy creates an instance of our // remoting proxy /// <include file='doc\ProxyAttribute.uex' path='docs/doc[@for="ProxyAttribute.CreateProxy"]/*' /> public virtual RealProxy CreateProxy(ObjRef objRef, Type serverType, Object serverObject, Context serverContext) { RemotingProxy rp = new RemotingProxy(serverType); // If this is a serverID, set the native context field in the TP if (null != serverContext) { RealProxy.SetStubData(rp, serverContext.InternalContextID); } // Set the flag indicating that the fields of the proxy // have been initialized rp.Initialized = true; // Sanity check Type t = serverType; if (!t.IsContextful && !t.IsMarshalByRef && (null != serverContext)) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_MBR_ProxyAttribute")); } return(rp); }
public virtual MarshalByRefObject CreateInstance(Type serverType) { #if !DISABLE_REMOTING RemotingProxy proxy = new RemotingProxy(serverType, ChannelServices.CrossContextUrl, null); #else RemotingProxy proxy = new RemotingProxy(serverType, "", null); #endif return((MarshalByRefObject)proxy.GetTransparentProxy()); }
public virtual MarshalByRefObject CreateInstance (Type serverType) { #if MOONLIGHT throw new NotImplementedException (); #else RemotingProxy proxy = new RemotingProxy (serverType, ChannelServices.CrossContextUrl, null); return (MarshalByRefObject) proxy.GetTransparentProxy(); #endif }
public virtual MarshalByRefObject CreateInstance(Type serverType) { #if MOONLIGHT throw new NotImplementedException(); #else RemotingProxy proxy = new RemotingProxy(serverType, ChannelServices.CrossContextUrl, null); return((MarshalByRefObject)proxy.GetTransparentProxy()); #endif }
private static void Invoke(object NotUsed, ref MessageData msgData) { Message reqMcmMsg = new Message(); reqMcmMsg.InitFields(msgData); Delegate thisPtr = reqMcmMsg.GetThisPtr() as Delegate; if (thisPtr == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Default")); } RemotingProxy realProxy = (RemotingProxy)RemotingServices.GetRealProxy(thisPtr.Target); if (realProxy != null) { realProxy.InternalInvoke(reqMcmMsg, true, reqMcmMsg.GetCallType()); } else { int callType = reqMcmMsg.GetCallType(); switch (callType) { case 1: case 9: { reqMcmMsg.Properties[Message.CallContextKey] = CallContext.GetLogicalCallContext().Clone(); AsyncResult retVal = new AsyncResult(reqMcmMsg); AgileAsyncWorkerItem state = new AgileAsyncWorkerItem(reqMcmMsg, ((callType & 8) != 0) ? null : retVal, thisPtr.Target); ThreadPool.QueueUserWorkItem(new WaitCallback(AgileAsyncWorkerItem.ThreadPoolCallBack), state); if ((callType & 8) != 0) { retVal.SyncProcessMessage(null); } reqMcmMsg.PropagateOutParameters(null, retVal); break; } case 2: RealProxy.EndInvokeHelper(reqMcmMsg, false); return; case 10: break; default: return; } } }
// Token: 0x06005742 RID: 22338 RVA: 0x00133030 File Offset: 0x00131230 private static void Invoke(object NotUsed, ref MessageData msgData) { Message message = new Message(); message.InitFields(msgData); object thisPtr = message.GetThisPtr(); Delegate @delegate; if ((@delegate = (thisPtr as Delegate)) == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Default")); } RemotingProxy remotingProxy = (RemotingProxy)RemotingServices.GetRealProxy(@delegate.Target); if (remotingProxy != null) { remotingProxy.InternalInvoke(message, true, message.GetCallType()); return; } int callType = message.GetCallType(); if (callType <= 2) { if (callType != 1) { if (callType != 2) { return; } RealProxy.EndInvokeHelper(message, false); return; } } else if (callType != 9) { return; } message.Properties[Message.CallContextKey] = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.Clone(); AsyncResult asyncResult = new AsyncResult(message); AgileAsyncWorkerItem state = new AgileAsyncWorkerItem(message, ((callType & 8) != 0) ? null : asyncResult, @delegate.Target); ThreadPool.QueueUserWorkItem(new WaitCallback(AgileAsyncWorkerItem.ThreadPoolCallBack), state); if ((callType & 8) != 0) { asyncResult.SyncProcessMessage(null); } message.PropagateOutParameters(null, asyncResult); }
public static IMessage Activate (RemotingProxy proxy, ConstructionCall ctorCall) { IMessage response; ctorCall.SourceProxy = proxy; if (Thread.CurrentContext.HasExitSinks && !ctorCall.IsContextOk) response = Thread.CurrentContext.GetClientContextSinkChain ().SyncProcessMessage (ctorCall); else response = RemoteActivate (ctorCall); if (response is IConstructionReturnMessage && ((IConstructionReturnMessage)response).Exception == null && proxy.ObjectIdentity == null) { Identity identity = RemotingServices.GetMessageTargetIdentity (ctorCall); proxy.AttachIdentity (identity); } return response; }
public virtual RealProxy CreateProxy(ObjRef objRef, Type serverType, object serverObject, Context serverContext) { RemotingProxy rp = new RemotingProxy(serverType); if (serverContext != null) { RealProxy.SetStubData(rp, serverContext.InternalContextID); } if ((objRef != null) && objRef.GetServerIdentity().IsAllocated) { rp.SetSrvInfo(objRef.GetServerIdentity(), objRef.GetDomainID()); } rp.Initialized = true; Type type = serverType; if ((!type.IsContextful && !type.IsMarshalByRef) && (serverContext != null)) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_MBR_ProxyAttribute")); } return rp; }
public virtual RealProxy CreateProxy(ObjRef objRef, Type serverType, object serverObject, Context serverContext) { RemotingProxy remotingProxy = new RemotingProxy(serverType); if (serverContext != null) { RealProxy.SetStubData(remotingProxy, serverContext.InternalContextID); } if (objRef != null && objRef.GetServerIdentity().IsAllocated) { remotingProxy.SetSrvInfo(objRef.GetServerIdentity(), objRef.GetDomainID()); } remotingProxy.Initialized = true; if (!serverType.IsContextful && !serverType.IsMarshalByRef && serverContext != null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_MBR_ProxyAttribute")); } return(remotingProxy); }
protected RealProxy(Type classToProxy, IntPtr stub, object stubData) { if (!classToProxy.IsMarshalByRef && !classToProxy.IsInterface) { throw new ArgumentException(Environment.GetResourceString("Remoting_Proxy_ProxyTypeIsNotMBR")); } if ((IntPtr)0 == stub) { stub = RealProxy._defaultStub; stubData = RealProxy._defaultStubData; } this._tp = null; if (stubData == null) { throw new ArgumentNullException("stubdata"); } this._tp = RemotingServices.CreateTransparentProxy(this, classToProxy, stub, stubData); RemotingProxy remotingProxy = this as RemotingProxy; if (remotingProxy != null) { this._flags |= RealProxyFlags.RemotingProxy; } }
[System.Security.SecurityCritical] // auto-generated internal static MarshalByRefObject CreateInstance(RuntimeType serverType) { // Use our activation implementation MarshalByRefObject retObj = null; ConstructorCallMessage ctorCallMsg = null; bool bCtxOK = IsCurrentContextOK(serverType, null, ref ctorCallMsg); if (bCtxOK && !serverType.IsContextful) { // Marshal by ref case Message.DebugOut("Allocating blank marshal-by-ref object"); // We create an uninitialized instance of the actual type and // let the regular jit-activation execute the constructor on it. retObj = RemotingServices.AllocateUninitializedObject(serverType); } else { // (context not OK) || (serverType is Contextful) // We always return a proxy and the jit-activation's attempt // to execute the constructor gets intercepted by the TP stub // and routed to RemotingServices.Activate() below. // if context *is* OK // this is a contextBound type being activated for which // we always create a proxy (proxies-everywhere!) // if context *is not* OK // this could be a MarshalByRef or ContextBound type // being activated outside this appDomain // OR // this could be a ContextBound type being activated cross-ctx RemotingProxy rp; // See if the object-type is configured for Connect (with a URL) retObj = (MarshalByRefObject)ConnectIfNecessary(ctorCallMsg); if (retObj == null) { // not configured for connect, take the usual route of // creating a proxy Message.DebugOut("Creating remoting proxy for " + serverType.FullName + " in context " + Thread.CurrentContext); rp = new RemotingProxy(serverType); Message.DebugOut("Created remoting proxy\n"); retObj = (MarshalByRefObject)rp.GetTransparentProxy(); } else { Message.DebugOut("NewObj did a Connect!"); rp = (RemotingProxy)RemotingServices.GetRealProxy(retObj); } // Store the constructor call message in the proxy rp.ConstructorMessage = ctorCallMsg; if (!bCtxOK) { // Chain in the context level activator now ContextLevelActivator activator = new ContextLevelActivator(); activator.NextActivator = ctorCallMsg.Activator; ctorCallMsg.Activator = activator; } else { // Set the flag to indicate that the activation // will not be leaving the client context .. in this case // the default construction level activator is enough // to complete the activation process. ctorCallMsg.ActivateInContext = true; } } return retObj; }
[System.Security.SecurityCritical] // auto-generated internal static Object CheckIfConnected( RemotingProxy proxy, IConstructionCallMessage ctorMsg) { // If we performed a connect, we must have put the URL as // the connectKey in the message. String objURL = (String) ctorMsg.Properties[ConnectKey]; Object tp = null; if (objURL != null) { // We did perform a connect during IsContextOK // Just get the TP from RP and return it. tp = (Object)proxy.GetTransparentProxy(); } // We return null if we do not recognize this proxy! return tp; }
internal static ClientIdentity GetOrCreateClientIdentity(ObjRef objRef, Type proxyType, out object clientProxy) { // This method looks for an identity for the given url. // If an identity is not found, it creates the identity and // assigns it a proxy to the remote object. // Creates the client sink chain for the given url or channelData. // It will also get the object uri from the url. object channelData = objRef.ChannelInfo != null ? objRef.ChannelInfo.ChannelData : null; string objectUri; IMessageSink sink = GetClientChannelSinkChain (objRef.URI, channelData, out objectUri); if (objectUri == null) objectUri = objRef.URI; lock (uri_hash) { clientProxy = null; string uri = GetNormalizedUri (objRef.URI); ClientIdentity identity = uri_hash [uri] as ClientIdentity; if (identity != null) { // Object already registered clientProxy = identity.ClientProxy; if (clientProxy != null) return identity; // The proxy has just been GCed, so its identity cannot // be reused. Just dispose it. DisposeIdentity (identity); } // Creates an identity and a proxy for the remote object identity = new ClientIdentity (objectUri, objRef); identity.ChannelSink = sink; // Registers the identity uri_hash [uri] = identity; if (proxyType != null) { RemotingProxy proxy = new RemotingProxy (proxyType, identity); CrossAppDomainSink cds = sink as CrossAppDomainSink; if (cds != null) proxy.SetTargetDomain (cds.TargetDomainId); clientProxy = proxy.GetTransparentProxy(); identity.ClientProxy = (MarshalByRefObject) clientProxy; } return identity; } }
internal static object CreateClientProxyForContextBound (Type type, object[] activationAttributes) { if (type.IsContextful) { // Look for a ProxyAttribute ProxyAttribute att = (ProxyAttribute) Attribute.GetCustomAttribute (type, typeof(ProxyAttribute), true); if (att != null) return att.CreateInstance (type); } RemotingProxy proxy = new RemotingProxy (type, ChannelServices.CrossContextUrl, activationAttributes); return proxy.GetTransparentProxy(); }
internal static object CreateClientProxy (Type objectType, string url, object[] activationAttributes) { string activationUrl = url; if (!activationUrl.EndsWith ("/")) activationUrl += "/"; activationUrl += "RemoteActivationService.rem"; string objectUri; GetClientChannelSinkChain (activationUrl, null, out objectUri); RemotingProxy proxy = new RemotingProxy (objectType, activationUrl, activationAttributes); return proxy.GetTransparentProxy(); }
public IConstructionReturnMessage InitializeServerObject(IConstructionCallMessage ctorMsg) { IConstructionReturnMessage retMsg = null; if (_serverObject == null) { Type svrType = GetProxiedType(); if ((ctorMsg != null) && (ctorMsg.ActivationType != svrType)) { throw new RemotingException( String.Format( Environment.GetResourceString("Remoting_Proxy_BadTypeForActivation"), svrType.FullName, ctorMsg.ActivationType)); } // Create a blank object _serverObject = RemotingServices.AllocateUninitializedObject(svrType); // If the stub is the default stub, then set the server context // to be the current context. SetContextForDefaultStub(); // OK... we are all set to run the constructor call on the uninitialized object MarshalByRefObject proxy = (MarshalByRefObject)GetTransparentProxy(); IMethodReturnMessage msg = null; Exception e = null; if (null != ctorMsg) { msg = RemotingServices.ExecuteMessage(proxy, ctorMsg); e = msg.Exception; } else { try { RemotingServices.CallDefaultCtor(proxy); } catch (Exception excep) { e = excep; } } // Construct a return message if (null == e) { Object[] outArgs = (msg == null ? null : msg.OutArgs); int outLength = (null == outArgs ? 0 : outArgs.Length); LogicalCallContext callCtx = (msg == null ? null : msg.LogicalCallContext); retMsg = new ConstructorReturnMessage(proxy, outArgs, outLength, callCtx, ctorMsg); // setup identity SetupIdentity(); RemotingProxy rp = this as RemotingProxy; if (rp != null) { rp.Initialized = true; } } else { // Exception occurred retMsg = new ConstructorReturnMessage(e, ctorMsg); } } return(retMsg); }
/// <summary>Creates either an uninitialized <see cref="T:System.MarshalByRefObject" /> or a transparent proxy, depending on whether the specified type can exist in the current context.</summary> /// <returns>An uninitialized <see cref="T:System.MarshalByRefObject" /> or a transparent proxy.</returns> /// <param name="serverType">The object type to create an instance of. </param> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true" /> /// <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="MemberAccess" /> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="ControlEvidence, Infrastructure" /> /// </PermissionSet> public virtual MarshalByRefObject CreateInstance(Type serverType) { RemotingProxy remotingProxy = new RemotingProxy(serverType, ChannelServices.CrossContextUrl, null); return((MarshalByRefObject)remotingProxy.GetTransparentProxy()); }
private void PrivateInvoke(ref MessageData msgData, int type) { IMessage message1 = (IMessage)null; CallType callType = (CallType)type; IMessage message2 = (IMessage)null; int msgFlags = -1; RemotingProxy remotingProxy = (RemotingProxy)null; if (CallType.MethodCall == callType) { Message message3 = new Message(); MessageData msgData1 = msgData; message3.InitFields(msgData1); message1 = (IMessage)message3; msgFlags = message3.GetCallType(); } else if (CallType.ConstructorCall == callType) { msgFlags = 0; remotingProxy = this as RemotingProxy; bool flag = false; ConstructorCallMessage constructorCallMessage1; if (!this.IsRemotingProxy()) { constructorCallMessage1 = new ConstructorCallMessage((object[])null, (object[])null, (object[])null, (RuntimeType)this.GetProxiedType()); } else { constructorCallMessage1 = remotingProxy.ConstructorMessage; Identity identityObject = remotingProxy.IdentityObject; if (identityObject != null) { flag = identityObject.IsWellKnown(); } } if (constructorCallMessage1 == null | flag) { ConstructorCallMessage constructorCallMessage2 = new ConstructorCallMessage((object[])null, (object[])null, (object[])null, (RuntimeType)this.GetProxiedType()); constructorCallMessage2.SetFrame(msgData); message1 = (IMessage)constructorCallMessage2; if (flag) { remotingProxy.ConstructorMessage = (ConstructorCallMessage)null; if (constructorCallMessage2.ArgCount != 0) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_WellKnownCTOR")); } } message2 = (IMessage) new ConstructorReturnMessage((MarshalByRefObject)this.GetTransparentProxy(), (object[])null, 0, (LogicalCallContext)null, (IConstructionCallMessage)constructorCallMessage2); } else { constructorCallMessage1.SetFrame(msgData); message1 = (IMessage)constructorCallMessage1; } } ChannelServices.IncrementRemoteCalls(); if (!this.IsRemotingProxy() && (msgFlags & 2) == 2) { message2 = RealProxy.EndInvokeHelper(message1 as Message, true); } if (message2 == null) { Thread currentThread = Thread.CurrentThread; LogicalCallContext logicalCallContext = currentThread.GetMutableExecutionContext().LogicalCallContext; this.SetCallContextInMessage(message1, msgFlags, logicalCallContext); logicalCallContext.PropagateOutgoingHeadersToMessage(message1); message2 = this.Invoke(message1); this.ReturnCallContextToThread(currentThread, message2, msgFlags, logicalCallContext); Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.PropagateIncomingHeadersToCallContext(message2); } if (!this.IsRemotingProxy() && (msgFlags & 1) == 1) { Message m = message1 as Message; AsyncResult asyncResult = new AsyncResult(m); IMessage msg = message2; asyncResult.SyncProcessMessage(msg); // ISSUE: variable of the null type __Null local1 = null; int outArgsCount = 0; // ISSUE: variable of the null type __Null local2 = null; Message message3 = m; message2 = (IMessage) new ReturnMessage((object)asyncResult, (object[])local1, outArgsCount, (LogicalCallContext)local2, (IMethodCallMessage)message3); } RealProxy.HandleReturnMessage(message1, message2); if (CallType.ConstructorCall != callType) { return; } IConstructionReturnMessage constructionReturnMessage = message2 as IConstructionReturnMessage; if (constructionReturnMessage == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation")); } ConstructorReturnMessage constructorReturnMessage = constructionReturnMessage as ConstructorReturnMessage; MarshalByRefObject marshalByRefObject; if (constructorReturnMessage != null) { marshalByRefObject = (MarshalByRefObject)constructorReturnMessage.GetObject(); if (marshalByRefObject == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullReturnValue")); } } else { marshalByRefObject = (MarshalByRefObject)RemotingServices.InternalUnmarshal((ObjRef)constructionReturnMessage.ReturnValue, this.GetTransparentProxy(), true); if (marshalByRefObject == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal")); } } if (marshalByRefObject != (MarshalByRefObject)this.GetTransparentProxy()) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_InconsistentState")); } if (!this.IsRemotingProxy()) { return; } remotingProxy.ConstructorMessage = (ConstructorCallMessage)null; }
internal static MarshalByRefObject CreateInstance(RuntimeType serverType) { MarshalByRefObject transparentProxy = null; ConstructorCallMessage ctorCallMsg = null; RemotingProxy realProxy; bool flag = IsCurrentContextOK(serverType, null, ref ctorCallMsg); if (flag && !serverType.IsContextful) { return RemotingServices.AllocateUninitializedObject(serverType); } transparentProxy = (MarshalByRefObject) ConnectIfNecessary(ctorCallMsg); if (transparentProxy == null) { realProxy = new RemotingProxy(serverType); transparentProxy = (MarshalByRefObject) realProxy.GetTransparentProxy(); } else { realProxy = (RemotingProxy) RemotingServices.GetRealProxy(transparentProxy); } realProxy.ConstructorMessage = ctorCallMsg; if (!flag) { ContextLevelActivator activator = new ContextLevelActivator { NextActivator = ctorCallMsg.Activator }; ctorCallMsg.Activator = activator; return transparentProxy; } ctorCallMsg.ActivateInContext = true; return transparentProxy; }
// Invoke for case where call is in the same context as the server object // (This special static method is used for AsyncDelegate-s ... this is called // directly from the EE) private static void Invoke(Object NotUsed, ref MessageData msgData) { Message m = new Message(); m.InitFields(msgData); Object thisPtr = m.GetThisPtr(); Delegate d; if ((d = thisPtr as Delegate) != null) { RemotingProxy rp = (RemotingProxy) RemotingServices.GetRealProxy(d.Target); if (rp != null) { rp.InternalInvoke(m, true, m.GetCallType()); } else { int callType = m.GetCallType(); AsyncResult ar; switch (callType) { case Message.BeginAsync: case Message.BeginAsync | Message.OneWay: // pick up call context from the thread m.Properties[Message.CallContextKey] = CallContext.GetLogicalCallContext().Clone(); ar = new AsyncResult(m); AgileAsyncWorkerItem workItem = new AgileAsyncWorkerItem( m, ((callType & Message.OneWay) != 0) ? null : ar, d.Target); ThreadPool.QueueUserWorkItem( new WaitCallback( AgileAsyncWorkerItem.ThreadPoolCallBack), workItem); if ((callType & Message.OneWay) != 0) { ar.SyncProcessMessage(null); } m.PropagateOutParameters(null, ar); break; case (Message.EndAsync | Message.OneWay): return; case Message.EndAsync: // This will also merge back the call context // onto the thread that called EndAsync RealProxy.EndInvokeHelper(m, false); break; default: BCLDebug.Assert( false, "Should never be here. Sync delegate code for agile object ended up in remoting"); break; } } } else { // Static invoke called with incorrect this pointer ... throw new RemotingException( Environment.GetResourceString( "Remoting_Default")); } }
private void PrivateInvoke(ref MessageData msgData, int type) { IMessage reqMsg = null; CallType type2 = (CallType)type; IMessage retMsg = null; int msgFlags = -1; RemotingProxy proxy = null; if (CallType.MethodCall == type2) { Message message3 = new Message(); message3.InitFields(msgData); reqMsg = message3; msgFlags = message3.GetCallType(); } else if (CallType.ConstructorCall == type2) { msgFlags = 0; proxy = this as RemotingProxy; ConstructorCallMessage ccm = null; bool flag = false; if (!this.IsRemotingProxy()) { ccm = new ConstructorCallMessage(null, null, null, (RuntimeType)this.GetProxiedType()); } else { ccm = proxy.ConstructorMessage; Identity identityObject = proxy.IdentityObject; if (identityObject != null) { flag = identityObject.IsWellKnown(); } } if ((ccm == null) || flag) { ccm = new ConstructorCallMessage(null, null, null, (RuntimeType)this.GetProxiedType()); ccm.SetFrame(msgData); reqMsg = ccm; if (flag) { proxy.ConstructorMessage = null; if (ccm.ArgCount != 0) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_WellKnownCTOR")); } } retMsg = new ConstructorReturnMessage((MarshalByRefObject)this.GetTransparentProxy(), null, 0, null, ccm); } else { ccm.SetFrame(msgData); reqMsg = ccm; } } ChannelServices.IncrementRemoteCalls(); if (!this.IsRemotingProxy() && ((msgFlags & 2) == 2)) { Message message5 = reqMsg as Message; retMsg = EndInvokeHelper(message5, true); } if (retMsg == null) { LogicalCallContext cctx = null; Thread currentThread = Thread.CurrentThread; cctx = currentThread.GetLogicalCallContext(); this.SetCallContextInMessage(reqMsg, msgFlags, cctx); cctx.PropagateOutgoingHeadersToMessage(reqMsg); retMsg = this.Invoke(reqMsg); this.ReturnCallContextToThread(currentThread, retMsg, msgFlags, cctx); CallContext.GetLogicalCallContext().PropagateIncomingHeadersToCallContext(retMsg); } if (!this.IsRemotingProxy() && ((msgFlags & 1) == 1)) { Message m = reqMsg as Message; AsyncResult ret = new AsyncResult(m); ret.SyncProcessMessage(retMsg); retMsg = new ReturnMessage(ret, null, 0, null, m); } HandleReturnMessage(reqMsg, retMsg); if (CallType.ConstructorCall == type2) { MarshalByRefObject obj2 = null; IConstructionReturnMessage message7 = retMsg as IConstructionReturnMessage; if (message7 == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation")); } ConstructorReturnMessage message8 = message7 as ConstructorReturnMessage; if (message8 != null) { obj2 = (MarshalByRefObject)message8.GetObject(); if (obj2 == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullReturnValue")); } } else { obj2 = (MarshalByRefObject)RemotingServices.InternalUnmarshal((ObjRef)message7.ReturnValue, this.GetTransparentProxy(), true); if (obj2 == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal")); } } if (obj2 != ((MarshalByRefObject)this.GetTransparentProxy())) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_InconsistentState")); } if (this.IsRemotingProxy()) { proxy.ConstructorMessage = null; } } }
private void PrivateInvoke(ref MessageData msgData, int type) { IMessage message = null; IMessage message2 = null; int num = -1; RemotingProxy remotingProxy = null; if (1 == type) { Message message3 = new Message(); message3.InitFields(msgData); message = message3; num = message3.GetCallType(); } else if (2 == type) { num = 0; remotingProxy = (this as RemotingProxy); bool flag = false; ConstructorCallMessage constructorCallMessage; if (!this.IsRemotingProxy()) { constructorCallMessage = new ConstructorCallMessage(null, null, null, (RuntimeType)this.GetProxiedType()); } else { constructorCallMessage = remotingProxy.ConstructorMessage; Identity identityObject = remotingProxy.IdentityObject; if (identityObject != null) { flag = identityObject.IsWellKnown(); } } if (constructorCallMessage == null || flag) { constructorCallMessage = new ConstructorCallMessage(null, null, null, (RuntimeType)this.GetProxiedType()); constructorCallMessage.SetFrame(msgData); message = constructorCallMessage; if (flag) { remotingProxy.ConstructorMessage = null; if (constructorCallMessage.ArgCount != 0) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_WellKnownCTOR")); } } message2 = new ConstructorReturnMessage((MarshalByRefObject)this.GetTransparentProxy(), null, 0, null, constructorCallMessage); } else { constructorCallMessage.SetFrame(msgData); message = constructorCallMessage; } } ChannelServices.IncrementRemoteCalls(); if (!this.IsRemotingProxy() && (num & 2) == 2) { Message reqMsg = message as Message; message2 = RealProxy.EndInvokeHelper(reqMsg, true); } if (message2 == null) { Thread currentThread = Thread.CurrentThread; LogicalCallContext logicalCallContext = currentThread.GetMutableExecutionContext().LogicalCallContext; this.SetCallContextInMessage(message, num, logicalCallContext); logicalCallContext.PropagateOutgoingHeadersToMessage(message); message2 = this.Invoke(message); this.ReturnCallContextToThread(currentThread, message2, num, logicalCallContext); Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.PropagateIncomingHeadersToCallContext(message2); } if (!this.IsRemotingProxy() && (num & 1) == 1) { Message message4 = message as Message; AsyncResult asyncResult = new AsyncResult(message4); asyncResult.SyncProcessMessage(message2); message2 = new ReturnMessage(asyncResult, null, 0, null, message4); } RealProxy.HandleReturnMessage(message, message2); if (2 == type) { IConstructionReturnMessage constructionReturnMessage = message2 as IConstructionReturnMessage; if (constructionReturnMessage == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation")); } ConstructorReturnMessage constructorReturnMessage = constructionReturnMessage as ConstructorReturnMessage; MarshalByRefObject marshalByRefObject; if (constructorReturnMessage != null) { marshalByRefObject = (MarshalByRefObject)constructorReturnMessage.GetObject(); if (marshalByRefObject == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullReturnValue")); } } else { marshalByRefObject = (MarshalByRefObject)RemotingServices.InternalUnmarshal((ObjRef)constructionReturnMessage.ReturnValue, this.GetTransparentProxy(), true); if (marshalByRefObject == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal")); } } if (marshalByRefObject != (MarshalByRefObject)this.GetTransparentProxy()) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_InconsistentState")); } if (this.IsRemotingProxy()) { remotingProxy.ConstructorMessage = null; } } }
[System.Security.SecurityCritical] // auto-generated internal static IConstructionReturnMessage Activate( RemotingProxy remProxy, IConstructionCallMessage ctorMsg) { IConstructionReturnMessage ctorRetMsg = null; if (((ConstructorCallMessage)ctorMsg).ActivateInContext) { // The current context was approved for activation Contract.Assert( ctorMsg.Activator.Level == ActivatorLevel.Construction, "activator level must ActivatorLevel.Construction!"); // This has to be a ContextBound type (proxies-everywhere) Contract.Assert(ctorMsg.ActivationType.IsContextful, "Inconsistent state during activation"); // Ask the activator in the message to take over ctorRetMsg = ctorMsg.Activator.Activate(ctorMsg); if (ctorRetMsg.Exception != null) { throw ctorRetMsg.Exception; } } else { // Client context was not approved for activation ... Contract.Assert( ctorMsg.Activator.Level >= ActivatorLevel.Context, "activator level must be at least x-context!"); // Check with ActivationServices if we did a "Connect" with // a remote server during IsContextOK Contract.Assert( ActivationServices.CheckIfConnected(remProxy, ctorMsg) == null, "We shouldn't come through this path on a Connect."); // Client context was not approved for activation ... // This is the more elaborate (real) activation case i.e. // we have to go at least out of the client context to // finish the work. // Prepare for the handoff to Activation Service // Ask various attributes to contribute properties // The attributes may chain in other activators into // the activation chain (to hijack/participate in // the activation process). ActivationServices.GetPropertiesFromAttributes( (IConstructionCallMessage)ctorMsg, ctorMsg.CallSiteActivationAttributes); ActivationServices.GetPropertiesFromAttributes( ctorMsg, ((ConstructorCallMessage)ctorMsg).GetWOMAttributes()); ActivationServices.GetPropertiesFromAttributes( (IConstructionCallMessage)ctorMsg, ((ConstructorCallMessage)ctorMsg).GetTypeAttributes()); // Fetch the client context chain IMessageSink cliCtxChain = Thread.CurrentContext.GetClientContextChain(); // Ask the client context chain to take over from here. IMethodReturnMessage retMsg = (IMethodReturnMessage) cliCtxChain.SyncProcessMessage(ctorMsg); // The return message may not be of type // IConstructionReturnMessage if an exception happens // in the sink chains. ctorRetMsg = retMsg as IConstructionReturnMessage; if (null == retMsg) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_Failed")); } else if (retMsg.Exception != null) { throw retMsg.Exception; } } // Note: PropagateOutParameters is now handled by RealProxy // CallContext from retMsg should be already set by RealProxy Contract.Assert( null != ctorRetMsg, "Activate returning null ConstructorReturnMessage"); return ctorRetMsg; }
internal static object CheckIfConnected(RemotingProxy proxy, IConstructionCallMessage ctorMsg) { string str = (string) ctorMsg.Properties["Connect"]; object transparentProxy = null; if (str != null) { transparentProxy = proxy.GetTransparentProxy(); } return transparentProxy; }
internal virtual IMessage InternalInvoke(IMethodCallMessage reqMcmMsg, bool useDispatchMessage, int callType) { Message message1 = reqMcmMsg as Message; if (message1 == null && callType != 0) { throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_InvalidCallType")); } IMessage message2 = (IMessage)null; Thread currentThread = Thread.CurrentThread; LogicalCallContext logicalCallContext = currentThread.GetMutableExecutionContext().LogicalCallContext; Identity identityObject = this.IdentityObject; ServerIdentity serverIdentity = identityObject as ServerIdentity; if (serverIdentity != null && identityObject.IsFullyDisconnected()) { throw new ArgumentException(Environment.GetResourceString("Remoting_ServerObjectNotFound", (object)reqMcmMsg.Uri)); } MethodBase methodBase = reqMcmMsg.MethodBase; if ((MethodBase)RemotingProxy._getTypeMethod == methodBase) { return((IMessage) new ReturnMessage((object)this.GetProxiedType(), (object[])null, 0, logicalCallContext, reqMcmMsg)); } if ((MethodBase)RemotingProxy._getHashCodeMethod == methodBase) { return((IMessage) new ReturnMessage((object)identityObject.GetHashCode(), (object[])null, 0, logicalCallContext, reqMcmMsg)); } if (identityObject.ChannelSink == null) { IMessageSink chnlSink = (IMessageSink)null; IMessageSink envoySink = (IMessageSink)null; if (!identityObject.ObjectRef.IsObjRefLite()) { RemotingServices.CreateEnvoyAndChannelSinks((MarshalByRefObject)null, identityObject.ObjectRef, out chnlSink, out envoySink); } else { RemotingServices.CreateEnvoyAndChannelSinks(identityObject.ObjURI, (object)null, out chnlSink, out envoySink); } RemotingServices.SetEnvoyAndChannelSinks(identityObject, chnlSink, envoySink); if (identityObject.ChannelSink == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_NoChannelSink")); } } IInternalMessage internalMessage = (IInternalMessage)reqMcmMsg; internalMessage.IdentityObject = identityObject; if (serverIdentity != null) { internalMessage.ServerIdentityObject = serverIdentity; } else { internalMessage.SetURI(identityObject.URI); } switch (callType) { case 0: bool bSkippingContextChain = false; Context currentContextInternal = currentThread.GetCurrentContextInternal(); IMessageSink ms = identityObject.EnvoyChain; if (currentContextInternal.IsDefaultContext && ms is EnvoyTerminatorSink) { bSkippingContextChain = true; ms = identityObject.ChannelSink; } message2 = RemotingProxy.CallProcessMessage(ms, (IMessage)reqMcmMsg, identityObject.ProxySideDynamicSinks, currentThread, currentContextInternal, bSkippingContextChain); break; case 1: case 9: LogicalCallContext callContext1 = (LogicalCallContext)logicalCallContext.Clone(); internalMessage.SetCallContext(callContext1); AsyncResult asyncResult = new AsyncResult(message1); this.InternalInvokeAsync((IMessageSink)asyncResult, message1, useDispatchMessage, callType); message2 = (IMessage) new ReturnMessage((object)asyncResult, (object[])null, 0, (LogicalCallContext)null, (IMethodCallMessage)message1); break; case 2: message2 = RealProxy.EndInvokeHelper(message1, true); break; case 8: LogicalCallContext callContext2 = (LogicalCallContext)logicalCallContext.Clone(); internalMessage.SetCallContext(callContext2); this.InternalInvokeAsync((IMessageSink)null, message1, useDispatchMessage, callType); message2 = (IMessage) new ReturnMessage((object)null, (object[])null, 0, (LogicalCallContext)null, reqMcmMsg); break; case 10: message2 = (IMessage) new ReturnMessage((object)null, (object[])null, 0, (LogicalCallContext)null, reqMcmMsg); break; } return(message2); }
public virtual MarshalByRefObject CreateInstance (Type serverType) { RemotingProxy proxy = new RemotingProxy (serverType, ChannelServices.CrossContextUrl, null); return (MarshalByRefObject) proxy.GetTransparentProxy(); }
[System.Security.SecurityCritical] // auto-generated private void PrivateInvoke(ref MessageData msgData, int type) { IMessage reqMsg = null; CallType callType = (CallType)type; IMessage retMsg = null; int msgFlags = -1; // Used only for Construction case RemotingProxy rp = null; // Create a message object based on the type of call if (CallType.MethodCall == callType) { Message msg = new Message(); msg.InitFields(msgData); reqMsg = msg; msgFlags = msg.GetCallType(); } else if (CallType.ConstructorCall == (CallType)callType) { // We use msgFlags to handle CallContext around // the virtual call to Invoke() msgFlags = Message.Sync; rp = this as RemotingProxy; ConstructorCallMessage ctorMsg = null; bool bIsWellKnown = false; if (!IsRemotingProxy()) { // Create a new constructor call message // < ctorMsg = new ConstructorCallMessage(null, null, null, (RuntimeType)GetProxiedType()); } else { // Extract the constructor message set in the first step of activation. ctorMsg = rp.ConstructorMessage; // If the proxy is a wellknown client proxy, we don't // need to run the c'tor. Identity id = rp.IdentityObject; if (id != null) { bIsWellKnown = id.IsWellKnown(); } } if ((null == ctorMsg) || bIsWellKnown) { // This is also used to short-circuit the activation path // when we have a well known proxy that has already been // initialized (there's a race condition if we don't do this). // // This is a special case, where we have a remoting proxy // but the constructormessage hasn't been setup. // so let us just bail out.. // this is currently used by ServicedComponent's for cross appdomain // pooling: <EMAIL>Microsoft</EMAIL> // ctorMsg = new ConstructorCallMessage(null, null, null, (RuntimeType)GetProxiedType()); // Set the constructor frame info in the CCM ctorMsg.SetFrame(msgData); reqMsg = ctorMsg; // If this was the default ctor, check that default .ctor was called. if (bIsWellKnown) { Contract.Assert(rp != null, "RemotingProxy expected here!"); // Clear any cached ctorMsg on the RemotingProxy rp.ConstructorMessage = null; // We did execute a Connect. Throw if the client // code is also trying to use a non-default constructor at // the same time. if (ctorMsg.ArgCount != 0) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_WellKnownCTOR")); } } // Create a constructor return message retMsg = new ConstructorReturnMessage((MarshalByRefObject)GetTransparentProxy(), null, 0, null, ctorMsg); } else { // Set the constructor frame info in the CCM ctorMsg.SetFrame(msgData); reqMsg = ctorMsg; } } else { Contract.Assert(false, "Unknown call type"); } // Make sure that outgoing remote calls are counted. ChannelServices.IncrementRemoteCalls(); // For non-remoting proxies, EndAsync should not call Invoke() // because the proxy cannot support Async and the call has already // finished executing in BeginAsync if (!IsRemotingProxy() && ((msgFlags & Message.EndAsync) == Message.EndAsync)) { Message msg = reqMsg as Message; retMsg = EndInvokeHelper(msg, true); Contract.Assert(null != retMsg, "null != retMsg"); } // Invoke Contract.Assert(null != reqMsg, "null != reqMsg"); if (null == retMsg) { // NOTE: there are cases where we setup a return message // and we don't want the activation call to go through // refer to the note above for ServicedComponents and Cross Appdomain // pooling LogicalCallContext cctx = null; Thread currentThread = Thread.CurrentThread; // Pick up or clone the call context from the thread // and install it in the reqMsg as appropriate cctx = currentThread.GetMutableExecutionContext().LogicalCallContext; SetCallContextInMessage(reqMsg, msgFlags, cctx); // Add the outgoing "Header"'s to the message. cctx.PropagateOutgoingHeadersToMessage(reqMsg); retMsg = Invoke(reqMsg); // Get the call context returned and set it on the thread ReturnCallContextToThread(currentThread, retMsg, msgFlags, cctx); // Pull response "Header"'s out of the message Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.PropagateIncomingHeadersToCallContext(retMsg); } if (!IsRemotingProxy() && ((msgFlags & Message.BeginAsync) == Message.BeginAsync)) { // This was a begin-async on a non-Remoting Proxy. For V-1 they // cannot support Async and end up doing a Sync call. We need // to fill up here to make the call look like async to // the caller. // Create the async result to return Message msg = reqMsg as Message; AsyncResult ar = new AsyncResult(msg); // Tell the async result that the call has actually completed // so it can hold on to the return message. ar.SyncProcessMessage(retMsg); // create a returnMessage to propagate just the asyncResult back // to the caller's stack. retMsg = new ReturnMessage(ar, null, 0, null /*cctx*/, msg); } // Propagate out parameters HandleReturnMessage(reqMsg, retMsg); // For constructor calls do some extra bookkeeping if (CallType.ConstructorCall == callType) { // NOTE: It is the responsiblity of the callee to propagate // the out parameters // Everything went well, we are ready to return // a proxy to the caller // Extract the return value MarshalByRefObject retObj = null; IConstructionReturnMessage ctorRetMsg = retMsg as IConstructionReturnMessage; if (null == ctorRetMsg) { throw new RemotingException( Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation")); } ConstructorReturnMessage crm = ctorRetMsg as ConstructorReturnMessage; if (null != crm) { // If return message is of type ConstructorReturnMessage // this is an in-appDomain activation. So no unmarshaling // needed. retObj = (MarshalByRefObject)crm.GetObject(); if (retObj == null) { throw new RemotingException( Environment.GetResourceString("Remoting_Activation_NullReturnValue")); } } else { // Fetch the objRef out of the returned message and unmarshal it retObj = (MarshalByRefObject)RemotingServices.InternalUnmarshal( (ObjRef)ctorRetMsg.ReturnValue, GetTransparentProxy(), true /*fRefine*/); if (retObj == null) { throw new RemotingException( Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal")); } } if (retObj != (MarshalByRefObject)GetTransparentProxy()) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_InconsistentState")); } if (IsRemotingProxy()) { // Clear any cached ctorMsg on the RemotingProxy rp.ConstructorMessage = null; } } }
// Private method invoked by the transparent proxy private void PrivateInvoke(ref MessageData msgData, int type) { IMessage reqMsg = null; CallType callType = (CallType)type; IMessage retMsg = null; int msgFlags = -1; // Create a message object based on the type of call if (CallType.MethodCall == callType) { Message msg = new Message(); msg.InitFields(msgData); reqMsg = msg; msgFlags = msg.GetCallType(); } else if (CallType.ConstructorCall == (CallType)callType) { // We use msgFlags to handle CallContext around // the virtual call to Invoke() msgFlags = Message.Sync; ConstructorCallMessage ctorMsg = null; RemotingProxy rp = this as RemotingProxy; if (null == rp) { // Create a new constructor call message ctorMsg = new ConstructorCallMessage(null, null, null, GetProxiedType()); } else { // Extract the constructor message set in the first step of activation. ctorMsg = rp.ConstructorMessage; } // If the proxy is a wellknown client proxy, we don't need to run the c'tor. bool bIsWellKnown = false; if (rp != null) { Identity id = rp.IdentityObject; if (id != null) { bIsWellKnown = id.IsWellKnown(); } } if ((null == ctorMsg) || bIsWellKnown) { // This is also used to short-circuit the activation path // when we have a well known proxy that has already been // initialized (there's a race condition if we don't do this). // // This is a special case, where we have a remoting proxy // but the constructormessage hasn't been setup. // so let us just bail out.. // this is currently used by ServicedComponent's for cross appdomain // pooling: // /* * ProxyAttribute pa = null; * BCLDebug.Assert(((pa = ActivationServices.GetProxyAttribute(GetProxiedType()) is Object) || true); * BCLDebug.Assert(pa != null && pa.GetType() != typeof(ProxyAttribute)); */ ctorMsg = new ConstructorCallMessage(null, null, null, GetProxiedType()); // Set the constructor frame info in the CCM ctorMsg.SetFrame(msgData); reqMsg = ctorMsg; // If this was the default ctor, check that default .ctor was called. if (bIsWellKnown) { // We did execute a Connect. Throw if the client // code is also trying to use a non-default constructor at // the same time. if (ctorMsg.ArgCount != 0) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_WellKnownCTOR")); } } // Create a constructor return message retMsg = new ConstructorReturnMessage((MarshalByRefObject)GetTransparentProxy(), null, 0, null, ctorMsg); } else { // Set the constructor frame info in the CCM ctorMsg.SetFrame(msgData); reqMsg = ctorMsg; } } else { BCLDebug.Assert(false, "Unknown call type"); } // Make sure that outgoing remote calls are counted. ChannelServices.IncrementRemoteCalls(); // Invoke BCLDebug.Assert(null != reqMsg, "null != reqMsg"); if (null == retMsg) { // NOTE: there are cases where we setup a return message // and we don't want the activation call to go through // refer to the note above for ServicedComponents and Cross Appdomain // pooling LogicalCallContext cctx = null; Thread currentThread = Thread.CurrentThread; // Pick up or clone the call context from the thread // and install it in the reqMsg as appropriate cctx = currentThread.GetLogicalCallContext(); SetCallContextInMessage(reqMsg, msgFlags, cctx); // Add the outgoing "Header"'s to the message. cctx.PropagateOutgoingHeadersToMessage(reqMsg); retMsg = Invoke(reqMsg); // Get the call context returned and set it on the thread ReturnCallContextToThread(currentThread, retMsg, msgFlags); // Pull response "Header"'s out of the message CallContext.GetLogicalCallContext().PropagateIncomingHeadersToCallContext(retMsg); } // Propagate out parameters HandleReturnMessage(reqMsg, retMsg); // For constructor calls do some extra bookkeeping if (CallType.ConstructorCall == callType) { // NOTE: It is the responsiblity of the callee to propagate // the out parameters // Everything went well, we are ready to return // a proxy to the caller // Extract the return value MarshalByRefObject retObj = null; IConstructionReturnMessage ctorRetMsg = retMsg as IConstructionReturnMessage; if (null == ctorRetMsg) { throw new RemotingException( Environment.GetResourceString("Remoting_Proxy_BadReturnTypeForActivation")); } ConstructorReturnMessage crm = ctorRetMsg as ConstructorReturnMessage; if (null != crm) { retObj = (MarshalByRefObject)crm.GetObject(); if (retObj == null) { throw new RemotingException( Environment.GetResourceString("Remoting_Activation_NullReturnValue")); } } else { // Fetch the objRef out of the returned message and unmarshal it retObj = (MarshalByRefObject)RemotingServices.InternalUnmarshal( (ObjRef)ctorRetMsg.ReturnValue, GetTransparentProxy(), true /*fRefine*/); if (retObj == null) { throw new RemotingException( Environment.GetResourceString("Remoting_Activation_NullFromInternalUnmarshal")); } } if (retObj != (MarshalByRefObject)GetTransparentProxy()) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_InconsistentState")); } } }