internal virtual void FinishAsyncWork(object stateIgnored) { InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(AsyncWorkItem.FinishAsyncWorkCallback); object[] args = new object[] { this }; Thread.CurrentThread.InternalCrossContextCallback(this._srvID.ServerContext, ftnToCall, args); }
internal static IMessageCtrl DoAsyncDispatch(IMessage reqMsg, IMessageSink replySink) { object[] args = new object[4]; ServerIdentity serverIdentity = InternalSink.GetServerIdentity(reqMsg); if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid id = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { object obj = reqMsg.Properties[(object)"CORProfilerCookie"]; if (obj != null) { id = (Guid)obj; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(id, true); if (replySink != null) { replySink = (IMessageSink) new ServerAsyncReplyTerminatorSink(replySink); } } Context serverContext = serverIdentity.ServerContext; args[0] = (object)reqMsg; args[1] = (object)replySink; args[2] = (object)Thread.CurrentContext; args[3] = (object)serverContext; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(CrossContextChannel.DoAsyncDispatchCallback); return((IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(serverContext, ftnToCall, args)); }
[System.Security.SecurityCritical] // auto-generated internal virtual void FinishAsyncWork(Object stateIgnored) { InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(FinishAsyncWorkCallback); Object[] args = new Object[] { this }; Thread.CurrentThread.InternalCrossContextCallback(_srvID.ServerContext, xctxDel, args); }
[System.Security.SecurityCritical] // auto-generated internal static IMessageCtrl DoAsyncDispatch(IMessage reqMsg, IMessageSink replySink) { Object[] args = new Object[] { null, null, null, null }; ServerIdentity srvID = GetServerIdentity(reqMsg); // If active, notify the profiler that an asynchronous remoting message was received. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { Object obj = reqMsg.Properties["CORProfilerCookie"]; if (obj != null) { g = (Guid)obj; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(g, true); // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is sent. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ServerAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } IMessageCtrl msgCtrl = null; Context srvCtx = srvID.ServerContext; //if (srvCtx.IsThreadPoolAware) //{ // this is the case when we do not queue the work item since the // server context claims to be doing its own threading. args[0] = reqMsg; args[1] = replySink; args[2] = Thread.CurrentContext; args[3] = srvCtx; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(DoAsyncDispatchCallback); msgCtrl = (IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(srvCtx, xctxDel, args); //} return(msgCtrl); } // DoDispatch
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { IMessage message = InternalSink.ValidateMessage(reqMsg); IMessageCtrl result = null; if (message == null) { message = InternalSink.DisallowAsyncActivation(reqMsg); } if (message != null) { if (replySink != null) { replySink.SyncProcessMessage(message); } } else { if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid guid; RemotingServices.CORProfilerRemotingClientSendingMessage(out guid, true); if (RemotingServices.CORProfilerTrackRemotingCookie()) { reqMsg.Properties["CORProfilerCookie"] = guid; } if (replySink != null) { IMessageSink messageSink = new ClientAsyncReplyTerminatorSink(replySink); replySink = messageSink; } } Context currentContext = Thread.CurrentContext; currentContext.NotifyDynamicSinks(reqMsg, true, true, true, true); if (replySink != null) { replySink = new AsyncReplySink(replySink, currentContext); } object[] array = new object[3]; InternalCrossContextDelegate internalCrossContextDelegate = new InternalCrossContextDelegate(ClientContextTerminatorSink.AsyncProcessMessageCallback); IMessageSink channelSink = this.GetChannelSink(reqMsg); array[0] = reqMsg; array[1] = replySink; array[2] = channelSink; if (channelSink != CrossContextChannel.MessageSink) { result = (IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, internalCrossContextDelegate, array); } else { result = (IMessageCtrl)internalCrossContextDelegate(array); } } return(result); }
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { IMessage message = null; if (this._replySink != null) { object[] args = new object[] { reqMsg, this._replySink }; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(System.Runtime.Remoting.Messaging.AsyncReplySink.SyncProcessMessageCallback); message = (IMessage) Thread.CurrentThread.InternalCrossContextCallback(this._cliCtx, ftnToCall, args); } return message; }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { IMessage message = InternalSink.ValidateMessage(reqMsg); object[] array = new object[4]; IMessageCtrl result = null; if (message != null) { if (replySink != null) { replySink.SyncProcessMessage(message); } } else { ServerIdentity serverIdentity = InternalSink.GetServerIdentity(reqMsg); if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid id = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { object obj = reqMsg.Properties["CORProfilerCookie"]; if (obj != null) { id = (Guid)obj; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(id, true); if (replySink != null) { IMessageSink messageSink = new ServerAsyncReplyTerminatorSink(replySink); replySink = messageSink; } } Context serverContext = serverIdentity.ServerContext; if (serverContext.IsThreadPoolAware) { array[0] = reqMsg; array[1] = replySink; array[2] = Thread.CurrentContext; array[3] = serverContext; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(CrossContextChannel.AsyncProcessMessageCallback); result = (IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(serverContext, ftnToCall, array); } else { AsyncWorkItem @object = new AsyncWorkItem(reqMsg, replySink, Thread.CurrentContext, serverIdentity); WaitCallback callBack = new WaitCallback(@object.FinishAsyncWork); ThreadPool.QueueUserWorkItem(callBack); } } return(result); }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { IMessage msg = InternalSink.ValidateMessage(reqMsg); object[] args = new object[4]; IMessageCtrl ctrl = null; if (msg != null) { if (replySink != null) { replySink.SyncProcessMessage(msg); } return(ctrl); } ServerIdentity serverIdentity = InternalSink.GetServerIdentity(reqMsg); if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid empty = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { object obj2 = reqMsg.Properties["CORProfilerCookie"]; if (obj2 != null) { empty = (Guid)obj2; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(empty, true); if (replySink != null) { IMessageSink sink = new ServerAsyncReplyTerminatorSink(replySink); replySink = sink; } } Context serverContext = serverIdentity.ServerContext; if (serverContext.IsThreadPoolAware) { args[0] = reqMsg; args[1] = replySink; args[2] = Thread.CurrentContext; args[3] = serverContext; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(CrossContextChannel.AsyncProcessMessageCallback); return((IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(serverContext, ftnToCall, args)); } AsyncWorkItem item = null; item = new AsyncWorkItem(reqMsg, replySink, Thread.CurrentContext, serverIdentity); WaitCallback callBack = new WaitCallback(item.FinishAsyncWork); ThreadPool.QueueUserWorkItem(callBack); return(ctrl); }
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { IMessage message = null; if (this._replySink != null) { object[] args = new object[] { reqMsg, this._replySink }; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(System.Runtime.Remoting.Messaging.AsyncReplySink.SyncProcessMessageCallback); message = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(this._cliCtx, ftnToCall, args); } return(message); }
public virtual IMessage SyncProcessMessage(IMessage msg) { IMessage message = null; if (this._replySink != null) { Thread.CurrentContext.NotifyDynamicSinks(msg, false, false, true, true); object[] args = new object[] { this._replySink, msg }; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(AsyncWorkItem.SyncProcessMessageCallback); message = (IMessage) Thread.CurrentThread.InternalCrossContextCallback(this._oldCtx, ftnToCall, args); } return message; }
public virtual IMessage SyncProcessMessage(IMessage msg) { IMessage message = null; if (this._replySink != null) { Thread.CurrentContext.NotifyDynamicSinks(msg, false, false, true, true); object[] args = new object[] { this._replySink, msg }; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(AsyncWorkItem.SyncProcessMessageCallback); message = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(this._oldCtx, ftnToCall, args); } return(message); }
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { IMessage message2; IMessage message = InternalSink.ValidateMessage(reqMsg); if (message != null) { return(message); } Context currentContext = Thread.CurrentContext; bool flag = currentContext.NotifyDynamicSinks(reqMsg, true, true, false, true); if (reqMsg is IConstructionCallMessage) { message = currentContext.NotifyActivatorProperties(reqMsg, false); if (message != null) { return(message); } message2 = ((IConstructionCallMessage)reqMsg).Activator.Activate((IConstructionCallMessage)reqMsg); message = currentContext.NotifyActivatorProperties(message2, false); if (message != null) { return(message); } } else { message2 = null; ChannelServices.NotifyProfiler(reqMsg, RemotingProfilerEvent.ClientSend); object[] args = new object[2]; IMessageSink channelSink = this.GetChannelSink(reqMsg); args[0] = reqMsg; args[1] = channelSink; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(ClientContextTerminatorSink.SyncProcessMessageCallback); if (channelSink != CrossContextChannel.MessageSink) { message2 = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, ftnToCall, args); } else { message2 = (IMessage)ftnToCall(args); } ChannelServices.NotifyProfiler(message2, RemotingProfilerEvent.ClientReceive); } if (flag) { currentContext.NotifyDynamicSinks(reqMsg, true, false, false, true); } return(message2); }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { IMessage msg = InternalSink.ValidateMessage(reqMsg); IMessageCtrl ctrl = null; if (msg == null) { msg = InternalSink.DisallowAsyncActivation(reqMsg); } if (msg != null) { if (replySink != null) { replySink.SyncProcessMessage(msg); } return(ctrl); } if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid guid; RemotingServices.CORProfilerRemotingClientSendingMessage(out guid, true); if (RemotingServices.CORProfilerTrackRemotingCookie()) { reqMsg.Properties["CORProfilerCookie"] = guid; } if (replySink != null) { IMessageSink sink = new ClientAsyncReplyTerminatorSink(replySink); replySink = sink; } } Context currentContext = Thread.CurrentContext; currentContext.NotifyDynamicSinks(reqMsg, true, true, true, true); if (replySink != null) { replySink = new System.Runtime.Remoting.Messaging.AsyncReplySink(replySink, currentContext); } object[] args = new object[3]; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(ClientContextTerminatorSink.AsyncProcessMessageCallback); IMessageSink channelSink = this.GetChannelSink(reqMsg); args[0] = reqMsg; args[1] = replySink; args[2] = channelSink; if (channelSink != CrossContextChannel.MessageSink) { return((IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, ftnToCall, args)); } return((IMessageCtrl)ftnToCall(args)); }
internal static IConstructionReturnMessage DoCrossContextActivation(IConstructionCallMessage reqMsg) { bool isContextful = reqMsg.ActivationType.IsContextful; Context context = null; if (isContextful) { context = new Context(); ArrayList arrayList = (ArrayList)reqMsg.ContextProperties; for (int i = 0; i < arrayList.Count; i++) { IContextProperty contextProperty = arrayList[i] as IContextProperty; if (contextProperty == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_BadAttribute")); } RuntimeAssembly asm = (RuntimeAssembly)contextProperty.GetType().Assembly; ActivationServices.CheckForInfrastructurePermission(asm); if (context.GetProperty(contextProperty.Name) == null) { context.SetProperty(contextProperty); } } context.Freeze(); for (int j = 0; j < arrayList.Count; j++) { if (!((IContextProperty)arrayList[j]).IsNewContextOK(context)) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_PropertyUnhappy")); } } } InternalCrossContextDelegate internalCrossContextDelegate = new InternalCrossContextDelegate(ActivationServices.DoCrossContextActivationCallback); object[] args = new object[] { reqMsg }; IConstructionReturnMessage result; if (isContextful) { result = (Thread.CurrentThread.InternalCrossContextCallback(context, internalCrossContextDelegate, args) as IConstructionReturnMessage); } else { result = (internalCrossContextDelegate(args) as IConstructionReturnMessage); } return(result); }
[System.Security.SecurityCritical] // auto-generated public virtual IMessage SyncProcessMessage(IMessage reqMsg) { // we just switch back to the old context before calling // the next replySink IMessage retMsg = null; if (_replySink != null) { Object[] args = new Object[] { reqMsg, _replySink }; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(SyncProcessMessageCallback); retMsg = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(_cliCtx, xctxDel, args); } return(retMsg); }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { IMessage msg = InternalSink.ValidateMessage(reqMsg); object[] args = new object[4]; IMessageCtrl ctrl = null; if (msg != null) { if (replySink != null) { replySink.SyncProcessMessage(msg); } return ctrl; } ServerIdentity serverIdentity = InternalSink.GetServerIdentity(reqMsg); if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid empty = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { object obj2 = reqMsg.Properties["CORProfilerCookie"]; if (obj2 != null) { empty = (Guid) obj2; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(empty, true); if (replySink != null) { IMessageSink sink = new ServerAsyncReplyTerminatorSink(replySink); replySink = sink; } } Context serverContext = serverIdentity.ServerContext; if (serverContext.IsThreadPoolAware) { args[0] = reqMsg; args[1] = replySink; args[2] = Thread.CurrentContext; args[3] = serverContext; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(CrossContextChannel.AsyncProcessMessageCallback); return (IMessageCtrl) Thread.CurrentThread.InternalCrossContextCallback(serverContext, ftnToCall, args); } AsyncWorkItem item = null; item = new AsyncWorkItem(reqMsg, replySink, Thread.CurrentContext, serverIdentity); WaitCallback callBack = new WaitCallback(item.FinishAsyncWork); ThreadPool.QueueUserWorkItem(callBack); return ctrl; }
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { IMessage result = null; if (this._replySink != null) { object[] args = new object[] { reqMsg, this._replySink }; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(AsyncReplySink.SyncProcessMessageCallback); result = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(this._cliCtx, ftnToCall, args); } return(result); }
internal static IConstructionReturnMessage DoCrossContextActivation(IConstructionCallMessage reqMsg) { bool isContextful = reqMsg.ActivationType.IsContextful; Context newCtx = null; if (isContextful) { newCtx = new Context(); ArrayList contextProperties = (ArrayList)reqMsg.ContextProperties; RuntimeAssembly asm = null; for (int i = 0; i < contextProperties.Count; i++) { IContextProperty prop = contextProperties[i] as IContextProperty; if (prop == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_BadAttribute")); } asm = (RuntimeAssembly)prop.GetType().Assembly; CheckForInfrastructurePermission(asm); if (newCtx.GetProperty(prop.Name) == null) { newCtx.SetProperty(prop); } } newCtx.Freeze(); for (int j = 0; j < contextProperties.Count; j++) { if (!((IContextProperty)contextProperties[j]).IsNewContextOK(newCtx)) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_PropertyUnhappy")); } } } InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(ActivationServices.DoCrossContextActivationCallback); object[] args = new object[] { reqMsg }; if (isContextful) { return(Thread.CurrentThread.InternalCrossContextCallback(newCtx, ftnToCall, args) as IConstructionReturnMessage); } return(ftnToCall(args) as IConstructionReturnMessage); }
[System.Security.SecurityCritical] // auto-generated public virtual IMessage SyncProcessMessage(IMessage msg) { // This gets called when the called object finishes the AsyncWork... // This is called irrespective of whether we delegated the initial // work to a thread pool thread or not. Quite likely it will be // called on a user thread (i.e. a thread different from the // forward call thread) // we just switch back to the old context before calling // the next replySink IMessage retMsg = null; if (_replySink != null) { // This assert covers the common case (ThreadPool) // and checks that the reply thread for the async call // indeed emerges from the server context. BCLDebug.Assert( (_srvID == null) || (_srvID.ServerContext == Thread.CurrentContext), "Thread expected to be in the server context!"); // Call the dynamic sinks to notify that the async call // has completed Thread.CurrentContext.NotifyDynamicSinks( msg, // this is the async reply false, // bCliSide false, // bStart true, // bAsync true); // bNotifyGlobals Object[] args = new Object[] { _replySink, msg }; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(SyncProcessMessageCallback); retMsg = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(_oldCtx, xctxDel, args); } return(retMsg); }
internal static IConstructionReturnMessage DoCrossContextActivation(IConstructionCallMessage reqMsg) { bool isContextful = reqMsg.ActivationType.IsContextful; Context context = (Context)null; if (isContextful) { context = new Context(); ArrayList arrayList = (ArrayList)reqMsg.ContextProperties; for (int index = 0; index < arrayList.Count; ++index) { IContextProperty prop = arrayList[index] as IContextProperty; if (prop == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_BadAttribute")); } ActivationServices.CheckForInfrastructurePermission((RuntimeAssembly)prop.GetType().Assembly); if (context.GetProperty(prop.Name) == null) { context.SetProperty(prop); } } context.Freeze(); for (int index = 0; index < arrayList.Count; ++index) { if (!((IContextProperty)arrayList[index]).IsNewContextOK(context)) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_PropertyUnhappy")); } } } InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(ActivationServices.DoCrossContextActivationCallback); object[] args = new object[1] { (object)reqMsg }; return(!isContextful?ftnToCall(args) as IConstructionReturnMessage : Thread.CurrentThread.InternalCrossContextCallback(context, ftnToCall, args) as IConstructionReturnMessage); }
[System.Security.SecurityCritical] // auto-generated internal static IConstructionReturnMessage DoCrossContextActivation( IConstructionCallMessage reqMsg) { bool bCtxBound = reqMsg.ActivationType.IsContextful; Context serverContext = null; if (bCtxBound) { // If the type is context bound, we need to create // the appropriate context and activate the object inside // it. // < // Create a new Context serverContext = new Context(); // < ArrayList list = (ArrayList) reqMsg.ContextProperties; RuntimeAssembly asm = null; for (int i=0; i<list.Count; i++) { IContextProperty prop = list[i] as IContextProperty; if (null == prop) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_BadAttribute")); } asm = (RuntimeAssembly)prop.GetType().Assembly; // Make a security check to ensure that the context property // is from a trusted assembly! CheckForInfrastructurePermission(asm); // This ensures that we don't try to add duplicate // attributes (eg. type attributes common on both client // and server end) if (serverContext.GetProperty(prop.Name) == null) { serverContext.SetProperty(prop); } } // No more property changes to the server context from here. serverContext.Freeze(); // (This seems like an overkill but that is how it is spec-ed) // Ask each of the properties in the context we formed from // if it is happy with the current context. for (int i=0; i<list.Count;i++) { if (!((IContextProperty)list[i]).IsNewContextOK( serverContext)) { throw new RemotingException( Environment.GetResourceString( "Remoting_Activation_PropertyUnhappy")); } } } IConstructionReturnMessage replyMsg; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(DoCrossContextActivationCallback); Object[] args = new Object[] { reqMsg }; if (bCtxBound) { replyMsg = Thread.CurrentThread.InternalCrossContextCallback( serverContext, xctxDel, args) as IConstructionReturnMessage; } else { replyMsg = xctxDel(args) as IConstructionReturnMessage; } return replyMsg; }
public virtual IMessage SyncProcessMessage(IMessage msg) { // This gets called when the called object finishes the AsyncWork... // This is called irrespective of whether we delegated the initial // work to a thread pool thread or not. Quite likely it will be // called on a user thread (i.e. a thread different from the // forward call thread) // we just switch back to the old context before calling // the next replySink IMessage retMsg = null; if (_replySink != null) { // This assert covers the common case (ThreadPool) // and checks that the reply thread for the async call // indeed emerges from the server context. BCLDebug.Assert( (_srvID == null) || (_srvID.ServerContext == Thread.CurrentContext), "Thread expected to be in the server context!"); // Call the dynamic sinks to notify that the async call // has completed Thread.CurrentContext.NotifyDynamicSinks( msg, // this is the async reply false, // bCliSide false, // bStart true, // bAsync true); // bNotifyGlobals Object[] args = new Object[] { _replySink, msg }; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(SyncProcessMessageCallback); retMsg = (IMessage) Thread.CurrentThread.InternalCrossContextCallback(_oldCtx, xctxDel, args); } return retMsg; }
/* package */ internal virtual void FinishAsyncWork(Object stateIgnored) { InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(FinishAsyncWorkCallback); Object[] args = new Object[] { this }; Thread.CurrentThread.InternalCrossContextCallback(_srvID.ServerContext, xctxDel, args); }
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { // we just switch back to the old context before calling // the next replySink IMessage retMsg = null; if (_replySink != null) { Object[] args = new Object[] { reqMsg, _replySink }; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(SyncProcessMessageCallback); retMsg = (IMessage) Thread.CurrentThread.InternalCrossContextCallback(_cliCtx, xctxDel, args); } return retMsg; }
internal static IMessageCtrl DoAsyncDispatch(IMessage reqMsg, IMessageSink replySink) { Object[] args = new Object[] { null, null, null, null }; ServerIdentity srvID = GetServerIdentity(reqMsg); // If active, notify the profiler that an asynchronous remoting message was received. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { Object obj = reqMsg.Properties["CORProfilerCookie"]; if (obj != null) g = (Guid) obj; } RemotingServices.CORProfilerRemotingServerReceivingMessage(g, true); // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is sent. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ServerAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } IMessageCtrl msgCtrl = null; Context srvCtx = srvID.ServerContext; //if (srvCtx.IsThreadPoolAware) //{ // this is the case when we do not queue the work item since the // server context claims to be doing its own threading. args[0] = reqMsg; args[1] = replySink; args[2] = Thread.CurrentContext; args[3] = srvCtx; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(DoAsyncDispatchCallback); msgCtrl = (IMessageCtrl) Thread.CurrentThread.InternalCrossContextCallback(srvCtx, xctxDel, args); //} return msgCtrl; } // DoDispatch
internal static IConstructionReturnMessage DoCrossContextActivation(IConstructionCallMessage reqMsg) { bool isContextful = reqMsg.ActivationType.IsContextful; Context newCtx = null; if (isContextful) { newCtx = new Context(); ArrayList contextProperties = (ArrayList) reqMsg.ContextProperties; RuntimeAssembly asm = null; for (int i = 0; i < contextProperties.Count; i++) { IContextProperty prop = contextProperties[i] as IContextProperty; if (prop == null) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_BadAttribute")); } asm = (RuntimeAssembly) prop.GetType().Assembly; CheckForInfrastructurePermission(asm); if (newCtx.GetProperty(prop.Name) == null) { newCtx.SetProperty(prop); } } newCtx.Freeze(); for (int j = 0; j < contextProperties.Count; j++) { if (!((IContextProperty) contextProperties[j]).IsNewContextOK(newCtx)) { throw new RemotingException(Environment.GetResourceString("Remoting_Activation_PropertyUnhappy")); } } } InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(ActivationServices.DoCrossContextActivationCallback); object[] args = new object[] { reqMsg }; if (isContextful) { return (Thread.CurrentThread.InternalCrossContextCallback(newCtx, ftnToCall, args) as IConstructionReturnMessage); } return (ftnToCall(args) as IConstructionReturnMessage); }
[System.Security.SecurityCritical] // auto-generated internal static ObjRef CreateDataForDomain(int appDomainId, IntPtr defCtxID) { // This is a subroutine of CreateProxyForDomain // so we can segregate the object references // from different app domains into different frames. This is // important for the app domain leak checking code. Message.DebugOut("Creating proxy for domain " + appDomainId + "\n"); RegisterWellKnownChannels(); InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(CreateDataForDomainCallback); return (ObjRef) Thread.CurrentThread.InternalCrossContextCallback(null, defCtxID, appDomainId, xctxDel, null); } // CreateDataForDomain
[System.Security.SecurityCritical] // auto-generated public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: AsyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); IMessageCtrl msgCtrl = null; if (errMsg == null) { errMsg = DisallowAsyncActivation(reqMsg); } if (errMsg != null) { if (replySink != null) { replySink.SyncProcessMessage(errMsg); } } else { // If active, notify the profiler that an asynchronous remoting call is being made. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g; RemotingServices.CORProfilerRemotingClientSendingMessage(out g, true); if (RemotingServices.CORProfilerTrackRemotingCookie()) { reqMsg.Properties["CORProfilerCookie"] = g; } // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is received. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ClientAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } Context cliCtx = Thread.CurrentContext; // Notify dynamic sinks that an Async call started cliCtx.NotifyDynamicSinks( reqMsg, true, // bCliSide true, // bStart true, // bAsync true); // bNotifyGlobals // Intercept the async reply to force the thread back // into the client-context before it executes further // and to notify dynamic sinks if (replySink != null) { replySink = new AsyncReplySink(replySink, cliCtx); } Object[] args = new Object[] { null, null, null }; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(AsyncProcessMessageCallback); IMessageSink channelSink = GetChannelSink(reqMsg); // Forward call to the channel. args[0] = reqMsg; args[1] = replySink; args[2] = channelSink; // Move to default context unless we are going through // the cross-context channel if (channelSink != CrossContextChannel.MessageSink) { msgCtrl = (IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, xctxDel, args); } else { msgCtrl = (IMessageCtrl)xctxDel(args); } } return(msgCtrl); }
private static object CompleteCrossContextCallback(InternalCrossContextDelegate ftnToCall, object[] args) { return ftnToCall(args); }
private static object CompleteCrossContextCallback(InternalCrossContextDelegate ftnToCall, object[] args);
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: SyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); if (errMsg != null) { return errMsg; } Context ctx = Thread.CurrentContext; bool bHasDynamicSinks = ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide true, // bStart false, // bAsync true); // bNotifyGlobals IMessage replyMsg; if (reqMsg is IConstructionCallMessage) { errMsg = ctx.NotifyActivatorProperties( reqMsg, false /*bServerSide*/); if (errMsg != null) { return errMsg; } replyMsg = ((IConstructionCallMessage)reqMsg).Activator.Activate( (IConstructionCallMessage)reqMsg); BCLDebug.Assert(replyMsg is IConstructionReturnMessage,"bad ctorRetMsg"); errMsg = ctx.NotifyActivatorProperties( replyMsg, false /*bServerSide*/); if (errMsg != null) { return errMsg; } } else { replyMsg = null; ChannelServices.NotifyProfiler(reqMsg, RemotingProfilerEvent.ClientSend); Object[] args = new Object[] { null, null }; IMessageSink channelSink = GetChannelSink(reqMsg); // Forward call to the channel. args[0] = reqMsg; args[1] = channelSink; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(SyncProcessMessageCallback); // Move to default context unless we are going through // the cross-context channel if (channelSink != CrossContextChannel.MessageSink) { replyMsg = (IMessage) Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, xctxDel, args); } else { replyMsg = (IMessage) xctxDel(args); } ChannelServices.NotifyProfiler(replyMsg, RemotingProfilerEvent.ClientReceive); } if (bHasDynamicSinks) { ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide false, // bStart false, // bAsync true); // bNotifyGlobals } return replyMsg; }
internal extern object InternalCrossContextCallback(Context ctx, IntPtr ctxID, int appDomainID, InternalCrossContextDelegate ftnToCall, object[] args);
internal object InternalCrossContextCallback(Context ctx, InternalCrossContextDelegate ftnToCall, object[] args);
internal object InternalCrossContextCallback(Context ctx, InternalCrossContextDelegate ftnToCall, object[] args) { return(this.InternalCrossContextCallback(ctx, ctx.InternalContextID, 0, ftnToCall, args)); }
[System.Security.SecurityCritical] // auto-generated public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Async call starting!!\n"); // One way Async notifications may potentially pass a null reply sink. IMessage errMsg = ValidateMessage(reqMsg); Object[] args = new Object[] { null, null, null, null }; IMessageCtrl msgCtrl = null; if (errMsg != null) { if (replySink != null) { replySink.SyncProcessMessage(errMsg); } } else { ServerIdentity srvID = GetServerIdentity(reqMsg); // If active, notify the profiler that an asynchronous remoting message was received. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { Object obj = reqMsg.Properties["CORProfilerCookie"]; if (obj != null) { g = (Guid)obj; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(g, true); // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is sent. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ServerAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } Context srvCtx = srvID.ServerContext; if (srvCtx.IsThreadPoolAware) { // this is the case when we do not queue the work item since the // server context claims to be doing its own threading. args[0] = reqMsg; args[1] = replySink; args[2] = Thread.CurrentContext; args[3] = srvCtx; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(AsyncProcessMessageCallback); msgCtrl = (IMessageCtrl)Thread.CurrentThread.InternalCrossContextCallback(srvCtx, xctxDel, args); } else { AsyncWorkItem workItem = null; // This is the case where we take care of returning the calling // thread asap by using the ThreadPool for completing the call. // we use a more elaborate WorkItem and delegate the work to the thread pool workItem = new AsyncWorkItem(reqMsg, replySink, Thread.CurrentContext, srvID); WaitCallback threadFunc = new WaitCallback(workItem.FinishAsyncWork); // Note: Dynamic sinks are notified in the threadFunc ThreadPool.QueueUserWorkItem(threadFunc); } } Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Async call returning!!\n"); return(msgCtrl); } // AsyncProcessMessage
internal object InternalCrossContextCallback(Context ctx, InternalCrossContextDelegate ftnToCall, object[] args) { return this.InternalCrossContextCallback(ctx, ctx.InternalContextID, 0, ftnToCall, args); }
[System.Security.SecurityCritical] // auto-generated public virtual IMessage SyncProcessMessage(IMessage reqMsg) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: SyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); if (errMsg != null) { return(errMsg); } Context ctx = Thread.CurrentContext; bool bHasDynamicSinks = ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide true, // bStart false, // bAsync true); // bNotifyGlobals IMessage replyMsg; if (reqMsg is IConstructionCallMessage) { errMsg = ctx.NotifyActivatorProperties( reqMsg, false /*bServerSide*/); if (errMsg != null) { return(errMsg); } replyMsg = ((IConstructionCallMessage)reqMsg).Activator.Activate( (IConstructionCallMessage)reqMsg); BCLDebug.Assert(replyMsg is IConstructionReturnMessage, "bad ctorRetMsg"); errMsg = ctx.NotifyActivatorProperties( replyMsg, false /*bServerSide*/); if (errMsg != null) { return(errMsg); } } else { replyMsg = null; ChannelServices.NotifyProfiler(reqMsg, RemotingProfilerEvent.ClientSend); Object[] args = new Object[] { null, null }; IMessageSink channelSink = GetChannelSink(reqMsg); // Forward call to the channel. args[0] = reqMsg; args[1] = channelSink; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(SyncProcessMessageCallback); // Move to default context unless we are going through // the cross-context channel if (channelSink != CrossContextChannel.MessageSink) { replyMsg = (IMessage)Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, xctxDel, args); } else { replyMsg = (IMessage)xctxDel(args); } ChannelServices.NotifyProfiler(replyMsg, RemotingProfilerEvent.ClientReceive); } if (bHasDynamicSinks) { ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide false, // bStart false, // bAsync true); // bNotifyGlobals } return(replyMsg); }
internal static IMessageCtrl DoAsyncDispatch(IMessage reqMsg, IMessageSink replySink) { object[] args = new object[4]; ServerIdentity serverIdentity = InternalSink.GetServerIdentity(reqMsg); if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid empty = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { object obj2 = reqMsg.Properties["CORProfilerCookie"]; if (obj2 != null) { empty = (Guid) obj2; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(empty, true); if (replySink != null) { IMessageSink sink = new ServerAsyncReplyTerminatorSink(replySink); replySink = sink; } } Context serverContext = serverIdentity.ServerContext; args[0] = reqMsg; args[1] = replySink; args[2] = Thread.CurrentContext; args[3] = serverContext; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(CrossContextChannel.DoAsyncDispatchCallback); return (IMessageCtrl) Thread.CurrentThread.InternalCrossContextCallback(serverContext, ftnToCall, args); }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Async call starting!!\n"); // One way Async notifications may potentially pass a null reply sink. IMessage errMsg = ValidateMessage(reqMsg); Object[] args = new Object[] { null, null, null, null }; IMessageCtrl msgCtrl = null; if (errMsg != null) { if (replySink!=null) { replySink.SyncProcessMessage(errMsg); } } else { ServerIdentity srvID = GetServerIdentity(reqMsg); // If active, notify the profiler that an asynchronous remoting message was received. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { Object obj = reqMsg.Properties["CORProfilerCookie"]; if (obj != null) { g = (Guid) obj; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(g, true); // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is sent. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ServerAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } Context srvCtx = srvID.ServerContext; if (srvCtx.IsThreadPoolAware) { // this is the case when we do not queue the work item since the // server context claims to be doing its own threading. args[0] = reqMsg; args[1] = replySink; args[2] = Thread.CurrentContext; args[3] = srvCtx; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(AsyncProcessMessageCallback); msgCtrl = (IMessageCtrl) Thread.CurrentThread.InternalCrossContextCallback(srvCtx, xctxDel, args); } else { AsyncWorkItem workItem = null; // This is the case where we take care of returning the calling // thread asap by using the ThreadPool for completing the call. // we use a more elaborate WorkItem and delegate the work to the thread pool workItem = new AsyncWorkItem(reqMsg, replySink, Thread.CurrentContext, srvID); WaitCallback threadFunc = new WaitCallback(workItem.FinishAsyncWork); // Note: Dynamic sinks are notified in the threadFunc ThreadPool.QueueUserWorkItem(threadFunc); } } Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Async call returning!!\n"); return msgCtrl; } // AsyncProcessMessage
private static object InternalRemotelySetupRemoteDomain(IntPtr contextId, int domainId, string friendlyName, AppDomainSetup setup, IntPtr parentSecurityDescriptor, char[] serProvidedEvidence, char[] serCreatorEvidence, byte[] serializedEvidence, AppDomainInitializerInfo initializerInfo) { InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(AppDomain.InternalRemotelySetupRemoteDomainHelper); object[] args = new object[] { friendlyName, setup, parentSecurityDescriptor, serProvidedEvidence, serCreatorEvidence, serializedEvidence, initializerInfo }; return Thread.CurrentThread.InternalCrossContextCallback(null, contextId, domainId, ftnToCall, args); }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: AsyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); IMessageCtrl msgCtrl=null; if (errMsg == null) { errMsg = DisallowAsyncActivation(reqMsg); } if (errMsg != null) { if (replySink != null) { replySink.SyncProcessMessage(errMsg); } } else { // If active, notify the profiler that an asynchronous remoting call is being made. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g; RemotingServices.CORProfilerRemotingClientSendingMessage(out g, true); if (RemotingServices.CORProfilerTrackRemotingCookie()) reqMsg.Properties["CORProfilerCookie"] = g; // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is received. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ClientAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } Context cliCtx = Thread.CurrentContext; // Notify dynamic sinks that an Async call started cliCtx.NotifyDynamicSinks( reqMsg, true, // bCliSide true, // bStart true, // bAsync true); // bNotifyGlobals // Intercept the async reply to force the thread back // into the client-context before it executes further // and to notify dynamic sinks if (replySink != null) { replySink = new AsyncReplySink(replySink, cliCtx); } Object[] args = new Object[] { null, null, null }; InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(AsyncProcessMessageCallback); IMessageSink channelSink = GetChannelSink(reqMsg); // Forward call to the channel. args[0] = reqMsg; args[1] = replySink; args[2] = channelSink; // Move to default context unless we are going through // the cross-context channel if (channelSink != CrossContextChannel.MessageSink) { msgCtrl = (IMessageCtrl) Thread.CurrentThread.InternalCrossContextCallback(Context.DefaultContext, xctxDel, args); } else { msgCtrl = (IMessageCtrl) xctxDel(args); } } return msgCtrl; }
internal static ObjRef CreateDataForDomain(int appDomainId, IntPtr defCtxID) { RegisterWellKnownChannels(); InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(RemotingServices.CreateDataForDomainCallback); return (ObjRef) Thread.CurrentThread.InternalCrossContextCallback(null, defCtxID, appDomainId, ftnToCall, null); }