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 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));
}
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);
}
// Forward call to the channel.
IMessageSink channelSink = GetChannelSink(reqMsg);
// Move to default context unless we are going through
// the cross-context channel
ContextTransitionFrame frame = new ContextTransitionFrame();
if (channelSink != CrossContextChannel.MessageSink)
{
Thread.CurrentThread.EnterContext(
Context.DefaultContext,
ref frame);
}
msgCtrl = channelSink.AsyncProcessMessage(reqMsg, replySink);
if (channelSink != CrossContextChannel.MessageSink)
{
Thread.CurrentThread.ReturnToContext(ref frame);
}
}
return msgCtrl;
}
[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);
}