protected ServicedComponentMarshaler(SerializationInfo info, StreamingContext context) : base(info, context)
 {
     byte[] buffer = null;
     Type type = null;
     bool flag = false;
     ComponentServices.InitializeRemotingChannels();
     SerializationInfoEnumerator enumerator = info.GetEnumerator();
     while (enumerator.MoveNext())
     {
         if (enumerator.Name.Equals("servertype"))
         {
             type = (Type) enumerator.Value;
         }
         else
         {
             if (enumerator.Name.Equals("dcomInfo"))
             {
                 buffer = (byte[]) enumerator.Value;
                 continue;
             }
             if (enumerator.Name.Equals("fIsMarshalled"))
             {
                 int num = 0;
                 object obj2 = enumerator.Value;
                 if (obj2.GetType() == typeof(string))
                 {
                     num = ((IConvertible) obj2).ToInt32(null);
                 }
                 else
                 {
                     num = (int) obj2;
                 }
                 if (num == 0)
                 {
                     flag = true;
                 }
             }
         }
     }
     if (!flag)
     {
         this._marshalled = true;
     }
     this._um = new SCUnMarshaler(type, buffer);
     this._rt = type;
     if (base.IsFromThisProcess() && !ServicedComponentInfo.IsTypeEventSource(type))
     {
         this._rp = RemotingServices.GetRealProxy(base.GetRealObject(context));
     }
     else
     {
         if (ServicedComponentInfo.IsTypeEventSource(type))
         {
             this.TypeInfo = new SCMTypeName(type);
         }
         object realObject = base.GetRealObject(context);
         this._rp = RemotingServices.GetRealProxy(realObject);
     }
     this._um.Dispose();
 }

 internal RedirectionProxy(MarshalByRefObject proxy, Type serverType)
 {
     _proxy = proxy;
     _realProxy = RemotingServices.GetRealProxy(_proxy);
     _serverType = serverType;
     _objectMode = WellKnownObjectMode.Singleton;
 } // RedirectionProxy

 internal RealProxy GetRealProxy()
 {
     if ((this._rp == null) && !this._fUnMarshaled)
     {
         this._rp = this.UnmarshalRemoteReference();
     }
     return this._rp;
 }

 public static void SwitchWrappers(RealProxy oldcp, RealProxy newcp)
 {
     object transparentProxy = oldcp.GetTransparentProxy();
     object tp = newcp.GetTransparentProxy();
     RemotingServices.GetServerContextForProxy(transparentProxy);
     RemotingServices.GetServerContextForProxy(tp);
     Marshal.InternalSwitchCCW(transparentProxy, tp);
 }

        public RemotingInvocation(RealProxy proxy, IMethodCallMessage message)
        {
            this.message = message;
            this.proxy = proxy;

            arguments = message.Args;
            if (arguments == null)
                arguments = new object[0];
        }

        private IntPtr _stub;           // Unmanaged code that decides whether to short circuit calls or not
     
 		// This method should never be called.  Its sole purpose is to shut up the compiler
		//	because it warns about private fields that are never used.  Most of these fields
		//	are used in unmanaged code.
