public CompositionException(IMethodCallMessage Message, string message, System.Exception innerException) : this(String.Format("Exception:{0}\r\nAssembly:{1}\r\n{2}:{3}\r\nArgs:\r\n", message, Message.TypeName, Message.MethodBase.MemberType, Message.MethodName), innerException)
{
for (int i = 0; i < Message.ArgCount; i += 2)
{
_message = String.Format("{0}\t{1}={2}\r\n", _message, Message.GetArgName(i), Message.GetArg(i).ToString());
}
}
private bool MethodEnterLog(IMethodCallMessage callMsg)
{
// reflection을 통해 Log 특성이 메쏘드에 존재하는지 확인한다.
MethodBase method = callMsg.MethodBase;
object[] attributes = method.GetCustomAttributes(typeof(LogAttribute), false);
if (attributes == null || attributes.Length == 0)
{
return(false); // Log 특성이 없다면 아무런 작업도 하지 않는다.
}
StringBuilder sb = new StringBuilder(128);
if (callMsg is IConstructionCallMessage)
{
sb.Append(".ctor(");
}
else
{
sb.AppendFormat("{0} {1}(",
((MethodInfo)method).ReturnType.Name, method.Name);
}
for (int i = 0; i < callMsg.ArgCount; i++)
{
sb.AppendFormat("{0}={1}",
callMsg.GetArgName(i), callMsg.GetArg(i));
if (i < callMsg.ArgCount - 1)
{
sb.Append(',');
}
}
sb.Append(')');
Console.WriteLine(sb.ToString(), "SM");
return(true);
}
private string MethodCallMessageToString(IMethodCallMessage msg)
{
if (msg != null)
{
StringBuilder mDescription = new StringBuilder();
if (msg.MethodName != null)
{
mDescription.AppendFormat("Method = {0}(", msg.MethodName);
}
for (int ix = 0; ix < msg.ArgCount; ix++)
{
mDescription.AppendFormat(" {0}=", msg.GetArgName(ix));
string val = "null";
if (msg.GetArg(ix) != null)
{
val = msg.GetArg(ix).ToString();
}
mDescription.AppendFormat(" {0} ;", val);
}
mDescription.Append(")");
return(mDescription.ToString());
}
else
{
return("Null message");
}
}
public override IMessage Invoke(IMessage request)
{
IMethodCallMessage call = (IMethodCallMessage)request;
Console.WriteLine("Invoke " + call.MethodName);
Console.Write("ARGS(");
for (int i = 0; i < call.ArgCount; i++)
{
if (i != 0)
{
Console.Write(", ");
}
Console.Write(call.GetArgName(i) + " " +
call.GetArg(i));
}
Console.WriteLine(")");
Console.Write("INARGS(");
for (int i = 0; i < call.InArgCount; i++)
{
if (i != 0)
{
Console.Write(", ");
}
Console.Write(call.GetInArgName(i) + " " +
call.GetInArg(i));
}
Console.WriteLine(")");
((R1)target).test_field = 1;
IMethodReturnMessage res = RemotingServices.ExecuteMessage(target, call);
Console.Write("RESARGS(");
for (int i = 0; i < res.ArgCount; i++)
{
if (i != 0)
{
Console.Write(", ");
}
Console.Write(res.GetArgName(i) + " " +
res.GetArg(i));
}
Console.WriteLine(")");
Console.Write("RESOUTARGS(");
for (int i = 0; i < res.OutArgCount; i++)
{
if (i != 0)
{
Console.Write(", ");
}
Console.Write(res.GetOutArgName(i) + " " +
res.GetOutArg(i));
}
Console.WriteLine(")");
return(res);
}
public CompositionException(IMethodCallMessage Message,string message, System.Exception innerException):this(String.Format("Exception:{0}\r\nAssembly:{1}\r\n{2}:{3}\r\nArgs:\r\n",message,Message.TypeName,Message.MethodBase.MemberType,Message.MethodName),innerException)
{
for(int i=0; i<Message.ArgCount; i+=2)
{
_message = String.Format("{0}\t{1}={2}\r\n",_message,Message.GetArgName(i),Message.GetArg(i).ToString());
}
}
internal virtual string[] GetNames(IMethodCallMessage m, int c)
{
string[] strArray = new string[c];
for (int index = 0; index < c; ++index)
{
string str = m.GetArgName(index) ?? "__param" + (object)index;
strArray[index] = str;
}
return(strArray);
}
protected virtual IDictionary <string, object> BuildParameters(IMethodCallMessage methodMessage)
{
var parameters = new Dictionary <string, object>();
for (var i = 0; i < methodMessage.ArgCount; i++)
{
parameters.Add(methodMessage.GetArgName(i), methodMessage.GetArg(i));
}
return(parameters);
}
internal virtual string[] GetNames(IMethodCallMessage m, int c)
{
string[] array = new string[c];
for (int i = 0; i < c; i++)
{
string text = m.GetArgName(i);
if (text == null)
{
text = "__param" + i;
}
array[i] = text;
}
return(array);
}
internal virtual String[] GetNames(IMethodCallMessage m, int c)
{
String[] names = new String[c];
for (int i = 0; i < c; i++)
{
String name = m.GetArgName(i);
if (name == null)
{
name = "__param" + i;
}
names[i] = name;
}
return(names);
}
internal virtual string[] GetNames(IMethodCallMessage m, int c)
{
string[] strArray = new string[c];
for (int i = 0; i < c; i++)
{
string argName = m.GetArgName(i);
if (argName == null)
{
argName = "__param" + i;
}
strArray[i] = argName;
}
return(strArray);
}
internal virtual string[] GetNames(IMethodCallMessage m, int c)
{
string[] strArray = new string[c];
for (int i = 0; i < c; i++)
{
string argName = m.GetArgName(i);
if (argName == null)
{
argName = "__param" + i;
}
strArray[i] = argName;
}
return strArray;
}
public IMessage SyncProcessMessage(IMessage msg)
{
IMessage returnMsg = nextSink.SyncProcessMessage(msg);
if (IsWriteLog == null)
{
return(returnMsg);
}
if (IsWriteLog.ToLower() == "true")//默认是不记录日志，只有配置文件配置了true，则记录日志
{
IMethodCallMessage call = msg as IMethodCallMessage;
//TrueLore.Bidding.Utility.ProjectInfo projectInfo = new Bidding.Utility.ProjectInfo();//V3版本数据库记录日志才用到，现在改用Log4Net记录日志，用不上了
String strTypeName = call.TypeName.Split(',')[1]; //程序集名
String strClassName = call.TypeName.Split(',')[0]; //类型名
String strMethodName = call.MethodName; //方法名
object[] args = call.Args; //方法参数
String[] argNames = new String[args.Length]; //方法参数名
for (int i = 0; i < args.Length; i++)
{
argNames[i] = call.GetArgName(i);
if (args[i] == null)
{
continue;
}
}
IMethodReturnMessage returnMessage = returnMsg as System.Runtime.Remoting.Messaging.IMethodReturnMessage;
if (returnMessage.Exception != null)
{
this.WriteLog(strTypeName, strClassName, strMethodName, argNames, args, returnMessage.Exception);
//this.InsertInvokeLog(projectInfo,strBidProjId, strTypeName, strClassName, strMethodName, argNames, args, returnMessage.Exception.Message);
}
else
{
this.WriteLog(strTypeName, strClassName, strMethodName, argNames, args);
//this.InsertInvokeLog(projectInfo,strBidProjId, strTypeName, strClassName, strMethodName, argNames, args);
}
}
return(returnMsg);
}
private IMessage HandleRequestWithParameters(IMethodCallMessage methodCall, ParsedMethodInfo pmi)
{
var deliveredArguments = new string[methodCall.InArgCount];
for (var i = 0; i < deliveredArguments.Length; ++i)
{
deliveredArguments[i] = methodCall.GetArgName(i);
}
var arguments = new object[pmi.ArgumentsOrder.Length];
for (var i = 0; i < arguments.Length; ++i)
{
var arg = pmi.ArgumentsOrder[i];
var index = Array.FindIndex(deliveredArguments, expectedArgPosition => expectedArgPosition == arg);
if (index >= 0)
{
arguments[i] = methodCall.GetInArg(index);
}
else
{
arguments[i] = null;
}
}
Action <object> callback = FindCallbackMethod(methodCall, pmi.CallbackArgumentName);
if (callback == null)
{
throw new SystemException("No callback reference found!");
}
var fullRequest = string.Format(pmi.RequestUrl, arguments);
_context.StartCoroutine(DownloadDataCoroutine(callback, pmi.ReturnType, fullRequest));
return(new ReturnMessage(null, null, 0, methodCall.LogicalCallContext, methodCall));
}
protected override IMessage Invoke(IMethodCallMessage mcall)
{
Marshaler marshaler = new Marshaler(site, NativeMarshalingConfiguration.Configuration);
foreach (Type type in proxiedType.Assembly.GetTypes())
{
marshaler.DefineCustomType(type.Name, type);
}
if (mcall.MethodBase == getHandleMethod)
{
return(GetHandle(mcall));
}
if (mcall.MethodBase == setHandleMethod)
{
return(SetHandle(mcall));
}
Initialize();
RpcStub stub;
if (!stubs.TryGetValue(mcall.MethodBase, out stub))
{
throw new InvalidOperationException(String.Format("cannot find stub for method '{0}'", mcall.MethodBase));
}
// marshal parameters
int n = stub.parameters.Length;
int actualsOffs = handleImplicit ? 1 : 0;
object[] actuals = new object[n + actualsOffs];
if (handleImplicit)
{
if (handle == null)
{
marshaler.TestAssumeFail(
"handle undefined for rpc interface '{0}' with implicit handle passing",
proxiedType);
}
IntPtr ptr = Marshal.StringToHGlobalUni(handle);
marshaler.MarkMemoryForDispose(ptr);
actuals[0] = ptr;
}
marshaler.EnterContext();
for (int i = 0; i < n; i++)
{
if (!stub.parameters[i].IsOut)
{
marshaler.DefineSymbol(mcall.GetArgName(i), mcall.Args[i]);
}
}
ParameterInfo[] parameterInfos = mcall.MethodBase.GetParameters();
for (int pass = 0; pass < 2; pass++)
{
for (int i = 0; i < n; i++)
{
if (pass == 0 && stub.parameters[i].HasDynamicExpression)
{
continue;
}
if (pass == 1 &&
!stub.parameters[i].HasDynamicExpression)
{
continue;
}
stub.parameters[i].AllocateMemoryRegion(marshaler, mcall.Args[i]);
RpcParameter rp = stub.parameters[i];
if (rp.marshallingRegion != null)
{
rp.marshallingRegion.TryReset();
}
if (!rp.IsOut &&
mcall.Args[i] != null)
{
object value = mcall.Args[i];
// Validate the value of the parameter.
if (this.needAutoValidate)
{
CheckParameter(parameterInfos[i], value, mcall, marshaler.SymbolStore);
}
marshaler.MarshalInto(rp.context, rp.marshallingRegion, mcall.Args[i]);
}
else
{
marshaler.EnterRegion(rp.marshallingRegion);
marshaler.Clear(marshaler.GetSize(rp.context, null));
marshaler.ExitRegion();
}
if (!rp.IsByRef)
{
actuals[i + actualsOffs] = rp.Get();
}
else
{
if (mcall.Args[i] == null && !rp.IsOut)
{
actuals[i + actualsOffs] = IntPtr.Zero;
}
else
{
actuals[i + actualsOffs] = rp.marshallingRegion.NativeMemory;
}
}
marshaler.DefineSymbol(mcall.GetArgName(i), actuals[i + actualsOffs]);
}
}
// call
object result;
try
{
result = stub.stubMethod.Invoke(null, actuals);
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
// marshal output parameters
object[] resultArgs = new object[n];
marshaler.IsProbingUnmarshaling = true;
for (int pass = 0; pass < 2; pass++)
{
for (int i = 0; i < n; i++)
{
RpcParameter rp = stub.parameters[i];
if (rp.marshallingRegion != null)
{
rp.marshallingRegion.TryReset();
}
if (rp.IsByRef)
{
object res = resultArgs[i] =
marshaler.UnmarshalFrom(rp.context, rp.marshallingRegion);
if (marshaler.IsProbingUnmarshaling == false)
{
RpcAdapterValidate(res, rp.context.Attributes, marshaler.SymbolStore);
if (rp.IsOut && marshaler.GetNativeType(rp.context) == typeof(IntPtr))
{
foreach (IntPtr ptr in marshaler.ForeignMemory)
{
if (ptr != IntPtr.Zero && rpcFreeMethod != null)
{
rpcFreeMethod.Invoke(null, new object[] { ptr });
}
}
}
}
marshaler.ForeignMemory.Clear();
if (!rp.IsByRef)
{
marshaler.DefineSymbol(mcall.GetArgName(i), rp.Get());
}
else
{
marshaler.DefineSymbol(mcall.GetArgName(i),
rp.marshallingRegion.NativeMemory);
}
}
else
{
resultArgs[i] = mcall.Args[i];
}
}
marshaler.IsProbingUnmarshaling = false;
}
if (stub.returnParameter.nativeType != typeof(void))
{
stub.returnParameter.AllocateMemoryRegion(marshaler, result);
stub.returnParameter.marshallingRegion.TryReset();
stub.returnParameter.Set(result);
result = marshaler.UnmarshalFrom(
stub.returnParameter.context,
stub.returnParameter.marshallingRegion);
RpcAdapterValidate(result, null, null);
}
marshaler.ExitContext();
marshaler.FreeMemory();
marshaler.Dispose();
marshaler = null;
CheckOperation(mcall);
ReturnMessage mret = new ReturnMessage(result, resultArgs, resultArgs.Length, mcall.LogicalCallContext, mcall);
return(mret);
}
public string GetArgName(int index)
{
return(orig.GetArgName(index));
}
protected override IMessage Invoke(IMethodCallMessage mcall)
{
Marshaler marshaler = new Marshaler(site, NativeMarshalingConfiguration.Configuration);
foreach (Type type in proxiedType.Assembly.GetTypes())
{
marshaler.DefineCustomType(type.Name, type);
}
if (mcall.MethodBase == getHandleMethod)
return GetHandle(mcall);
if (mcall.MethodBase == setHandleMethod)
return SetHandle(mcall);
Initialize();
RpcStub stub;
if (!stubs.TryGetValue(mcall.MethodBase, out stub))
throw new InvalidOperationException(String.Format("cannot find stub for method '{0}'", mcall.MethodBase));
// marshal parameters
int n = stub.parameters.Length;
int actualsOffs = handleImplicit ? 1 : 0;
object[] actuals = new object[n + actualsOffs];
if (handleImplicit)
{
if (handle == null)
marshaler.TestAssumeFail(
"handle undefined for rpc interface '{0}' with implicit handle passing",
proxiedType);
IntPtr ptr = Marshal.StringToHGlobalUni(handle);
marshaler.MarkMemoryForDispose(ptr);
actuals[0] = ptr;
}
marshaler.EnterContext();
for (int i = 0; i < n; i++)
{
if (!stub.parameters[i].IsOut)
{
marshaler.DefineSymbol(mcall.GetArgName(i), mcall.Args[i]);
}
}
ParameterInfo[] parameterInfos = mcall.MethodBase.GetParameters();
for (int pass = 0; pass < 2; pass++)
{
for (int i = 0; i < n; i++)
{
if (pass == 0 && stub.parameters[i].HasDynamicExpression)
{
continue;
}
if (pass == 1
&& !stub.parameters[i].HasDynamicExpression)
{
continue;
}
stub.parameters[i].AllocateMemoryRegion(marshaler, mcall.Args[i]);
RpcParameter rp = stub.parameters[i];
if (rp.marshallingRegion != null)
rp.marshallingRegion.TryReset();
if (!rp.IsOut
&& mcall.Args[i] != null)
{
object value = mcall.Args[i];
// Validate the value of the parameter.
if (this.needAutoValidate)
CheckParameter(parameterInfos[i], value, mcall, marshaler.SymbolStore);
marshaler.MarshalInto(rp.context, rp.marshallingRegion, mcall.Args[i]);
}
else
{
marshaler.EnterRegion(rp.marshallingRegion);
marshaler.Clear(marshaler.GetSize(rp.context, null));
marshaler.ExitRegion();
}
if (!rp.IsByRef)
{
actuals[i + actualsOffs] = rp.Get();
}
else
{
if (mcall.Args[i] == null && !rp.IsOut)
{
actuals[i + actualsOffs] = IntPtr.Zero;
}
else
{
actuals[i + actualsOffs] = rp.marshallingRegion.NativeMemory;
}
}
marshaler.DefineSymbol(mcall.GetArgName(i), actuals[i + actualsOffs]);
}
}
// call
object result;
try
{
result = stub.stubMethod.Invoke(null, actuals);
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
// marshal output parameters
object[] resultArgs = new object[n];
marshaler.IsProbingUnmarshaling = true;
for (int pass = 0; pass < 2; pass++)
{
for (int i = 0; i < n; i++)
{
RpcParameter rp = stub.parameters[i];
if (rp.marshallingRegion != null)
rp.marshallingRegion.TryReset();
if (rp.IsByRef)
{
object res = resultArgs[i] =
marshaler.UnmarshalFrom(rp.context, rp.marshallingRegion);
if (marshaler.IsProbingUnmarshaling == false)
{
RpcAdapterValidate(res, rp.context.Attributes, marshaler.SymbolStore);
if (rp.IsOut && marshaler.GetNativeType(rp.context) == typeof(IntPtr))
{
foreach (IntPtr ptr in marshaler.ForeignMemory)
{
if (ptr != IntPtr.Zero && rpcFreeMethod != null)
{
rpcFreeMethod.Invoke(null, new object[] { ptr });
}
}
}
}
marshaler.ForeignMemory.Clear();
if (!rp.IsByRef)
{
marshaler.DefineSymbol(mcall.GetArgName(i), rp.Get());
}
else
{
marshaler.DefineSymbol(mcall.GetArgName(i),
rp.marshallingRegion.NativeMemory);
}
}
else
{
resultArgs[i] = mcall.Args[i];
}
}
marshaler.IsProbingUnmarshaling = false;
}
if (stub.returnParameter.nativeType != typeof(void))
{
stub.returnParameter.AllocateMemoryRegion(marshaler, result);
stub.returnParameter.marshallingRegion.TryReset();
stub.returnParameter.Set(result);
result = marshaler.UnmarshalFrom(
stub.returnParameter.context,
stub.returnParameter.marshallingRegion);
RpcAdapterValidate(result, null, null);
}
marshaler.ExitContext();
marshaler.FreeMemory();
marshaler.Dispose();
marshaler = null;
CheckOperation(mcall);
ReturnMessage mret = new ReturnMessage(result, resultArgs, resultArgs.Length, mcall.LogicalCallContext, mcall);
return mret;
}
public override IMessage Invoke(IMessage myIMessage)
{
Console.WriteLine("**********************************************************************************");
IDictionary myIDictionary = myIMessage.Properties;
// Set the '__Uri' property of 'IMessage' to 'URI' property of 'ObjRef'.
myIDictionary["__Uri"] = stringUri;
IDictionaryEnumerator myIDictionaryEnumerator = (IDictionaryEnumerator)myIDictionary.GetEnumerator();
while (myIDictionaryEnumerator.MoveNext())
{
Object myKey = myIDictionaryEnumerator.Key;
String myKeyName = myKey.ToString();
Object myValue = myIDictionaryEnumerator.Value;
Console.WriteLine("\t{0} : {1}", myKeyName, myIDictionaryEnumerator.Value);
if (myKeyName == "__Args")
{
Object[] objs = (Object[])myValue;
for (int aIndex = 0; aIndex < objs.Length; aIndex++)
{
Console.WriteLine("\t\targ: {0} myValue: {1}", aIndex, objs[aIndex]);
}
}
if ((myKeyName == "__MethodSignature") && (null != myValue))
{
Object[] objs = (Object[])myValue;
for (int aIndex = 0; aIndex < objs.Length; aIndex++)
{
Console.WriteLine("\t\targ: {0} myValue: {1}", aIndex, objs[aIndex]);
}
}
}
Console.WriteLine("**********************************************************************************");
Console.WriteLine("ChannelServices.SyncDispatchMessage");
IMessage myReturnMessage = ChannelServices.SyncDispatchMessage(myIMessage);
// Push return value and OUT parameters back onto stack.
IMethodReturnMessage myMethodReturnMessage = (IMethodReturnMessage)myReturnMessage;
Console.WriteLine("IMethodReturnMessage.ReturnValue: {0}", myMethodReturnMessage.ReturnValue);
Console.WriteLine("**********************************************************************************");
IMethodCallMessage myIMethodCallMessage = (IMethodCallMessage)myIMessage;
IMethodReturnMessage myIMethodReturnMessage = RemotingServices.ExecuteMessage(myMarshalByRefObject, myIMethodCallMessage);
Console.WriteLine("Method name : " + myIMethodReturnMessage.MethodName);
Console.WriteLine("The return value is : " + myIMethodReturnMessage.ReturnValue);
Console.WriteLine("**********************************************************************************");
int myArgOutCount = myIMethodReturnMessage.OutArgCount;
Console.WriteLine("The number of 'ref', 'out' parameters are : " + myIMethodReturnMessage.OutArgCount);
// Gets name and values of 'ref' and 'out' parameters.
for (int i = 0; i < myArgOutCount; i++)
{
Console.WriteLine("Name of argument {0} is '{1}'.", i, myIMethodReturnMessage.GetOutArgName(i));
Console.WriteLine("Value of argument {0} is '{1}'.", i, myIMethodReturnMessage.GetOutArg(i));
}
Console.WriteLine();
object[] myObjectArray = myIMethodReturnMessage.OutArgs;
for (int i = 0; i < myObjectArray.Length; i++)
{
Console.WriteLine("Value of argument {0} is '{1}' in OutArgs", i, myObjectArray[i]);
}
Console.WriteLine("**********************************************************************************");
Console.WriteLine("Message is of type 'IMethodCallMessage'.");
Console.WriteLine("InArgCount is : " + myIMethodCallMessage.InArgCount);
foreach (object arg in myIMethodCallMessage.InArgs)
{
Console.WriteLine("InArgs is : " + arg);
}
for (int i = 0; i < myIMethodCallMessage.InArgCount; i++)
{
Console.WriteLine("GetArgName(" + i + ") is : " + myIMethodCallMessage.GetArgName(i));
Console.WriteLine("GetInArg(" + i + ") is : " + myIMethodCallMessage.GetInArg(i));
}
Console.WriteLine("**********************************************************************************");
var message = new ReturnMessage(5, null, 0, null, (IMethodCallMessage)myIMessage);
return(message);
}
[System.Security.SecurityCritical] // auto-generated
internal virtual String[] GetNames(IMethodCallMessage m, int c)
{
String[] names = new String[c];
for (int i = 0; i < c; i++)
{
String name = m.GetArgName(i);
if (name == null)
{
name = "__param" + i;
}
names[i] = name;
}
return names;
}
public override IMessage Invoke(IMessage msg)
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
IMethodCallMessage methodCall = msg as IMethodCallMessage;
if (msg == null)
{
throw new InvalidOperationException("Method call is expected.");
}
if (this.site == null)
{
throw new InvalidOperationException("Calling method on uninitialized ITestSite object.");
}
if (methodCall.MethodName.Contains("CaptureRequirement") &&
(methodCall.InArgCount > 2) &&
(methodCall.InArgs[methodCall.InArgCount - 1] is string) &&
(methodCall.InArgs[methodCall.InArgCount - 2] is int))
{
string protocolDocShortName = null;
if ("protocolDocShortName" == methodCall.GetArgName(methodCall.InArgCount - 3))
{
protocolDocShortName = (string)methodCall.InArgs[methodCall.InArgCount - 3];
}
else
{
protocolDocShortName = this.site.DefaultProtocolDocShortName;
}
string verifyingReqDescription = (string)methodCall.InArgs[methodCall.InArgCount - 1];
int verifyingReqId = (int)methodCall.InArgs[methodCall.InArgCount - 2];
if (CommonUtility.IsRequirementVerificationDisabled(this.site, protocolDocShortName, verifyingReqId))
{
this.site.Log.Add(
LogEntryKind.Debug,
"The requirement ({0}) verification for {1} is disabled.",
verifyingReqId,
protocolDocShortName);
this.site.Log.Add(
LogEntryKind.Debug,
"The requirement description: {0}.",
verifyingReqDescription);
return(new ReturnMessage(
null,
null,
0,
methodCall.LogicalCallContext,
methodCall));
}
}
object retVal = null;
object[] args = methodCall.Args;
retVal = methodCall.MethodBase.Invoke(this.site, args);
return(new ReturnMessage(
retVal,
null,
0,
methodCall.LogicalCallContext,
methodCall));
}
public String GetArgName(int index)
{
return(mcm.GetArgName(index));
}
