public void ServerCallback(IAsyncResult ar)
{
if (!(this._asyncEnd != (MethodInfo)null))
{
return;
}
RemotingMethodCachedData reflectionCachedData1 = InternalRemotingServices.GetReflectionCachedData((MethodBase)this._asyncEnd);
RemotingMethodCachedData reflectionCachedData2 = InternalRemotingServices.GetReflectionCachedData(this._msg.MethodBase);
ParameterInfo[] parameters = reflectionCachedData1.Parameters;
object[] objArray = new object[parameters.Length];
objArray[parameters.Length - 1] = (object)ar;
object[] args = this._msg.Args;
AsyncMessageHelper.GetOutArgs(reflectionCachedData2.Parameters, args, objArray);
StackBuilderSink stackBuilderSink = new StackBuilderSink(this._serverObject);
object[] outArgs1;
object ret = stackBuilderSink.PrivateProcessMessage(this._asyncEnd.MethodHandle, Message.CoerceArgs((MethodBase)this._asyncEnd, objArray, parameters), this._serverObject, out outArgs1);
if (outArgs1 != null)
{
outArgs1 = ArgMapper.ExpandAsyncEndArgsToSyncArgs(reflectionCachedData2, outArgs1);
}
stackBuilderSink.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData2, args, ref outArgs1);
object[] outArgs2 = outArgs1;
int argCount = this._msg.ArgCount;
LogicalCallContext logicalCallContext = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
IMethodCallMessage mcm = this._msg;
this.AsyncProcessResponse((IMessage) new ReturnMessage(ret, outArgs2, argCount, logicalCallContext, mcm), (ITransportHeaders)null, (Stream)null);
}
internal ServerIdentity(MarshalByRefObject obj, Context serverCtx)
: base(obj is ContextBoundObject)
{
if (obj != null)
{
this._srvType = RemotingServices.IsTransparentProxy((object)obj) ? RemotingServices.GetRealProxy((object)obj).GetProxiedType() : obj.GetType();
}
this._srvCtx = serverCtx;
this._serverObjectChain = (IMessageSink)null;
this._stackBuilderSink = (StackBuilderSink)null;
}
/// <include file='doc\ChannelSinkStacks.uex' path='docs/doc[@for="ServerChannelSinkStack.ServerCallback"]/*' />
public void ServerCallback(IAsyncResult ar)
{
if (_asyncEnd != null)
{
RemotingMethodCachedData asyncEndCache = (RemotingMethodCachedData)
InternalRemotingServices.GetReflectionCachedData(_asyncEnd);
MethodInfo syncMI = (MethodInfo)_msg.MethodBase;
RemotingMethodCachedData syncCache = (RemotingMethodCachedData)
InternalRemotingServices.GetReflectionCachedData(syncMI);
ParameterInfo[] paramList = asyncEndCache.Parameters;
// construct list to pass into End
Object[] parameters = new Object[paramList.Length];
parameters[paramList.Length - 1] = ar; // last parameter is the async result
Object[] syncMsgArgs = _msg.Args;
// copy out and ref parameters to the parameters list
AsyncMessageHelper.GetOutArgs(syncCache.Parameters, syncMsgArgs, parameters);
Object[] outArgs;
StackBuilderSink s = new StackBuilderSink(_serverObject);
Object returnValue =
s.PrivateProcessMessage(_asyncEnd,
System.Runtime.Remoting.Messaging.Message.CoerceArgs(_asyncEnd, parameters, paramList),
_serverObject,
0,
false,
out outArgs);
// The outArgs list is associated with the EndXXX method. We need to make sure
// it is sized properly for the out args of the XXX method.
if (outArgs != null)
{
outArgs = ArgMapper.ExpandAsyncEndArgsToSyncArgs(syncCache, outArgs);
}
s.CopyNonByrefOutArgsFromOriginalArgs(syncCache, syncMsgArgs, ref outArgs);
IMessage retMessage = new ReturnMessage(
returnValue, outArgs, _msg.ArgCount, CallContext.GetLogicalCallContext(), _msg);
AsyncProcessResponse(retMessage, null, null);
}
} // ServerCallback
// Creates a new server identity. This form is used by RemotingServices.Wrap
//
internal ServerIdentity(MarshalByRefObject obj, Context serverCtx) : base(obj is ContextBoundObject)
{
if (null != obj)
{
if (!RemotingServices.IsTransparentProxy(obj))
{
_srvType = obj.GetType();
}
else
{
RealProxy rp = RemotingServices.GetRealProxy(obj);
_srvType = rp.GetProxiedType();
}
}
_srvCtx = serverCtx;
_serverObjectChain = null;
_stackBuilderSink = null;
}
internal static object ActivateWithMessage(Type serverType, IMessage msg, ServerIdentity srvIdToBind, out Exception e)
{
object obj2 = null;
e = null;
obj2 = RemotingServices.AllocateUninitializedObject(serverType);
object proxy = null;
if (serverType.IsContextful)
{
if (msg is ConstructorCallMessage)
{
proxy = ((ConstructorCallMessage)msg).GetThisPtr();
}
else
{
proxy = null;
}
proxy = RemotingServices.Wrap((ContextBoundObject)obj2, proxy, false);
}
else
{
if (Thread.CurrentContext != Context.DefaultContext)
{
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_Failed"));
}
proxy = obj2;
}
IMessageSink sink = new StackBuilderSink(proxy);
IMethodReturnMessage message = (IMethodReturnMessage)sink.SyncProcessMessage(msg);
if (message.Exception == null)
{
if (serverType.IsContextful)
{
return(RemotingServices.Wrap((ContextBoundObject)obj2));
}
return(obj2);
}
e = message.Exception;
return(null);
}
internal IMessageSink CreateServerObjectSinkChain(MarshalByRefObject obj, bool forceInternalExecute)
{
IMessageSink messageSink = new StackBuilderSink(obj, forceInternalExecute);
messageSink = new ServerObjectTerminatorSink(messageSink);
messageSink = new LeaseSink(messageSink);
if (this.context_properties != null)
{
for (int i = this.context_properties.Count - 1; i >= 0; i--)
{
IContextProperty contextProperty = (IContextProperty)this.context_properties[i];
IContributeObjectSink contributeObjectSink = contextProperty as IContributeObjectSink;
if (contributeObjectSink != null)
{
messageSink = contributeObjectSink.GetObjectSink(obj, messageSink);
}
}
}
return(messageSink);
}
internal IMessageSink CreateServerObjectSinkChain(MarshalByRefObject obj, bool forceInternalExecute)
{
IMessageSink objectSink = new StackBuilderSink(obj, forceInternalExecute);
objectSink = new ServerObjectTerminatorSink(objectSink);
objectSink = new Lifetime.LeaseSink(objectSink);
if (context_properties != null)
{
// Contribute object sinks in reverse order
for (int n = context_properties.Count - 1; n >= 0; n--)
{
IContextProperty prop = (IContextProperty)context_properties[n];
IContributeObjectSink contributor = prop as IContributeObjectSink;
if (contributor != null)
{
objectSink = contributor.GetObjectSink(obj, objectSink);
}
}
}
return(objectSink);
}
public void ServerCallback(IAsyncResult ar)
{
if (this._asyncEnd != null)
{
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(this._asyncEnd);
MethodInfo mi = (MethodInfo)this._msg.MethodBase;
RemotingMethodCachedData reflectionCachedData2 = InternalRemotingServices.GetReflectionCachedData(mi);
ParameterInfo[] parameters = reflectionCachedData.Parameters;
object[] array = new object[parameters.Length];
array[parameters.Length - 1] = ar;
object[] args = this._msg.Args;
AsyncMessageHelper.GetOutArgs(reflectionCachedData2.Parameters, args, array);
StackBuilderSink stackBuilderSink = new StackBuilderSink(this._serverObject);
object[] array2;
object ret = stackBuilderSink.PrivateProcessMessage(this._asyncEnd.MethodHandle, Message.CoerceArgs(this._asyncEnd, array, parameters), this._serverObject, out array2);
if (array2 != null)
{
array2 = ArgMapper.ExpandAsyncEndArgsToSyncArgs(reflectionCachedData2, array2);
}
stackBuilderSink.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData2, args, ref array2);
IMessage msg = new ReturnMessage(ret, array2, this._msg.ArgCount, Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext, this._msg);
this.AsyncProcessResponse(msg, null, null);
}
}
public void ServerCallback(IAsyncResult ar)
{
if (this._asyncEnd != null)
{
object[] objArray3;
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData((MethodBase)this._asyncEnd);
MethodInfo methodBase = (MethodInfo)this._msg.MethodBase;
RemotingMethodCachedData syncMethod = InternalRemotingServices.GetReflectionCachedData((MethodBase)methodBase);
ParameterInfo[] parameters = reflectionCachedData.Parameters;
object[] endArgs = new object[parameters.Length];
endArgs[parameters.Length - 1] = ar;
object[] args = this._msg.Args;
AsyncMessageHelper.GetOutArgs(syncMethod.Parameters, args, endArgs);
StackBuilderSink sink = new StackBuilderSink(this._serverObject);
object ret = sink.PrivateProcessMessage(this._asyncEnd.MethodHandle, Message.CoerceArgs(this._asyncEnd, endArgs, parameters), this._serverObject, 0, false, out objArray3);
if (objArray3 != null)
{
objArray3 = ArgMapper.ExpandAsyncEndArgsToSyncArgs(syncMethod, objArray3);
}
sink.CopyNonByrefOutArgsFromOriginalArgs(syncMethod, args, ref objArray3);
IMessage msg = new ReturnMessage(ret, objArray3, this._msg.ArgCount, CallContext.GetLogicalCallContext(), this._msg);
this.AsyncProcessResponse(msg, null, null);
}
}
