public override MethodBase?ResolveMethod(int metadataToken, Type[]?genericTypeArguments, Type[]?genericMethodArguments) { try { MetadataToken tk = new MetadataToken(metadataToken); if (!tk.IsMethodDef && !tk.IsMethodSpec) { if (!tk.IsMemberRef) { throw new ArgumentException(SR.Format(SR.Argument_ResolveMethod, tk, this), nameof(metadataToken)); } unsafe { ConstArray sig = MetadataImport.GetMemberRefProps(tk); if (*(MdSigCallingConvention *)sig.Signature == MdSigCallingConvention.Field) { throw new ArgumentException(SR.Format(SR.Argument_ResolveMethod, tk, this), nameof(metadataToken)); } } } RuntimeTypeHandle[]? typeArgs = null; RuntimeTypeHandle[]? methodArgs = null; if (genericTypeArguments?.Length > 0) { typeArgs = ConvertToTypeHandleArray(genericTypeArguments); } if (genericMethodArguments?.Length > 0) { methodArgs = ConvertToTypeHandleArray(genericMethodArguments); } ModuleHandle moduleHandle = new ModuleHandle(this); IRuntimeMethodInfo methodHandle = moduleHandle.ResolveMethodHandle(tk, typeArgs, methodArgs).GetMethodInfo(); Type declaringType = RuntimeMethodHandle.GetDeclaringType(methodHandle); if (declaringType.IsGenericType || declaringType.IsArray) { MetadataToken tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tk)); if (tk.IsMethodSpec) { tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tkDeclaringType)); } declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments); } return(RuntimeType.GetMethodBase(declaringType as RuntimeType, methodHandle)); } catch (BadImageFormatException e) { throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, e); } }
// this method is a big perf hit, so don't call unnecessarily internal static MethodInfo GetMethodInfo(RuntimeMethodHandle rmh) { if (rmh.IsNullHandle()) { return(null); } #if _DEBUG try { #endif // Assert here because reflection will check grants and if we fail the check, // there will be an infinite recursion that overflows the stack. PermissionSet.s_fullTrust.Assert(); RuntimeTypeHandle rth = rmh.GetDeclaringType(); return(System.RuntimeType.GetMethodBase(rth, rmh) as MethodInfo); #if _DEBUG } catch (Exception) { return(null); } #endif }
internal static MethodInfo GetMethodInfo(RuntimeMethodHandleInternal rmh) { if (rmh.IsNullHandle()) { return((MethodInfo)null); } PermissionSet.s_fullTrust.Assert(); return(RuntimeType.GetMethodBase(RuntimeMethodHandle.GetDeclaringType(rmh), rmh) as MethodInfo); }
[System.Security.SecuritySafeCritical] // auto-generated public override MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) { MetadataToken tk = new MetadataToken(metadataToken); if (!MetadataImport.IsValidToken(tk)) { throw new ArgumentOutOfRangeException("metadataToken", Environment.GetResourceString("Argument_InvalidToken", tk, this)); } RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments); RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments); try { if (!tk.IsMethodDef && !tk.IsMethodSpec) { if (!tk.IsMemberRef) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", tk, this)); } unsafe { ConstArray sig = MetadataImport.GetMemberRefProps(tk); if (*(MdSigCallingConvention *)sig.Signature.ToPointer() == MdSigCallingConvention.Field) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", tk, this)); } } } IRuntimeMethodInfo methodHandle = ModuleHandle.ResolveMethodHandleInternal(GetNativeHandle(), tk, typeArgs, methodArgs); Type declaringType = RuntimeMethodHandle.GetDeclaringType(methodHandle); if (declaringType.IsGenericType || declaringType.IsArray) { MetadataToken tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tk)); if (tk.IsMethodSpec) { tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tkDeclaringType)); } declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments); } return(System.RuntimeType.GetMethodBase(declaringType as RuntimeType, methodHandle)); } catch (BadImageFormatException e) { throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e); } }
internal override int ParentToken(int token) { RuntimeType declaringType = null; object obj2 = this.m_scope[token]; if (obj2 is RuntimeMethodHandle) { declaringType = RuntimeMethodHandle.GetDeclaringType(((RuntimeMethodHandle)obj2).GetMethodInfo()); } else if (obj2 is RuntimeFieldHandle) { declaringType = RuntimeFieldHandle.GetApproxDeclaringType(((RuntimeFieldHandle)obj2).GetRuntimeFieldInfo()); } else if (obj2 is DynamicMethod) { DynamicMethod method = (DynamicMethod)obj2; declaringType = RuntimeMethodHandle.GetDeclaringType(method.m_methodHandle); } else if (obj2 is GenericMethodInfo) { GenericMethodInfo info = (GenericMethodInfo)obj2; declaringType = info.m_context.GetRuntimeType(); } else if (obj2 is GenericFieldInfo) { GenericFieldInfo info2 = (GenericFieldInfo)obj2; declaringType = info2.m_context.GetRuntimeType(); } else if (obj2 is VarArgMethod) { VarArgMethod method2 = (VarArgMethod)obj2; DynamicMethod dynamicMethod = method2.m_dynamicMethod; if (dynamicMethod != null) { dynamicMethod.GetMethodDescriptor(); declaringType = RuntimeMethodHandle.GetDeclaringType(dynamicMethod.m_methodHandle); } else { RuntimeMethodInfo info3 = method2.m_method; if (info3.DeclaringType == null) { declaringType = RuntimeMethodHandle.GetDeclaringType(info3); } else { declaringType = info3.DeclaringType.TypeHandle.GetRuntimeType(); } } } if (declaringType == null) { return(-1); } return(this.m_scope.GetTokenFor(declaringType.GetTypeHandleInternal())); }
public unsafe override MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) { MetadataToken metadataToken2 = new MetadataToken(metadataToken); if (!this.MetadataImport.IsValidToken(metadataToken2)) { throw new ArgumentOutOfRangeException("metadataToken", Environment.GetResourceString("Argument_InvalidToken", new object[] { metadataToken2, this })); } RuntimeTypeHandle[] typeInstantiationContext = RuntimeModule.ConvertToTypeHandleArray(genericTypeArguments); RuntimeTypeHandle[] methodInstantiationContext = RuntimeModule.ConvertToTypeHandleArray(genericMethodArguments); MethodBase methodBase; try { if (!metadataToken2.IsMethodDef && !metadataToken2.IsMethodSpec) { if (!metadataToken2.IsMemberRef) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", new object[] { metadataToken2, this })); } if (*(byte *)this.MetadataImport.GetMemberRefProps(metadataToken2).Signature.ToPointer() == 6) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", new object[] { metadataToken2, this })); } } IRuntimeMethodInfo runtimeMethodInfo = ModuleHandle.ResolveMethodHandleInternal(this.GetNativeHandle(), metadataToken2, typeInstantiationContext, methodInstantiationContext); Type type = RuntimeMethodHandle.GetDeclaringType(runtimeMethodInfo); if (type.IsGenericType || type.IsArray) { MetadataToken token = new MetadataToken(this.MetadataImport.GetParentToken(metadataToken2)); if (metadataToken2.IsMethodSpec) { token = new MetadataToken(this.MetadataImport.GetParentToken(token)); } type = this.ResolveType(token, genericTypeArguments, genericMethodArguments); } methodBase = RuntimeType.GetMethodBase(type as RuntimeType, runtimeMethodInfo); } catch (BadImageFormatException innerException) { throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), innerException); } return(methodBase); }
internal static unsafe ParameterInfo[] GetParameters(MethodBase method, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter) { RuntimeMethodHandle methodHandle = method.GetMethodHandle(); returnParameter = null; int length = sig.Arguments.Length; ParameterInfo[] infoArray = fetchReturnParameter ? null : new ParameterInfo[length]; int methodDef = methodHandle.GetMethodDef(); int count = 0; if (!System.Reflection.MetadataToken.IsNullToken(methodDef)) { MetadataImport metadataImport = methodHandle.GetDeclaringType().GetModuleHandle().GetMetadataImport(); count = metadataImport.EnumParamsCount(methodDef); int *result = stackalloc int[count]; metadataImport.EnumParams(methodDef, result, count); for (uint i = 0; i < count; i++) { ParameterAttributes attributes; int num5; int parameterToken = result[(int)((int *)i)]; metadataImport.GetParamDefProps(parameterToken, out num5, out attributes); num5--; if (fetchReturnParameter && (num5 == -1)) { returnParameter = new ParameterInfo(sig, metadataImport, parameterToken, num5, attributes, member); } else if (!fetchReturnParameter && (num5 >= 0)) { infoArray[num5] = new ParameterInfo(sig, metadataImport, parameterToken, num5, attributes, member); } } } if (fetchReturnParameter) { if (returnParameter == null) { returnParameter = new ParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member); } return(infoArray); } if (count < (infoArray.Length + 1)) { for (int j = 0; j < infoArray.Length; j++) { if (infoArray[j] == null) { infoArray[j] = new ParameterInfo(sig, MetadataImport.EmptyImport, 0, j, ParameterAttributes.None, member); } } } return(infoArray); }
internal override unsafe int ParentToken(int token) { RuntimeTypeHandle owner = RuntimeTypeHandle.EmptyHandle; Object handle = m_scope[token]; if (handle is RuntimeMethodHandle) { RuntimeMethodHandle method = (RuntimeMethodHandle)handle; owner = method.GetDeclaringType(); } else if (handle is RuntimeFieldHandle) { RuntimeFieldHandle field = (RuntimeFieldHandle)handle; owner = field.GetApproxDeclaringType(); } else if (handle is DynamicMethod) { DynamicMethod dynMeth = (DynamicMethod)handle; owner = dynMeth.m_method.GetDeclaringType(); } else if (handle is GenericMethodInfo) { GenericMethodInfo gmi = (GenericMethodInfo)handle; owner = gmi.m_context; } else if (handle is VarArgMethod) { VarArgMethod varargMeth = (VarArgMethod)handle; if (varargMeth.m_method is DynamicMethod) { owner = ((DynamicMethod)varargMeth.m_method).m_method.GetDeclaringType(); } else if (varargMeth.m_method is DynamicMethod.RTDynamicMethod) { owner = ((DynamicMethod.RTDynamicMethod)varargMeth.m_method).m_owner.m_method.GetDeclaringType(); } else { owner = varargMeth.m_method.MethodHandle.GetDeclaringType(); } } if (owner.IsNullHandle()) { return(-1); } return(m_scope.GetTokenFor(owner)); }
public int GetTokenFor(RuntimeMethodHandle method) { IRuntimeMethodInfo methodInfo = method.GetMethodInfo(); RuntimeMethodHandleInternal internal2 = methodInfo.Value; if ((methodInfo != null) && !RuntimeMethodHandle.IsDynamicMethod(internal2)) { RuntimeType declaringType = RuntimeMethodHandle.GetDeclaringType(internal2); if ((declaringType != null) && RuntimeTypeHandle.IsGenericType(declaringType)) { MethodBase methodBase = RuntimeType.GetMethodBase(methodInfo); Type genericTypeDefinition = methodBase.DeclaringType.GetGenericTypeDefinition(); throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_MethodDeclaringTypeGenericLcg"), new object[] { methodBase, genericTypeDefinition })); } } this.m_tokens.Add(method); return((this.m_tokens.Count - 1) | 0x6000000); }
public int GetTokenFor(RuntimeMethodHandle method) { IRuntimeMethodInfo methodInfo = method.GetMethodInfo(); RuntimeMethodHandleInternal value = methodInfo.Value; if (methodInfo != null && !RuntimeMethodHandle.IsDynamicMethod(value)) { RuntimeType declaringType = RuntimeMethodHandle.GetDeclaringType(value); if (declaringType != null && RuntimeTypeHandle.HasInstantiation(declaringType)) { MethodBase methodBase = RuntimeType.GetMethodBase(methodInfo); Type genericTypeDefinition = methodBase.DeclaringType.GetGenericTypeDefinition(); throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_MethodDeclaringTypeGenericLcg"), methodBase, genericTypeDefinition)); } } this.m_tokens.Add(method); return(this.m_tokens.Count - 1 | 100663296); }
public unsafe MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) { MethodBase methodBase; System.Reflection.MetadataToken token = new System.Reflection.MetadataToken(metadataToken); if (!this.MetadataImport.IsValidToken((int)token)) { throw new ArgumentOutOfRangeException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", new object[] { token, this }), new object[0])); } RuntimeTypeHandle[] typeInstantiationContext = ConvertToTypeHandleArray(genericTypeArguments); RuntimeTypeHandle[] methodInstantiationContext = ConvertToTypeHandleArray(genericMethodArguments); try { if (!token.IsMethodDef && !token.IsMethodSpec) { if (!token.IsMemberRef) { throw new ArgumentException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethod", new object[] { token, this }), new object[0])); } if (*(((byte *)this.MetadataImport.GetMemberRefProps((int)token).Signature.ToPointer())) == 6) { throw new ArgumentException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethod"), new object[] { token, this })); } } RuntimeMethodHandle methodHandle = this.GetModuleHandle().ResolveMethodHandle((int)token, typeInstantiationContext, methodInstantiationContext); Type runtimeType = methodHandle.GetDeclaringType().GetRuntimeType(); if (runtimeType.IsGenericType || runtimeType.IsArray) { System.Reflection.MetadataToken token2 = new System.Reflection.MetadataToken(this.MetadataImport.GetParentToken((int)token)); if (token.IsMethodSpec) { token2 = new System.Reflection.MetadataToken(this.MetadataImport.GetParentToken((int)token2)); } runtimeType = this.ResolveType((int)token2, genericTypeArguments, genericMethodArguments); } methodBase = System.RuntimeType.GetMethodBase(runtimeType.GetTypeHandleInternal(), methodHandle); } catch (BadImageFormatException exception) { throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), exception); } return(methodBase); }
public int GetTokenFor(RuntimeMethodHandle method) { IRuntimeMethodInfo methodReal = method.GetMethodInfo(); RuntimeMethodHandleInternal rmhi = methodReal.Value; if (methodReal != null && !RuntimeMethodHandle.IsDynamicMethod(rmhi)) { RuntimeType type = RuntimeMethodHandle.GetDeclaringType(rmhi); if ((type != null) && RuntimeTypeHandle.HasInstantiation(type)) { // Do we really need to retrieve this much info just to throw an exception? MethodBase m = RuntimeType.GetMethodBase(methodReal); Type t = m.DeclaringType.GetGenericTypeDefinition(); throw new ArgumentException(SR.Format(SR.Argument_MethodDeclaringTypeGenericLcg, m, t)); } } m_tokens.Add(method); return(m_tokens.Count - 1 | (int)MetadataTokenType.MethodDef); }
public override unsafe MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) { System.Reflection.MetadataToken metadataToken1 = new System.Reflection.MetadataToken(metadataToken); if (!this.MetadataImport.IsValidToken((int)metadataToken1)) { throw new ArgumentOutOfRangeException("metadataToken", Environment.GetResourceString("Argument_InvalidToken", (object)metadataToken1, (object)this)); } RuntimeTypeHandle[] typeHandleArray1 = RuntimeModule.ConvertToTypeHandleArray(genericTypeArguments); RuntimeTypeHandle[] typeHandleArray2 = RuntimeModule.ConvertToTypeHandleArray(genericMethodArguments); try { if (!metadataToken1.IsMethodDef && !metadataToken1.IsMethodSpec) { if (!metadataToken1.IsMemberRef) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", (object)metadataToken1, (object)this)); } if ((int)*(byte *)this.MetadataImport.GetMemberRefProps((int)metadataToken1).Signature.ToPointer() == 6) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMethod", (object)metadataToken1, (object)this)); } } IRuntimeMethodInfo runtimeMethodInfo = ModuleHandle.ResolveMethodHandleInternal(this.GetNativeHandle(), (int)metadataToken1, typeHandleArray1, typeHandleArray2); Type type = (Type)RuntimeMethodHandle.GetDeclaringType(runtimeMethodInfo); if (type.IsGenericType || type.IsArray) { System.Reflection.MetadataToken metadataToken2 = new System.Reflection.MetadataToken(this.MetadataImport.GetParentToken((int)metadataToken1)); if (metadataToken1.IsMethodSpec) { metadataToken2 = new System.Reflection.MetadataToken(this.MetadataImport.GetParentToken((int)metadataToken2)); } type = this.ResolveType((int)metadataToken2, genericTypeArguments, genericMethodArguments); } return(RuntimeType.GetMethodBase(type as RuntimeType, runtimeMethodInfo)); } catch (BadImageFormatException ex) { throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), (Exception)ex); } }
internal static ParameterInfo[] GetParameters(IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter) { returnParameter = (ParameterInfo)null; int length = sig.Arguments.Length; ParameterInfo[] parameterInfoArray = fetchReturnParameter ? (ParameterInfo[])null : new ParameterInfo[length]; int methodDef = RuntimeMethodHandle.GetMethodDef(methodHandle); int num1 = 0; if (!System.Reflection.MetadataToken.IsNullToken(methodDef)) { MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle)); MetadataEnumResult result; metadataImport.EnumParams(methodDef, out result); num1 = result.Length; if (num1 > length + 1) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } for (int index = 0; index < num1; ++index) { int num2 = result[index]; int sequence; ParameterAttributes attributes; metadataImport.GetParamDefProps(num2, out sequence, out attributes); --sequence; if (fetchReturnParameter && sequence == -1) { if (returnParameter != null) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } returnParameter = (ParameterInfo) new RuntimeParameterInfo(sig, metadataImport, num2, sequence, attributes, member); } else if (!fetchReturnParameter && sequence >= 0) { if (sequence >= length) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } parameterInfoArray[sequence] = (ParameterInfo) new RuntimeParameterInfo(sig, metadataImport, num2, sequence, attributes, member); } } } if (fetchReturnParameter) { if (returnParameter == null) { returnParameter = (ParameterInfo) new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member); } } else if (num1 < parameterInfoArray.Length + 1) { for (int position = 0; position < parameterInfoArray.Length; ++position) { if (parameterInfoArray[position] == null) { parameterInfoArray[position] = (ParameterInfo) new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, position, ParameterAttributes.None, member); } } } return(parameterInfoArray); }
[System.Security.SecurityCritical] // auto-generated internal unsafe static ParameterInfo[] GetParameters( IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter) { returnParameter = null; int sigArgCount = sig.Arguments.Length; ParameterInfo[] args = fetchReturnParameter ? null : new ParameterInfo[sigArgCount]; int tkMethodDef = RuntimeMethodHandle.GetMethodDef(methodHandle); int cParamDefs = 0; // Not all methods have tokens. Arrays, pointers and byRef types do not have tokens as they // are generated on the fly by the runtime. if (!MdToken.IsNullToken(tkMethodDef)) { MetadataImport scope = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle)); MetadataEnumResult tkParamDefs; scope.EnumParams(tkMethodDef, out tkParamDefs); cParamDefs = tkParamDefs.Length; // Not all parameters have tokens. Parameters may have no token // if they have no name and no attributes. if (cParamDefs > sigArgCount + 1 /* return type */) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } for (int i = 0; i < cParamDefs; i++) { #region Populate ParameterInfos ParameterAttributes attr; int position, tkParamDef = tkParamDefs[i]; scope.GetParamDefProps(tkParamDef, out position, out attr); position--; if (fetchReturnParameter == true && position == -1) { // more than one return parameter? if (returnParameter != null) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } returnParameter = new RuntimeParameterInfo(sig, scope, tkParamDef, position, attr, member); } else if (fetchReturnParameter == false && position >= 0) { // position beyong sigArgCount? if (position >= sigArgCount) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } args[position] = new RuntimeParameterInfo(sig, scope, tkParamDef, position, attr, member); } #endregion } } // Fill in empty ParameterInfos for those without tokens if (fetchReturnParameter) { if (returnParameter == null) { returnParameter = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, (ParameterAttributes)0, member); } } else { if (cParamDefs < args.Length + 1) { for (int i = 0; i < args.Length; i++) { if (args[i] != null) { continue; } args[i] = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, i, (ParameterAttributes)0, member); } } } return(args); }
internal static unsafe ParameterInfo[] GetParameters(IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter) { returnParameter = null; int length = sig.Arguments.Length; ParameterInfo[] infoArray = fetchReturnParameter ? null : new ParameterInfo[length]; int methodDef = RuntimeMethodHandle.GetMethodDef(methodHandle); int count = 0; if (!System.Reflection.MetadataToken.IsNullToken(methodDef)) { MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle)); count = metadataImport.EnumParamsCount(methodDef); int *result = (int *)stackalloc byte[(((IntPtr)count) * 4)]; metadataImport.EnumParams(methodDef, result, count); if (count > (length + 1)) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } for (uint i = 0; i < count; i++) { ParameterAttributes attributes; int num5; int parameterToken = result[(int)((int *)i)]; metadataImport.GetParamDefProps(parameterToken, out num5, out attributes); num5--; if (fetchReturnParameter && (num5 == -1)) { if (returnParameter != null) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } returnParameter = new RuntimeParameterInfo(sig, metadataImport, parameterToken, num5, attributes, member); } else if (!fetchReturnParameter && (num5 >= 0)) { if (num5 >= length) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } infoArray[num5] = new RuntimeParameterInfo(sig, metadataImport, parameterToken, num5, attributes, member); } } } if (fetchReturnParameter) { if (returnParameter == null) { returnParameter = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member); } return(infoArray); } if (count < (infoArray.Length + 1)) { for (int j = 0; j < infoArray.Length; j++) { if (infoArray[j] == null) { infoArray[j] = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, j, ParameterAttributes.None, member); } } } return(infoArray); }
internal static ParameterInfo[] GetParameters(IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter) { returnParameter = null; int num = sig.Arguments.Length; ParameterInfo[] array = fetchReturnParameter ? null : new ParameterInfo[num]; int methodDef = RuntimeMethodHandle.GetMethodDef(methodHandle); int num2 = 0; if (!System.Reflection.MetadataToken.IsNullToken(methodDef)) { MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle)); MetadataEnumResult metadataEnumResult; metadataImport.EnumParams(methodDef, out metadataEnumResult); num2 = metadataEnumResult.Length; if (num2 > num + 1) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } for (int i = 0; i < num2; i++) { int num3 = metadataEnumResult[i]; int num4; ParameterAttributes attributes; metadataImport.GetParamDefProps(num3, out num4, out attributes); num4--; if (fetchReturnParameter && num4 == -1) { if (returnParameter != null) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } returnParameter = new RuntimeParameterInfo(sig, metadataImport, num3, num4, attributes, member); } else if (!fetchReturnParameter && num4 >= 0) { if (num4 >= num) { throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ParameterSignatureMismatch")); } array[num4] = new RuntimeParameterInfo(sig, metadataImport, num3, num4, attributes, member); } } } if (fetchReturnParameter) { if (returnParameter == null) { returnParameter = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member); } } else if (num2 < array.Length + 1) { for (int j = 0; j < array.Length; j++) { if (array[j] == null) { array[j] = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, j, ParameterAttributes.None, member); } } } return(array); }