[System.Security.SecuritySafeCritical] // auto-generated public override FieldInfo ResolveField(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 { IRuntimeFieldInfo fieldHandle = null; if (!tk.IsFieldDef) { if (!tk.IsMemberRef) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveField", tk, this)); } unsafe { ConstArray sig = MetadataImport.GetMemberRefProps(tk); if (*(MdSigCallingConvention *)sig.Signature.ToPointer() != MdSigCallingConvention.Field) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveField", tk, this)); } } fieldHandle = ModuleHandle.ResolveFieldHandleInternal(GetNativeHandle(), tk, typeArgs, methodArgs); } fieldHandle = ModuleHandle.ResolveFieldHandleInternal(GetNativeHandle(), metadataToken, typeArgs, methodArgs); RuntimeType declaringType = RuntimeFieldHandle.GetApproxDeclaringType(fieldHandle.Value); if (declaringType.IsGenericType || declaringType.IsArray) { int tkDeclaringType = ModuleHandle.GetMetadataImport(GetNativeHandle()).GetParentToken(metadataToken); declaringType = (RuntimeType)ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments); } return(System.RuntimeType.GetFieldInfo(declaringType, fieldHandle)); } catch (MissingFieldException) { return(ResolveLiteralField(tk, genericTypeArguments, genericMethodArguments)); } catch (BadImageFormatException e) { throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e); } }
public unsafe override FieldInfo ResolveField(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); FieldInfo result; try { IRuntimeFieldInfo runtimeFieldInfo; if (!metadataToken2.IsFieldDef) { if (!metadataToken2.IsMemberRef) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveField", new object[] { metadataToken2, this })); } if (*(byte *)this.MetadataImport.GetMemberRefProps(metadataToken2).Signature.ToPointer() != 6) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveField", new object[] { metadataToken2, this })); } runtimeFieldInfo = ModuleHandle.ResolveFieldHandleInternal(this.GetNativeHandle(), metadataToken2, typeInstantiationContext, methodInstantiationContext); } runtimeFieldInfo = ModuleHandle.ResolveFieldHandleInternal(this.GetNativeHandle(), metadataToken, typeInstantiationContext, methodInstantiationContext); RuntimeType runtimeType = RuntimeFieldHandle.GetApproxDeclaringType(runtimeFieldInfo.Value); if (runtimeType.IsGenericType || runtimeType.IsArray) { int parentToken = ModuleHandle.GetMetadataImport(this.GetNativeHandle()).GetParentToken(metadataToken); runtimeType = (RuntimeType)this.ResolveType(parentToken, genericTypeArguments, genericMethodArguments); } result = RuntimeType.GetFieldInfo(runtimeType, runtimeFieldInfo); } catch (MissingFieldException) { result = this.ResolveLiteralField(metadataToken2, genericTypeArguments, genericMethodArguments); } catch (BadImageFormatException innerException) { throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), innerException); } return(result); }
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())); }
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 unsafe FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) { FieldInfo fieldInfo; 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 { RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle(); if (!token.IsFieldDef) { if (!token.IsMemberRef) { throw new ArgumentException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), new object[] { token, this })); } if (*(((byte *)this.MetadataImport.GetMemberRefProps((int)token).Signature.ToPointer())) != 6) { throw new ArgumentException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), new object[] { token, this })); } fieldHandle = this.GetModuleHandle().ResolveFieldHandle((int)token, typeInstantiationContext, methodInstantiationContext); } fieldHandle = this.GetModuleHandle().ResolveFieldHandle(metadataToken, typeInstantiationContext, methodInstantiationContext); Type runtimeType = fieldHandle.GetApproxDeclaringType().GetRuntimeType(); if (runtimeType.IsGenericType || runtimeType.IsArray) { int parentToken = this.GetModuleHandle().GetMetadataImport().GetParentToken(metadataToken); runtimeType = this.ResolveType(parentToken, genericTypeArguments, genericMethodArguments); } fieldInfo = System.RuntimeType.GetFieldInfo(runtimeType.GetTypeHandleInternal(), fieldHandle); } catch (MissingFieldException) { fieldInfo = this.ResolveLiteralField((int)token, genericTypeArguments, genericMethodArguments); } catch (BadImageFormatException exception) { throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), exception); } return(fieldInfo); }
public override unsafe FieldInfo ResolveField(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 { IRuntimeFieldInfo runtimeFieldInfo = (IRuntimeFieldInfo)null; if (!metadataToken1.IsFieldDef) { if (!metadataToken1.IsMemberRef) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveField", (object)metadataToken1, (object)this)); } if ((int)*(byte *)this.MetadataImport.GetMemberRefProps((int)metadataToken1).Signature.ToPointer() != 6) { throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveField", (object)metadataToken1, (object)this)); } runtimeFieldInfo = ModuleHandle.ResolveFieldHandleInternal(this.GetNativeHandle(), (int)metadataToken1, typeHandleArray1, typeHandleArray2); } IRuntimeFieldInfo field = ModuleHandle.ResolveFieldHandleInternal(this.GetNativeHandle(), metadataToken, typeHandleArray1, typeHandleArray2); RuntimeType reflectedType = RuntimeFieldHandle.GetApproxDeclaringType(field.Value); if (reflectedType.IsGenericType || reflectedType.IsArray) { reflectedType = (RuntimeType)this.ResolveType(ModuleHandle.GetMetadataImport(this.GetNativeHandle()).GetParentToken(metadataToken), genericTypeArguments, genericMethodArguments); } return(RuntimeType.GetFieldInfo(reflectedType, field)); } catch (MissingFieldException ex) { return(this.ResolveLiteralField((int)metadataToken1, genericTypeArguments, genericMethodArguments)); } catch (BadImageFormatException ex) { throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), (Exception)ex); } }
[System.Security.SecuritySafeCritical] // auto-generated internal override RuntimeModule GetRuntimeModule() { return(RuntimeTypeHandle.GetModule(RuntimeFieldHandle.GetApproxDeclaringType(this))); }
public override FieldInfo?ResolveField(int metadataToken, Type[]?genericTypeArguments, Type[]?genericMethodArguments) { try { MetadataToken tk = new MetadataToken(metadataToken); if (!MetadataImport.IsValidToken(tk)) { throw new ArgumentOutOfRangeException(nameof(metadataToken), SR.Format(SR.Argument_InvalidToken, tk, this)); } 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); if (!tk.IsFieldDef) { if (!tk.IsMemberRef) { throw new ArgumentException(SR.Format(SR.Argument_ResolveField, tk, this), nameof(metadataToken)); } unsafe { ConstArray sig = MetadataImport.GetMemberRefProps(tk); if (*(MdSigCallingConvention *)sig.Signature != MdSigCallingConvention.Field) { throw new ArgumentException(SR.Format(SR.Argument_ResolveField, tk, this), nameof(metadataToken)); } } } IRuntimeFieldInfo fieldHandle = moduleHandle.ResolveFieldHandle(metadataToken, typeArgs, methodArgs).GetRuntimeFieldInfo(); RuntimeType declaringType = RuntimeFieldHandle.GetApproxDeclaringType(fieldHandle.Value); if (declaringType.IsGenericType || declaringType.IsArray) { int tkDeclaringType = ModuleHandle.GetMetadataImport(this).GetParentToken(metadataToken); declaringType = (RuntimeType)ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments); } return(RuntimeType.GetFieldInfo(declaringType, fieldHandle)); } catch (MissingFieldException) { return(ResolveLiteralField(metadataToken, genericTypeArguments, genericMethodArguments)); } catch (BadImageFormatException e) { throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, e); } }