コード例 #1
0
 public virtual void SetMessageCtrl(IMessageCtrl mc)
 {
     _mc = mc;
 }
コード例 #2
0
ファイル: AsyncResult.cs プロジェクト: KonajuGames/SharpLang
	public virtual void SetMessageCtrl (IMessageCtrl mc)
	{
		message_ctrl = mc;
	}
コード例 #3
0
	// Set the message control information for this result.
	public virtual void SetMessageCtrl(IMessageCtrl mc)
			{
				messageControl = mc;
			}
 public virtual new void SetMessageCtrl(IMessageCtrl mc)
 {
 }
コード例 #5
0
 public virtual void SetMessageCtrl(IMessageCtrl mc)
 {
     this._mc = mc;
 }
コード例 #6
0
 public virtual void SetMessageCtrl(IMessageCtrl mc)
 {
     message_ctrl = mc;
 }
コード例 #7
0
        public virtual IMessageCtrl AsyncProcessMessage(
            IMessage msg, IMessageSink replySink)
        {
            IMethodCallMessage mcMsg = (IMethodCallMessage)msg;

            IMessageCtrl       retCtrl    = null;
            IMessage           retMessage = null;
            LogicalCallContext oldCallCtx = null;
            bool isCallContextSet         = false;

            try{
                try
                {
                    LogicalCallContext callCtx = (LogicalCallContext)
                                                 mcMsg.Properties[Message.CallContextKey];

                    Object server = _server;

                    // validate the method base if necessary
                    VerifyIsOkToCallMethod(server, mcMsg);

                    // install call context onto the thread, holding onto
                    // the one that is currently on the thread

                    oldCallCtx       = CallContext.SetLogicalCallContext(callCtx);
                    isCallContextSet = true;
                    // retrieve incoming headers
                    callCtx.PropagateIncomingHeadersToCallContext(msg);

                    PreserveThreadPrincipalIfNecessary(callCtx, oldCallCtx);

                    // see if this is a server message that was dispatched asynchronously
                    ServerChannelSinkStack sinkStack =
                        msg.Properties["__SinkStack"] as ServerChannelSinkStack;
                    if (sinkStack != null)
                    {
                        sinkStack.ServerObject = server;
                    }

                    BCLDebug.Assert((server != null) == (!_bStatic),
                                    "Invalid state in stackbuilder sink?");

                    MethodBase mb      = GetMethodBase(mcMsg);
                    Object[]   outArgs = null;
                    Object     ret     = null;
                    RemotingMethodCachedData methodCache =
                        InternalRemotingServices.GetReflectionCachedData(mb);
                    Object[] args = Message.CoerceArgs(mcMsg, methodCache.Parameters);

                    ret = PrivateProcessMessage(mb.MethodHandle,
                                                args,
                                                server,
                                                0,
                                                false,
                                                out outArgs);
                    CopyNonByrefOutArgsFromOriginalArgs(methodCache, args, ref outArgs);

                    if (replySink != null)
                    {
                        // call context could be different then the one from before the call.
                        LogicalCallContext latestCallContext = CallContext.GetLogicalCallContext();

                        if (latestCallContext != null)
                        {
                            // Special case Principal since if might not be serializable before returning
                            // ReturnMessage
                            latestCallContext.RemovePrincipalIfNotSerializable();
                        }

                        retMessage = new ReturnMessage(
                            ret,
                            outArgs,
                            (outArgs == null ? 0 : outArgs.Length),
                            latestCallContext,
                            mcMsg);

                        // retrieve outgoing response headers
                        latestCallContext.PropagateOutgoingHeadersToMessage(retMessage);
                    }
                }
                catch (Exception e)
                {
                    if (replySink != null)
                    {
                        retMessage = new ReturnMessage(e, mcMsg);
                        ((ReturnMessage)retMessage).SetLogicalCallContext(
                            (LogicalCallContext)
                            mcMsg.Properties[Message.CallContextKey]);
                    }
                }
                finally
                {
                    // Call the reply sink without catching the exceptions
                    // in it. In v2.0 any exceptions in the callback for example
                    // would probably bring down the process
                    replySink.SyncProcessMessage(retMessage);
                }
            }
            finally {
                // restore the call context on the thread
                if (isCallContextSet)
                {
                    CallContext.SetLogicalCallContext(oldCallCtx);
                }
            }

            return(retCtrl);
        } // AsyncProcessMessage
コード例 #8
0
ファイル: AsyncResult.cs プロジェクト: PlumpMath/CIL2Java
 /// <summary>Sets an <see cref="T:System.Runtime.Remoting.Messaging.IMessageCtrl" /> for the current remote method call, which provides a way to control asynchronous messages after they have been dispatched.</summary><param name="mc">The <see cref="T:System.Runtime.Remoting.Messaging.IMessageCtrl" /> for the current remote method call. </param>
 public virtual void SetMessageCtrl(IMessageCtrl mc)
 {
     throw new NotImplementedException();
 }
コード例 #9
0
ファイル: RemotingProxy.cs プロジェクト: pmq20/mono_forked
        public override IMessage Invoke(IMessage request)
        {
            IMethodCallMessage mm = request as IMethodCallMessage;

            if (mm != null)
            {
                if (mm.MethodBase == _cache_GetHashCodeMethod)
                {
                    return(new MethodResponse(ObjectIdentity.GetHashCode(), null, null, mm));
                }

                if (mm.MethodBase == _cache_GetTypeMethod)
                {
                    return(new MethodResponse(GetProxiedType(), null, null, mm));
                }
            }

            IInternalMessage im = request as IInternalMessage;

            if (im != null)
            {
                if (im.Uri == null)
                {
                    im.Uri = _targetUri;
                }
                im.TargetIdentity = _objectIdentity;
            }

            _objectIdentity.NotifyClientDynamicSinks(true, request, true, false);

            IMessage     response;
            IMessageSink sink;

            // Needs to go through the client context sink?
            if (Thread.CurrentContext.HasExitSinks && !_hasEnvoySink)
            {
                sink = Thread.CurrentContext.GetClientContextSinkChain();
            }
            else
            {
                sink = _sink;
            }

            MonoMethodMessage mMsg = request as MonoMethodMessage;

            if (mMsg == null || mMsg.CallType == CallType.Sync)
            {
                response = sink.SyncProcessMessage(request);
            }
            else
            {
                AsyncResult  ares  = mMsg.AsyncResult;
                IMessageCtrl mctrl = sink.AsyncProcessMessage(request, ares);
                if (ares != null)
                {
                    ares.SetMessageCtrl(mctrl);
                }
                response = new ReturnMessage(null, new object[0], 0, null, mMsg);
            }

            _objectIdentity.NotifyClientDynamicSinks(false, request, true, false);

            return(response);
        }