internal MethodResponse(IMethodCallMessage msg, object handlerObject, BinaryMethodReturnMessage smuggledMrm)
{
if (msg != null)
{
this.MI = msg.MethodBase;
this._methodCache = InternalRemotingServices.GetReflectionCachedData(this.MI);
this.methodName = msg.MethodName;
this.uri = msg.Uri;
this.typeName = msg.TypeName;
if (this._methodCache.IsOverloaded())
{
this.methodSignature = (Type[]) msg.MethodSignature;
}
this.argCount = this._methodCache.Parameters.Length;
}
this.retVal = smuggledMrm.ReturnValue;
this.outArgs = smuggledMrm.Args;
this.fault = smuggledMrm.Exception;
this.callContext = smuggledMrm.LogicalCallContext;
if (smuggledMrm.HasProperties)
{
smuggledMrm.PopulateMessageProperties(this.Properties);
}
this.fSoap = false;
}
internal static object[] ExpandAsyncEndArgsToSyncArgs(RemotingMethodCachedData syncMethod, object[] asyncEndArgs)
{
object[] objArray = new object[syncMethod.Parameters.Length];
int[] outRefArgMap = syncMethod.OutRefArgMap;
for (int i = 0; i < outRefArgMap.Length; i++)
{
objArray[outRefArgMap[i]] = asyncEndArgs[i];
}
return objArray;
}
internal ArgMapper(MethodBase mb, bool fOut)
{
this._methodCachedData = InternalRemotingServices.GetReflectionCachedData(mb);
if (fOut)
{
this._map = this._methodCachedData.MarshalResponseArgMap;
}
else
{
this._map = this._methodCachedData.MarshalRequestArgMap;
}
}
internal ArgMapper(IMethodMessage mm, bool fOut)
{
this._mm = mm;
MethodBase methodBase = this._mm.MethodBase;
this._methodCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
if (fOut)
{
this._map = this._methodCachedData.MarshalResponseArgMap;
}
else
{
this._map = this._methodCachedData.MarshalRequestArgMap;
}
}
public MethodResponse(Header[] h1, IMethodCallMessage mcm)
{
if (mcm == null)
{
throw new ArgumentNullException("mcm");
}
Message message = mcm as Message;
if (message != null)
{
this.MI = message.GetMethodBase();
}
else
{
this.MI = mcm.MethodBase;
}
if (this.MI == null)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Message_MethodMissing"), new object[] { mcm.MethodName, mcm.TypeName }));
}
this._methodCache = InternalRemotingServices.GetReflectionCachedData(this.MI);
this.argCount = this._methodCache.Parameters.Length;
this.fSoap = true;
this.FillHeaders(h1);
}
private void PopulateOutArguments(RemotingMethodCachedData methodCache)
{
ParameterInfo[] parameters = methodCache.Parameters;
foreach (int num in methodCache.OutOnlyArgMap)
{
Type elementType = parameters[num].ParameterType.GetElementType();
if (elementType.IsValueType)
{
this.args[num] = Activator.CreateInstance(elementType, true);
}
}
}
internal MethodResponse(IMethodCallMessage msg, SmuggledMethodReturnMessage smuggledMrm, ArrayList deserializedArgs)
{
this.MI = msg.MethodBase;
this._methodCache = InternalRemotingServices.GetReflectionCachedData(this.MI);
this.methodName = msg.MethodName;
this.uri = msg.Uri;
this.typeName = msg.TypeName;
if (this._methodCache.IsOverloaded())
{
this.methodSignature = (Type[]) msg.MethodSignature;
}
this.retVal = smuggledMrm.GetReturnValue(deserializedArgs);
this.outArgs = smuggledMrm.GetArgs(deserializedArgs);
this.fault = smuggledMrm.GetException(deserializedArgs);
this.callContext = smuggledMrm.GetCallContext(deserializedArgs);
if (smuggledMrm.MessagePropertyCount > 0)
{
smuggledMrm.PopulateMessageProperties(this.Properties, deserializedArgs);
}
this.argCount = this._methodCache.Parameters.Length;
this.fSoap = false;
}
} // ExpandAsyncBeginArgsToSyncArgs
internal static Object[] ExpandAsyncEndArgsToSyncArgs(RemotingMethodCachedData syncMethod,
Object[] asyncEndArgs)
{
// This is when we have a list of args associated with EndFoo(), and
// we want to size it to a list of args associated with Foo();
Object[] args = new Object[syncMethod.Parameters.Length];
int[] outRefArgMap = syncMethod.OutRefArgMap;
for (int co = 0; co < outRefArgMap.Length; co++)
{
args[outRefArgMap[co]] = asyncEndArgs[co];
}
return args;
} // ExpandAsyncEndArgsToSyncArgs
// access attribute cached on the reflection object
internal static RemotingMethodCachedData GetReflectionCachedData(MethodBase mi)
{
RemotingMethodCachedData cache = null;
RuntimeMethodInfo rmi = null;
RuntimeConstructorInfo rci = null;
if ((rmi = mi as RuntimeMethodInfo) != null)
{
cache = (RemotingMethodCachedData)rmi.RemotingCache[CacheObjType.RemotingData];
if (cache == null)
rmi.RemotingCache[CacheObjType.RemotingData] = cache = new RemotingMethodCachedData(rmi);
}
else if ((rci = mi as RuntimeConstructorInfo) != null)
{
cache = (RemotingMethodCachedData)rci.RemotingCache[CacheObjType.RemotingData];
if (cache == null)
rci.RemotingCache[CacheObjType.RemotingData] = cache = new RemotingMethodCachedData(rci);
}
else
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeReflectionObject"));
return cache;
}// GetCachedRemotingAttribute
internal MethodResponse(IMethodCallMessage msg,
Object handlerObject,
BinaryMethodReturnMessage smuggledMrm)
{
if (msg != null)
{
MI = (MethodBase)msg.MethodBase;
_methodCache = InternalRemotingServices.GetReflectionCachedData(MI);
methodName = msg.MethodName;
uri = msg.Uri;
typeName = msg.TypeName;
if (_methodCache.IsOverloaded())
methodSignature = (Type[])msg.MethodSignature;
argCount = _methodCache.Parameters.Length;
}
retVal = smuggledMrm.ReturnValue;
outArgs = smuggledMrm.Args;
fault = smuggledMrm.Exception;
callContext = smuggledMrm.LogicalCallContext;
if (smuggledMrm.HasProperties)
smuggledMrm.PopulateMessageProperties(Properties);
fSoap = false;
}
internal MethodResponse(IMethodCallMessage msg,
SmuggledMethodReturnMessage smuggledMrm,
ArrayList deserializedArgs)
{
MI = (MethodBase)msg.MethodBase;
_methodCache = InternalRemotingServices.GetReflectionCachedData(MI);
methodName = msg.MethodName;
uri = msg.Uri;
typeName = msg.TypeName;
if (_methodCache.IsOverloaded())
methodSignature = (Type[])msg.MethodSignature;
retVal = smuggledMrm.GetReturnValue(deserializedArgs);
outArgs = smuggledMrm.GetArgs(deserializedArgs);
fault = smuggledMrm.GetException(deserializedArgs);
callContext = smuggledMrm.GetCallContext(deserializedArgs);
if (smuggledMrm.MessagePropertyCount > 0)
smuggledMrm.PopulateMessageProperties(Properties, deserializedArgs);
argCount = _methodCache.Parameters.Length;
fSoap = false;
}
// Constructor -- this constructor is called only in the SOAP Scenario
/// <include file='doc\Message.uex' path='docs/doc[@for="MethodResponse.MethodResponse"]/*' />
/// <internalonly/>
public MethodResponse(Header[] h1, IMethodCallMessage mcm)
{
if (mcm == null)
throw new ArgumentNullException("mcm");
Message msg = mcm as Message;
if (null != msg)
{
MI = (MethodBase)msg.GetMethodBase();
}
else
{
MI = (MethodBase)mcm.MethodBase;
}
if (MI == null)
{
throw new RemotingException(
String.Format(
Environment.GetResourceString(
"Remoting_Message_MethodMissing"),
mcm.MethodName,
mcm.TypeName));
}
_methodCache = InternalRemotingServices.GetReflectionCachedData(MI);
argCount = _methodCache.Parameters.Length;
fSoap = true;
FillHeaders(h1);
}
void PopulateOutArguments(RemotingMethodCachedData methodCache)
{
ParameterInfo[] parameterInfos = methodCache.Parameters;
// We need to have a dummy object in the array for out parameters
// that have value types.
foreach (int outArg in methodCache.OutOnlyArgMap)
{
Type type = parameterInfos[outArg].ParameterType.GetElementType();
if (type.IsValueType)
args[outArg] = Activator.CreateInstance(type, true);
}
}
internal static RemotingMethodCachedData GetReflectionCachedData(MethodBase mi)
{
RemotingMethodCachedData data = null;
RuntimeMethodInfo ri = null;
RuntimeConstructorInfo info2 = null;
ri = mi as RuntimeMethodInfo;
if (ri != null)
{
data = (RemotingMethodCachedData) ri.RemotingCache[CacheObjType.RemotingData];
if (data == null)
{
ri.RemotingCache[CacheObjType.RemotingData] = data = new RemotingMethodCachedData(ri);
}
return data;
}
info2 = mi as RuntimeConstructorInfo;
if (info2 == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeReflectionObject"));
}
data = (RemotingMethodCachedData) info2.RemotingCache[CacheObjType.RemotingData];
if (data == null)
{
info2.RemotingCache[CacheObjType.RemotingData] = data = new RemotingMethodCachedData(info2);
}
return data;
}
// access attribute cached on the reflection object
internal static RemotingMethodCachedData GetReflectionCachedData(MethodBase mi)
{
RemotingMethodCachedData cache = null;
cache = (RemotingMethodCachedData)mi.Cache[CacheObjType.RemotingData];
if (cache == null)
{
cache = new RemotingMethodCachedData(mi);
mi.Cache[CacheObjType.RemotingData] = cache;
}
return cache;
}// GetCachedRemotingAttribute
}// GetCachedRemotingAttribute
internal static RemotingCachedData GetReflectionCachedData(MemberInfo mi)
{
RemotingCachedData cache = null;
cache = (RemotingCachedData)mi.Cache[CacheObjType.RemotingData];
if (cache == null)
{
if (mi is MethodBase)
cache = new RemotingMethodCachedData(mi);
else
if (mi is Type)
cache = new RemotingTypeCachedData(mi);
else
cache = new RemotingCachedData(mi);
mi.Cache[CacheObjType.RemotingData] = cache;
}
return cache;
}// GetCachedRemotingAttribute
internal ArgMapper(IMethodMessage mm, bool fOut)
{
_mm = mm;
MethodBase mb = (MethodBase)_mm.MethodBase;
_methodCachedData =
InternalRemotingServices.GetReflectionCachedData(mb);
if (fOut)
_map = _methodCachedData.MarshalResponseArgMap;
else
_map = _methodCachedData.MarshalRequestArgMap;
} // ArgMapper
// copies references of non-byref [In, Out] args from the input args to
// the output args array.
internal void CopyNonByrefOutArgsFromOriginalArgs(RemotingMethodCachedData methodCache,
Object[] args,
ref Object[] marshalResponseArgs)
{
int[] map = methodCache.NonRefOutArgMap;
if (map.Length > 0)
{
if (marshalResponseArgs == null)
marshalResponseArgs = new Object[methodCache.Parameters.Length];
foreach (int pos in map)
{
marshalResponseArgs[pos] = args[pos];
}
}
}
} // GetParameterMaps
//
// Helper methods for expanding and contracting argument lists
// when translating from async methods to sync methods and back.
//
internal static Object[] ExpandAsyncBeginArgsToSyncArgs(RemotingMethodCachedData syncMethod,
Object[] asyncBeginArgs)
{
// This is when we have a list of args associated with BeginFoo(), and
// we want a list of args we can use to invoke Foo().
ParameterInfo[] parameters = syncMethod.Parameters;
int syncParamCount = parameters.Length;
int[] inRefArgMap = syncMethod.InRefArgMap;
Object[] args = new Object[syncParamCount];
for (int co = 0; co < inRefArgMap.Length; co++)
{
args[inRefArgMap[co]] = asyncBeginArgs[co];
}
// We also are required to create an instance for any primitive parameters
// that are only out parameters (PrivateProcessMessage requires it).
foreach (int outArg in syncMethod.OutOnlyArgMap)
{
Type type = parameters[outArg].ParameterType.GetElementType();
if (type.IsValueType)
args[outArg] = Activator.CreateInstance(type, true);
}
return args;
} // ExpandAsyncBeginArgsToSyncArgs