[System.Security.SecurityCritical] // auto-generated
internal static Object FinishAsyncWorkCallback(Object[] args)
{
AsyncWorkItem This = (AsyncWorkItem)args[0];
Context srvCtx = This._srvID.ServerContext;
LogicalCallContext threadPoolCallCtx =
CallContext.SetLogicalCallContext(This._callCtx);
// Call the server context chain Async. We provide workItem as our
// replySink ... this will cause the replySink.ProcessMessage
// to switch back to the context of the original caller thread.
// Call the dynamic sinks to notify that the async call
// is starting
srvCtx.NotifyDynamicSinks(
This._reqMsg,
false, // bCliSide
true, // bStart
true, // bAsync
true); // bNotifyGlobals
// <
IMessageCtrl ctrl =
srvCtx.GetServerContextChain().AsyncProcessMessage(
This._reqMsg,
(IMessageSink)This);
// change back to the old context
CallContext.SetLogicalCallContext(threadPoolCallCtx);
return(null);
}
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 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);
}
internal static object FinishAsyncWorkCallback(object[] args)
{
AsyncWorkItem replySink = (AsyncWorkItem)args[0];
Context serverContext = replySink._srvID.ServerContext;
LogicalCallContext callCtx = CallContext.SetLogicalCallContext(replySink._callCtx);
serverContext.NotifyDynamicSinks(replySink._reqMsg, false, true, true, true);
serverContext.GetServerContextChain().AsyncProcessMessage(replySink._reqMsg, replySink);
CallContext.SetLogicalCallContext(callCtx);
return(null);
}
internal static object FinishAsyncWorkCallback(object[] args)
{
AsyncWorkItem asyncWorkItem = (AsyncWorkItem)args[0];
Context serverContext = asyncWorkItem._srvID.ServerContext;
LogicalCallContext logicalCallContext = CallContext.SetLogicalCallContext(asyncWorkItem._callCtx);
serverContext.NotifyDynamicSinks(asyncWorkItem._reqMsg, false, true, true, true);
IMessageCtrl messageCtrl = serverContext.GetServerContextChain().AsyncProcessMessage(asyncWorkItem._reqMsg, asyncWorkItem);
CallContext.SetLogicalCallContext(logicalCallContext);
return(null);
}
internal static object DoAsyncDispatchCallback(object[] args)
{
AsyncWorkItem asyncWorkItem = (AsyncWorkItem)null;
IMessage msg = (IMessage)args[0];
IMessageSink replySink = (IMessageSink)args[1];
Context oldCtx = (Context)args[2];
Context context = (Context)args[3];
if (replySink != null)
{
asyncWorkItem = new AsyncWorkItem(replySink, oldCtx);
}
return((object)context.GetServerContextChain().AsyncProcessMessage(msg, (IMessageSink)asyncWorkItem));
}
internal static object AsyncProcessMessageCallback(object[] args)
{
AsyncWorkItem replySink = null;
IMessage msg = (IMessage) args[0];
IMessageSink sink = (IMessageSink) args[1];
Context oldCtx = (Context) args[2];
Context context2 = (Context) args[3];
if (sink != null)
{
replySink = new AsyncWorkItem(sink, oldCtx);
}
context2.NotifyDynamicSinks(msg, false, true, true, true);
return context2.GetServerContextChain().AsyncProcessMessage(msg, replySink);
}
internal static object DoAsyncDispatchCallback(object[] args)
{
AsyncWorkItem replySink = null;
IMessage msg = (IMessage)args[0];
IMessageSink sink = (IMessageSink)args[1];
Context oldCtx = (Context)args[2];
Context context2 = (Context)args[3];
if (sink != null)
{
replySink = new AsyncWorkItem(sink, oldCtx);
}
return(context2.GetServerContextChain().AsyncProcessMessage(msg, replySink));
}
internal static object AsyncProcessMessageCallback(object[] args)
{
AsyncWorkItem replySink = null;
IMessage msg = (IMessage)args[0];
IMessageSink sink = (IMessageSink)args[1];
Context oldCtx = (Context)args[2];
Context context2 = (Context)args[3];
if (sink != null)
{
replySink = new AsyncWorkItem(sink, oldCtx);
}
context2.NotifyDynamicSinks(msg, false, true, true, true);
return(context2.GetServerContextChain().AsyncProcessMessage(msg, replySink));
}
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;
}
internal static object FinishAsyncWorkCallback(object[] args)
{
AsyncWorkItem asyncWorkItem = (AsyncWorkItem)args[0];
Context serverContext = asyncWorkItem._srvID.ServerContext;
LogicalCallContext callCtx = CallContext.SetLogicalCallContext(asyncWorkItem._callCtx);
IMessage msg = asyncWorkItem._reqMsg;
int num1 = 0;
int num2 = 1;
int num3 = 1;
int num4 = 1;
serverContext.NotifyDynamicSinks(msg, num1 != 0, num2 != 0, num3 != 0, num4 != 0);
serverContext.GetServerContextChain().AsyncProcessMessage(asyncWorkItem._reqMsg, (IMessageSink)asyncWorkItem);
CallContext.SetLogicalCallContext(callCtx);
return((object)null);
}
internal static object AsyncProcessMessageCallback(object[] args)
{
AsyncWorkItem asyncWorkItem = (AsyncWorkItem)null;
IMessage msg1 = (IMessage)args[0];
IMessageSink replySink = (IMessageSink)args[1];
Context oldCtx = (Context)args[2];
Context context = (Context)args[3];
if (replySink != null)
{
asyncWorkItem = new AsyncWorkItem(replySink, oldCtx);
}
IMessage msg2 = msg1;
int num1 = 0;
int num2 = 1;
int num3 = 1;
int num4 = 1;
context.NotifyDynamicSinks(msg2, num1 != 0, num2 != 0, num3 != 0, num4 != 0);
return((object)context.GetServerContextChain().AsyncProcessMessage(msg1, (IMessageSink)asyncWorkItem));
}
[System.Security.SecurityCritical] // auto-generated
internal static Object AsyncProcessMessageCallback(Object[] args)
{
AsyncWorkItem workItem = null;
IMessage reqMsg = (IMessage)args[0];
IMessageSink replySink = (IMessageSink)args[1];
Context oldCtx = (Context)args[2];
Context srvCtx = (Context)args[3];
IMessageCtrl msgCtrl = null;
// we use the work item just as our replySink in this case
if (replySink != null)
{
workItem = new AsyncWorkItem(replySink, oldCtx);
}
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain");
srvCtx.NotifyDynamicSinks(
reqMsg,
false, // bCliSide
true, // bStart
true, // bAsync
true); // bNotifyGlobals
// call the server context chain
msgCtrl =
srvCtx.GetServerContextChain().AsyncProcessMessage(
reqMsg,
(IMessageSink)workItem);
// Note: for async calls, we will do the return notification
// for dynamic properties only when the async call
// completes (i.e. when the replySink gets called)
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain");
return(msgCtrl);
}
[System.Security.SecurityCritical] // auto-generated
internal static Object DoAsyncDispatchCallback(Object[] args)
{
AsyncWorkItem workItem = null;
IMessage reqMsg = (IMessage)args[0];
IMessageSink replySink = (IMessageSink)args[1];
Context oldCtx = (Context)args[2];
Context srvCtx = (Context)args[3];
IMessageCtrl msgCtrl = null;
// we use the work item just as our replySink in this case
if (replySink != null)
{
workItem = new AsyncWorkItem(replySink, oldCtx);
}
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain");
// call the server context chain
msgCtrl =
srvCtx.GetServerContextChain().AsyncProcessMessage(reqMsg, (IMessageSink)workItem);
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain");
return(msgCtrl);
}
[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
} // AsyncProcessMessage
internal static Object DoAsyncDispatchCallback(Object[] args)
{
AsyncWorkItem workItem = null;
IMessage reqMsg = (IMessage) args[0];
IMessageSink replySink = (IMessageSink) args[1];
Context oldCtx = (Context) args[2];
Context srvCtx = (Context) args[3];
IMessageCtrl msgCtrl = null;
// we use the work item just as our replySink in this case
if (replySink != null)
{
workItem = new AsyncWorkItem(replySink, oldCtx);
}
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain");
// call the server context chain
msgCtrl =
srvCtx.GetServerContextChain().AsyncProcessMessage(reqMsg, (IMessageSink)workItem);
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain");
return msgCtrl;
}
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 static Object AsyncProcessMessageCallback(Object[] args)
{
AsyncWorkItem workItem = null;
IMessage reqMsg = (IMessage) args[0];
IMessageSink replySink = (IMessageSink) args[1];
Context oldCtx = (Context) args[2];
Context srvCtx = (Context) args[3];
IMessageCtrl msgCtrl = null;
// we use the work item just as our replySink in this case
if (replySink != null)
{
workItem = new AsyncWorkItem(replySink, oldCtx);
}
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain");
srvCtx.NotifyDynamicSinks(
reqMsg,
false, // bCliSide
true, // bStart
true, // bAsync
true); // bNotifyGlobals
// call the server context chain
msgCtrl =
srvCtx.GetServerContextChain().AsyncProcessMessage(
reqMsg,
(IMessageSink)workItem);
// Note: for async calls, we will do the return notification
// for dynamic properties only when the async call
// completes (i.e. when the replySink gets called)
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain");
return msgCtrl;
}
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);
IMessageCtrl msgCtrl = null;
if (errMsg != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(errMsg);
}
}
else
{
ServerIdentity srvID = GetServerIdentity(reqMsg);
AsyncWorkItem workItem = null;
// 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.
Context oldCtx = Thread.CurrentContext;
// change to server object context
ContextTransitionFrame frame = new ContextTransitionFrame();
srvCtx = srvID.ServerContext;
Thread.CurrentThread.EnterContext(srvCtx, ref frame);
// we use the work item just as our replySink in this case
if (replySink != null)
{
workItem = new AsyncWorkItem(replySink, oldCtx);
}
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain");
srvCtx.NotifyDynamicSinks(
reqMsg,
false, // bCliSide
true, // bStart
true, // bAsync
true); // bNotifyGlobals
// call the server context chain
msgCtrl =
srvCtx.GetServerContextChain().AsyncProcessMessage(
reqMsg,
(IMessageSink)workItem);
// Note: for async calls, we will do the return notification
// for dynamic properties only when the async call
// completes (i.e. when the replySink gets called)
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain");
// chain back to the dispatch thread context
Thread.CurrentThread.ReturnToContext(ref frame);
}
else
{
// 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);
msgCtrl = null;
}
}
Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Async call returning!!\n");
return(msgCtrl);
} // AsyncProcessMessage
} // AsyncProcessMessage
internal static IMessageCtrl DoAsyncDispatch(IMessage reqMsg, IMessageSink replySink)
{
ServerIdentity srvID = GetServerIdentity(reqMsg);
AsyncWorkItem workItem = null;
// 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.
Context oldCtx = Thread.CurrentContext;
// change to server object context
ContextTransitionFrame frame = new ContextTransitionFrame();
Thread.CurrentThread.EnterContext(srvID.ServerContext, ref frame);
// we use the work item just as our replySink in this case
if (replySink != null)
{
workItem = new AsyncWorkItem(replySink, oldCtx);
}
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain");
// call the server context chain
IMessageCtrl msgCtrl =
srvID.ServerContext.GetServerContextChain().AsyncProcessMessage(reqMsg, (IMessageSink)workItem);
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain");
// chain back to the dispatch thread context
Thread.CurrentThread.ReturnToContext(ref frame);
//}
return msgCtrl;
} // DoDispatch
} // AsyncProcessMessage
internal static IMessageCtrl DoAsyncDispatch(IMessage reqMsg, IMessageSink replySink)
{
ServerIdentity srvID = GetServerIdentity(reqMsg);
AsyncWorkItem workItem = null;
// 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.
Context oldCtx = Thread.CurrentContext;
// change to server object context
ContextTransitionFrame frame = new ContextTransitionFrame();
Thread.CurrentThread.EnterContext(srvID.ServerContext, ref frame);
// we use the work item just as our replySink in this case
if (replySink != null)
{
workItem = new AsyncWorkItem(replySink, oldCtx);
}
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain");
// call the server context chain
IMessageCtrl msgCtrl =
srvID.ServerContext.GetServerContextChain().AsyncProcessMessage(reqMsg, (IMessageSink)workItem);
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain");
// chain back to the dispatch thread context
Thread.CurrentThread.ReturnToContext(ref frame);
//}
return(msgCtrl);
} // DoDispatch
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);
IMessageCtrl msgCtrl=null;
if (errMsg != null)
{
if (replySink!=null)
{
replySink.SyncProcessMessage(errMsg);
}
}
else
{
ServerIdentity srvID = GetServerIdentity(reqMsg);
AsyncWorkItem workItem = null;
// 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.
Context oldCtx = Thread.CurrentContext;
// change to server object context
ContextTransitionFrame frame = new ContextTransitionFrame();
srvCtx = srvID.ServerContext;
Thread.CurrentThread.EnterContext(srvCtx, ref frame);
// we use the work item just as our replySink in this case
if (replySink != null)
{
workItem = new AsyncWorkItem(replySink, oldCtx);
}
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain");
srvCtx.NotifyDynamicSinks(
reqMsg,
false, // bCliSide
true, // bStart
true, // bAsync
true); // bNotifyGlobals
// call the server context chain
msgCtrl =
srvCtx.GetServerContextChain().AsyncProcessMessage(
reqMsg,
(IMessageSink)workItem);
// Note: for async calls, we will do the return notification
// for dynamic properties only when the async call
// completes (i.e. when the replySink gets called)
Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain");
// chain back to the dispatch thread context
Thread.CurrentThread.ReturnToContext(ref frame);
}
else
{
// 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);
msgCtrl = null;
}
}
Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Async call returning!!\n");
return msgCtrl;
} // AsyncProcessMessage
internal static object DoAsyncDispatchCallback(object[] args)
{
AsyncWorkItem replySink = null;
IMessage msg = (IMessage) args[0];
IMessageSink sink = (IMessageSink) args[1];
Context oldCtx = (Context) args[2];
Context context2 = (Context) args[3];
if (sink != null)
{
replySink = new AsyncWorkItem(sink, oldCtx);
}
return context2.GetServerContextChain().AsyncProcessMessage(msg, replySink);
}
