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)); }