internal object InvokeMethod(Symbols.Method TargetProcedure, object[] Arguments, bool[] CopyBack, BindingFlags Flags)
{
object obj3;
MethodBase callTarget = NewLateBinding.GetCallTarget(TargetProcedure, Flags);
object[] parameters = NewLateBinding.ConstructCallArguments(TargetProcedure, Arguments, Flags);
if ((this.m_Instance == null) && !Symbols.IsShared(callTarget))
{
throw new NullReferenceException(Utils.GetResourceString("NullReference_InstanceReqToAccessMember1", new string[] { TargetProcedure.ToString() }));
}
if (Symbols.IsNonPublicRuntimeMember(callTarget))
{
throw new MissingMemberException();
}
try
{
obj3 = callTarget.Invoke(this.m_Instance, parameters);
}
catch (TargetInvocationException exception)
{
throw exception.InnerException;
}
OverloadResolution.ReorderArgumentArray(TargetProcedure, parameters, Arguments, CopyBack, Flags);
return(obj3);
}
internal object GetFieldValue(FieldInfo Field)
{
if ((this.m_Instance == null) && !Symbols.IsShared(Field))
{
throw new NullReferenceException(Utils.GetResourceString("NullReference_InstanceReqToAccessMember1", new string[] { Utils.FieldToString(Field) }));
}
if (Symbols.IsNonPublicRuntimeMember(Field))
{
throw new MissingMemberException();
}
return(Field.GetValue(this.m_Instance));
}
internal void SetFieldValue(FieldInfo Field, object Value)
{
if (Field.IsInitOnly)
{
throw new MissingMemberException(Utils.GetResourceString("MissingMember_ReadOnlyField2", new string[] { Field.Name, this.VBFriendlyName }));
}
if ((this.m_Instance == null) && !Symbols.IsShared(Field))
{
throw new NullReferenceException(Utils.GetResourceString("NullReference_InstanceReqToAccessMember1", new string[] { Utils.FieldToString(Field) }));
}
if (Symbols.IsNonPublicRuntimeMember(Field))
{
throw new MissingMemberException();
}
Field.SetValue(this.m_Instance, Conversions.ChangeType(Value, Field.FieldType));
}
internal static string PropertyToString(PropertyInfo Prop)
{
ParameterInfo[] parameters;
Type returnType;
string str2 = "";
PropertyKind readWrite = PropertyKind.ReadWrite;
MethodInfo getMethod = Prop.GetGetMethod();
if (getMethod != null)
{
if (Prop.GetSetMethod() != null)
{
readWrite = PropertyKind.ReadWrite;
}
else
{
readWrite = PropertyKind.ReadOnly;
}
parameters = getMethod.GetParameters();
returnType = getMethod.ReturnType;
}
else
{
readWrite = PropertyKind.WriteOnly;
getMethod = Prop.GetSetMethod();
ParameterInfo[] sourceArray = getMethod.GetParameters();
parameters = new ParameterInfo[(sourceArray.Length - 2) + 1];
Array.Copy(sourceArray, parameters, parameters.Length);
returnType = sourceArray[sourceArray.Length - 1].ParameterType;
}
str2 = str2 + "Public ";
if ((getMethod.Attributes & MethodAttributes.Virtual) != MethodAttributes.ReuseSlot)
{
if (!Prop.DeclaringType.IsInterface)
{
str2 = str2 + "Overrides ";
}
}
else if (Symbols.IsShared(getMethod))
{
str2 = str2 + "Shared ";
}
switch (readWrite)
{
case PropertyKind.ReadOnly:
str2 = str2 + "ReadOnly ";
break;
case PropertyKind.WriteOnly:
str2 = str2 + "WriteOnly ";
break;
}
str2 = str2 + "Property " + Prop.Name + "(";
bool flag = true;
foreach (ParameterInfo info2 in parameters)
{
if (!flag)
{
str2 = str2 + ", ";
}
else
{
flag = false;
}
str2 = str2 + ParameterToString(info2);
}
return(str2 + ") As " + VBFriendlyNameOfType(returnType, true));
}
public static string MethodToString(MethodBase Method)
{
bool flag;
Type typ = null;
string str = "";
if (Method.MemberType == MemberTypes.Method)
{
typ = ((MethodInfo)Method).ReturnType;
}
if (Method.IsPublic)
{
str = str + "Public ";
}
else if (Method.IsPrivate)
{
str = str + "Private ";
}
else if (Method.IsAssembly)
{
str = str + "Friend ";
}
if ((Method.Attributes & MethodAttributes.Virtual) != MethodAttributes.ReuseSlot)
{
if (!Method.DeclaringType.IsInterface)
{
str = str + "Overrides ";
}
}
else if (Symbols.IsShared(Method))
{
str = str + "Shared ";
}
Symbols.UserDefinedOperator uNDEF = Symbols.UserDefinedOperator.UNDEF;
if (Symbols.IsUserDefinedOperator(Method))
{
uNDEF = Symbols.MapToUserDefinedOperator(Method);
}
if (uNDEF != Symbols.UserDefinedOperator.UNDEF)
{
if (uNDEF == Symbols.UserDefinedOperator.Narrow)
{
str = str + "Narrowing ";
}
else if (uNDEF == Symbols.UserDefinedOperator.Widen)
{
str = str + "Widening ";
}
str = str + "Operator ";
}
else if ((typ == null) || (typ == VoidType))
{
str = str + "Sub ";
}
else
{
str = str + "Function ";
}
if (uNDEF != Symbols.UserDefinedOperator.UNDEF)
{
str = str + Symbols.OperatorNames[(int)uNDEF];
}
else if (Method.MemberType == MemberTypes.Constructor)
{
str = str + "New";
}
else
{
str = str + Method.Name;
}
if (Symbols.IsGeneric(Method))
{
str = str + "(Of ";
flag = true;
foreach (Type type2 in Symbols.GetTypeParameters(Method))
{
if (!flag)
{
str = str + ", ";
}
else
{
flag = false;
}
str = str + VBFriendlyNameOfType(type2, false);
}
str = str + ")";
}
str = str + "(";
flag = true;
foreach (ParameterInfo info in Method.GetParameters())
{
if (!flag)
{
str = str + ", ";
}
else
{
flag = false;
}
str = str + ParameterToString(info);
}
str = str + ")";
if ((typ == null) || (typ == VoidType))
{
return(str);
}
return(str + " As " + VBFriendlyNameOfType(typ, true));
}