#if _DEBUG
		private int NeverCallThis()
		{
			BCLDebug.Assert(false,"NeverCallThis");
			_rp = null;
			_pMT = new IntPtr(RemotingServices.TrashMemory);
			_pInterfaceMT = new IntPtr(RemotingServices.TrashMemory);
            _stub = new IntPtr(RemotingServices.TrashMemory);
			RealProxy rp = _rp;
			return _pInterfaceMT.ToInt32();
		}

		private static void InvokeRealProxy(RealProxy realProxy, WcfInvocation wcfInvocation)
		{
			var message = new MethodCallMessage(wcfInvocation.Method, wcfInvocation.Arguments);
			var returnMessage = (IMethodReturnMessage)realProxy.Invoke(message);
			if (returnMessage.Exception != null)
			{
				throw returnMessage.Exception;
			}
			wcfInvocation.ReturnValue = returnMessage.ReturnValue;
		}

 public ObjectCall(
     RealProxy proxy,
     IMessage callMessage,
     Action<IConstructionCallMessage> validationOnInit = null,
     Action<IMethodCallMessage> validationOnAction = null)
 {
     this.proxy = proxy;
     this.callMessage = callMessage;
     this.validationOnInit = validationOnInit;
     this.validationOnAction = validationOnAction;
 }

        [System.Security.SecurityCritical]  // auto-generated_required
        public static void SwitchWrappers(RealProxy oldcp, RealProxy newcp)
        {
            Object oldtp = oldcp.GetTransparentProxy(); 
            Object newtp = newcp.GetTransparentProxy();
 
            IntPtr oldcontextId = RemotingServices.GetServerContextForProxy(oldtp); 
            IntPtr newcontextId = RemotingServices.GetServerContextForProxy(newtp);
 
            // switch the CCW from oldtp to new tp
            Marshal.InternalSwitchCCW(oldtp, newtp);
        }

		private static void InvokeRealProxy(RealProxy realProxy, WcfInvocation wcfInvocation)
		{
			var message = new MethodCallMessage(wcfInvocation.Method, wcfInvocation.Arguments);
			var returnMessage = (IMethodReturnMessage)realProxy.Invoke(message);
			if (returnMessage.Exception != null)
			{
				var exception = ExceptionHelper.PreserveStackTrace(returnMessage.Exception);
				throw exception;
			}
			wcfInvocation.ReturnValue = returnMessage.ReturnValue;
		}

 internal static extern Object CreateTransparentProxy( 
                                     RealProxy rp, 
                                     RuntimeType typeToProxy,
                                     IntPtr stub, 
                                     Object stubData);

 [System.Security.SecurityCritical]  // auto-generated
 internal static bool ProxyCheckCast(RealProxy rp, RuntimeType castType)
 {
     return CheckCast(rp, castType); 
 } // ProxyCheckCast

        [System.Security.SecurityCritical]  // auto-generated 
        private static bool CheckCast(RealProxy rp, RuntimeType castType)
        { 
            // NOTE: This is the point where JIT_CheckCastClass ultimately 
            // lands up in the managed world if the object being cast is
            // a transparent proxy. 
            // If we are here, it means that walking the current EEClass
            // up the chain inside the EE was unable to verify the cast.

            Message.DebugOut("Entered CheckCast for type " + castType); 
            bool fCastOK = false;
 
            BCLDebug.Assert(rp != null, "Shouldn't be called with null real proxy."); 

            // Always return true if cast is to System.Object 
            if (castType == typeof(Object))
                return true;

            // We do not allow casting to non-interface types that do not extend 
            // from System.MarshalByRefObject
            if (!castType.IsInterface && !castType.IsMarshalByRef) 
                return false; 

            // Note: this is a bit of a hack to allow deserialization of WellKnown 
            // object refs (in the well known cases, we always return TRUE for
            // interface casts but doing so messes us up in the case when
            // the object manager is trying to resolve object references since
            // it ends up thinking that the proxy we returned needs to be resolved 
            // further).
            if (castType != typeof(IObjectReference)) 
            { 
                IRemotingTypeInfo typeInfo = rp as IRemotingTypeInfo;
                if(null != typeInfo) 
                {
                    fCastOK = typeInfo.CanCastTo(castType, rp.GetTransparentProxy());
                }
                else 
                {
                    // The proxy does not implement IRemotingTypeInfo, so we should 
                    //   try to do casting based on the ObjRef type info. 
                    Identity id = rp.IdentityObject;
                    if (id != null) 
                    {
                        ObjRef objRef = id.ObjectRef;
                        if (objRef != null)
                        { 
                            typeInfo = objRef.TypeInfo;
                            if (typeInfo != null) 
                            { 
                                fCastOK = typeInfo.CanCastTo(castType, rp.GetTransparentProxy());
                            } 
                        }
                    }
                }
            } 

            Message.DebugOut("CheckCast returning " + fCastOK); 
            return fCastOK; 
        }

 public static extern Object GetStubData(RealProxy rp); 

 public static extern void SetStubData(RealProxy rp, Object stubData);

 internal RemotingIntermediary(RealProxy pxy) : base(pxy.GetProxiedType())
 {
     this._pxy = pxy;
     this._blind = new BlindMBRO((MarshalByRefObject) this.GetTransparentProxy());
 }

	// Set the stub data for a particular proxy.
	public static void SetStubData(RealProxy rp, Object stubData)
			{
				if(rp != null)
				{
					rp.stubData = stubData;
				}
			}

		public static void SetStubData (RealProxy rp, object stubData)
		{
			rp._stubData = stubData;
		}

		internal static bool ProxyCheckCast (RealProxy rp, RuntimeType castType)
		{
			// TODO: What should it do?
			return true;
		}

 internal MbrObject(RealProxy proxy, System.Type targetType)
 {
     this.proxy = proxy;
     this.targetType = targetType;
 }