EndInvokeHelper() статический приватный Метод

static private EndInvokeHelper ( Message reqMsg, bool bProxyCase ) : IMessage
reqMsg System.Runtime.Remoting.Messaging.Message
bProxyCase bool
Результат IMessage
Пример #1
0
        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;
                }
            }
        }
Пример #2
0
        // 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);
        }
Пример #3
0
        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);
        }
Пример #4
0
        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;
        }
Пример #5
0
        // 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"));
            }
        }
Пример #6
0
        } // Invoke

        // This is called for all remoted calls on a TP except Ctors
        // The method called may be Sync, Async or OneWay(special case of Async)
        // In the Async case we come here for both BeginInvoke & EndInvoke
        internal virtual IMessage InternalInvoke(
            IMethodCallMessage reqMcmMsg, bool useDispatchMessage, int callType)
        {
            Message reqMsg = reqMcmMsg as Message;

            if ((reqMsg == null) && (callType != Message.Sync))
            {
                // Only the synchronous call type is supported for messages that
                //   aren't of type Message.
                throw new RemotingException(
                          Environment.GetResourceString("Remoting_Proxy_InvalidCallType"));
            }

            IMessage retMsg        = null;
            Thread   currentThread = Thread.CurrentThread;

            // pick up call context from the thread
            LogicalCallContext cctx = currentThread.GetLogicalCallContext();

            Identity       idObj    = IdentityObject;
            ServerIdentity serverID = idObj as ServerIdentity;

            if ((null != serverID) && idObj.IsFullyDisconnected())
            {
                throw new ArgumentException(
                          String.Format(Environment.GetResourceString("Remoting_ServerObjectNotFound"), reqMcmMsg.Uri));
            }

            // Short-circuit calls to Object::GetType and Object::GetHashCode
            MethodBase mb = reqMcmMsg.MethodBase;

            if (_getTypeMethod == mb)
            {
                // Time to load the true type of the remote object....
                Type t = GetProxiedType();
                return(new ReturnMessage(t, null, 0, null /*cctx*/, reqMcmMsg));
            }

            if (_getHashCodeMethod == mb)
            {
                int hashCode = idObj.GetHashCode();
                return(new ReturnMessage(hashCode, null, 0, null /*cctx*/, reqMcmMsg));
            }

            // check for channel sink
            if (idObj.ChannelSink == null)
            {
                throw new RemotingException(
                          Environment.GetResourceString("Remoting_Proxy_NoChannelSink"));
            }

            // Set the identity in the message object
            IInternalMessage iim = (IInternalMessage)reqMcmMsg;

            iim.IdentityObject = idObj;

            if (null != serverID)
            {
                Message.DebugOut("Setting serveridentity on message \n");
                iim.ServerIdentityObject = serverID;
            }
            else
            {
                // We need to set the URI only for identities that
                // are not the server identities. The uri is used to
                // dispatch methods for objects outside the appdomain.
                // Inside the appdomain (xcontext case) we dispatch
                // by getting the server object from the server identity.
                iim.SetURI(idObj.URI);
            }

            Message.DebugOut("InternalInvoke. Dispatching based on class type\n");
            AsyncResult ar = null;

            switch (callType)
            {
            case Message.Sync:
                Message.DebugOut("RemotingProxy.Invoke Call: SyncProcessMsg\n");
                BCLDebug.Assert(!useDispatchMessage, "!useDispatchMessage");
                bool         bSkipContextChain = false;
                Context      currentContext    = currentThread.GetCurrentContextInternal();
                IMessageSink nextSink          = idObj.EnvoyChain;

                // if we are in the default context, there can be no
                // client context chain, so we can skip the intermediate
                // calls if there are no envoy sinks

                if (currentContext.IsDefaultContext)
                {
                    if (nextSink is EnvoyTerminatorSink)
                    {
                        bSkipContextChain = true;

                        // jump directly to the channel sink
                        nextSink = idObj.ChannelSink;
                    }
                }

                retMsg = CallProcessMessage(nextSink,
                                            reqMcmMsg,
                                            idObj.ProxySideDynamicSinks,
                                            currentThread,
                                            currentContext,
                                            bSkipContextChain);

                break;

            case Message.BeginAsync:
            case Message.BeginAsync | Message.OneWay:
                // For async calls we clone the call context from the thread
                // This is a limited clone (we dont deep copy the user data)
                cctx = (LogicalCallContext)cctx.Clone();
                iim.SetCallContext(cctx);

                ar = new AsyncResult(reqMsg);

                InternalInvokeAsync(ar, reqMsg, useDispatchMessage, callType);

                Message.DebugOut("Propagate out params for BeginAsync\n");
                retMsg = new ReturnMessage(ar, null, 0, null /*cctx*/, reqMsg);
                break;

            case Message.OneWay:
                // For async calls we clone the call context from the thread
                // This is a limited clone (we dont deep copy the user data)
                cctx = (LogicalCallContext)cctx.Clone();
                iim.SetCallContext(cctx);
                InternalInvokeAsync(null, reqMsg, useDispatchMessage, callType);
                retMsg = new ReturnMessage(null, null, 0, null /*cctx*/, reqMcmMsg);
                break;

            case (Message.EndAsync | Message.OneWay):
                retMsg = new ReturnMessage(null, null, 0, null /*cctx*/, reqMcmMsg);
                break;

            case Message.EndAsync:
                // For endAsync, we merge back the returned callContext
                // into the thread's callContext
                retMsg = RealProxy.EndInvokeHelper(reqMsg, true);
                break;
            }

            return(retMsg);
        }
Пример #7
0
        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;
                }
            }
        }
Пример #8
0
        internal virtual IMessage InternalInvoke(IMethodCallMessage reqMcmMsg, bool useDispatchMessage, int callType)
        {
            Message m = reqMcmMsg as Message;

            if ((m == null) && (callType != 0))
            {
                throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_InvalidCallType"));
            }
            IMessage           message2           = null;
            Thread             currentThread      = Thread.CurrentThread;
            LogicalCallContext logicalCallContext = currentThread.GetLogicalCallContext();
            Identity           identityObject     = this.IdentityObject;
            ServerIdentity     identity2          = identityObject as ServerIdentity;

            if ((identity2 != null) && identityObject.IsFullyDisconnected())
            {
                throw new ArgumentException(Environment.GetResourceString("Remoting_ServerObjectNotFound", new object[] { reqMcmMsg.Uri }));
            }
            MethodBase methodBase = reqMcmMsg.MethodBase;

            if (_getTypeMethod == methodBase)
            {
                return(new ReturnMessage(base.GetProxiedType(), null, 0, logicalCallContext, reqMcmMsg));
            }
            if (_getHashCodeMethod == methodBase)
            {
                return(new ReturnMessage(identityObject.GetHashCode(), null, 0, logicalCallContext, reqMcmMsg));
            }
            if (identityObject.ChannelSink == null)
            {
                IMessageSink chnlSink  = null;
                IMessageSink envoySink = null;
                if (!identityObject.ObjectRef.IsObjRefLite())
                {
                    RemotingServices.CreateEnvoyAndChannelSinks(null, identityObject.ObjectRef, out chnlSink, out envoySink);
                }
                else
                {
                    RemotingServices.CreateEnvoyAndChannelSinks(identityObject.ObjURI, null, out chnlSink, out envoySink);
                }
                RemotingServices.SetEnvoyAndChannelSinks(identityObject, chnlSink, envoySink);
                if (identityObject.ChannelSink == null)
                {
                    throw new RemotingException(Environment.GetResourceString("Remoting_Proxy_NoChannelSink"));
                }
            }
            IInternalMessage message3 = (IInternalMessage)reqMcmMsg;

            message3.IdentityObject = identityObject;
            if (identity2 != null)
            {
                message3.ServerIdentityObject = identity2;
            }
            else
            {
                message3.SetURI(identityObject.URI);
            }
            AsyncResult ar = null;

            switch (callType)
            {
            case 0:
            {
                bool         bSkippingContextChain  = false;
                Context      currentContextInternal = currentThread.GetCurrentContextInternal();
                IMessageSink envoyChain             = identityObject.EnvoyChain;
                if (currentContextInternal.IsDefaultContext && (envoyChain is EnvoyTerminatorSink))
                {
                    bSkippingContextChain = true;
                    envoyChain            = identityObject.ChannelSink;
                }
                return(CallProcessMessage(envoyChain, reqMcmMsg, identityObject.ProxySideDynamicSinks, currentThread, currentContextInternal, bSkippingContextChain));
            }

            case 1:
            case 9:
                logicalCallContext = (LogicalCallContext)logicalCallContext.Clone();
                message3.SetCallContext(logicalCallContext);
                ar = new AsyncResult(m);
                this.InternalInvokeAsync(ar, m, useDispatchMessage, callType);
                return(new ReturnMessage(ar, null, 0, null, m));

            case 2:
                return(RealProxy.EndInvokeHelper(m, true));

            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                return(message2);

            case 8:
                logicalCallContext = (LogicalCallContext)logicalCallContext.Clone();
                message3.SetCallContext(logicalCallContext);
                this.InternalInvokeAsync(null, m, useDispatchMessage, callType);
                return(new ReturnMessage(null, null, 0, null, reqMcmMsg));

            case 10:
                return(new ReturnMessage(null, null, 0, null, reqMcmMsg));
            }
            return(message2);
        }