public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
{
throw new ArgumentNullException(nameof(attributeType));
}
if (MdToken.IsNullToken(m_tkParamDef))
{
return(Array.Empty <object>());
}
RuntimeType?attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
if (attributeRuntimeType == null)
{
throw new ArgumentException(SR.Arg_MustBeType, nameof(attributeType));
}
return(CustomAttribute.GetCustomAttributes(this, attributeRuntimeType));
}
public override bool IsDefined(Type attributeType, bool inherit)
{
if (attributeType == null)
{
throw new ArgumentNullException(nameof(attributeType));
}
if (MdToken.IsNullToken(m_tkParamDef))
{
return(false);
}
RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
if (attributeRuntimeType == null)
{
throw new ArgumentException(SR.Arg_MustBeType, nameof(attributeType));
}
return(CustomAttribute.IsDefined(this, attributeRuntimeType));
}
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);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
public override bool IsDefined(Type attributeType, bool inherit)
{
if (attributeType == null)
{
throw new ArgumentNullException("attributeType");
}
Contract.EndContractBlock();
if (MdToken.IsNullToken(m_tkParamDef))
{
return(false);
}
RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
if (attributeRuntimeType == null)
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
}
return(CustomAttribute.IsDefined(this, attributeRuntimeType));
}
public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
{
throw new ArgumentNullException(nameof(attributeType));
}
Contract.EndContractBlock();
if (MdToken.IsNullToken(m_tkParamDef))
{
return(EmptyArray <Object> .Value);
}
RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
if (attributeRuntimeType == null)
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), nameof(attributeType));
}
return(CustomAttribute.GetCustomAttributes(this, attributeRuntimeType));
}
private RuntimeParameterInfo(RuntimeParameterInfo accessor, MemberInfo member)
{
// Change ownership
MemberImpl = member;
// The original owner should always be a method, because this method is only used to
// change the owner from a method to a property.
m_originalMember = accessor.MemberImpl as MethodBase;
Contract.Assert(m_originalMember != null);
// Populate all the caches -- we inherit this behavior from RTM
NameImpl = accessor.Name;
m_nameIsCached = true;
ClassImpl = accessor.ParameterType;
PositionImpl = accessor.Position;
AttrsImpl = accessor.Attributes;
// Strictly speeking, property's don't contain paramter tokens
// However we need this to make ca's work... oh well...
m_tkParamDef = MdToken.IsNullToken(accessor.MetadataToken) ? (int)MetadataTokenType.ParamDef : accessor.MetadataToken;
m_scope = accessor.m_scope;
}
public override unsafe MemberInfo ResolveMember(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
System.Reflection.MetadataToken metadataToken1 = new System.Reflection.MetadataToken(metadataToken);
if (metadataToken1.IsProperty)
{
throw new ArgumentException(Environment.GetResourceString("InvalidOperation_PropertyInfoNotAvailable"));
}
if (metadataToken1.IsEvent)
{
throw new ArgumentException(Environment.GetResourceString("InvalidOperation_EventInfoNotAvailable"));
}
if (metadataToken1.IsMethodSpec || metadataToken1.IsMethodDef)
{
return((MemberInfo)this.ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments));
}
if (metadataToken1.IsFieldDef)
{
return((MemberInfo)this.ResolveField(metadataToken, genericTypeArguments, genericMethodArguments));
}
if (metadataToken1.IsTypeRef || metadataToken1.IsTypeDef || metadataToken1.IsTypeSpec)
{
return((MemberInfo)this.ResolveType(metadataToken, genericTypeArguments, genericMethodArguments));
}
if (metadataToken1.IsMemberRef)
{
if (!this.MetadataImport.IsValidToken((int)metadataToken1))
{
throw new ArgumentOutOfRangeException("metadataToken", Environment.GetResourceString("Argument_InvalidToken", (object)metadataToken1, (object)this));
}
if ((int)*(byte *)this.MetadataImport.GetMemberRefProps((int)metadataToken1).Signature.ToPointer() == 6)
{
return((MemberInfo)this.ResolveField((int)metadataToken1, genericTypeArguments, genericMethodArguments));
}
return((MemberInfo)this.ResolveMethod((int)metadataToken1, genericTypeArguments, genericMethodArguments));
}
throw new ArgumentException("metadataToken", Environment.GetResourceString("Argument_ResolveMember", (object)metadataToken1, (object)this));
}
public unsafe MemberInfo ResolveMember(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
System.Reflection.MetadataToken token = new System.Reflection.MetadataToken(metadataToken);
if (token.IsProperty)
{
throw new ArgumentException(Environment.GetResourceString("InvalidOperation_PropertyInfoNotAvailable"));
}
if (token.IsEvent)
{
throw new ArgumentException(Environment.GetResourceString("InvalidOperation_EventInfoNotAvailable"));
}
if (token.IsMethodSpec || token.IsMethodDef)
{
return(this.ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments));
}
if (token.IsFieldDef)
{
return(this.ResolveField(metadataToken, genericTypeArguments, genericMethodArguments));
}
if ((token.IsTypeRef || token.IsTypeDef) || token.IsTypeSpec)
{
return(this.ResolveType(metadataToken, genericTypeArguments, genericMethodArguments));
}
if (!token.IsMemberRef)
{
throw new ArgumentException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMember", new object[] { token, this }), new object[0]));
}
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]));
}
if (*(((byte *)this.MetadataImport.GetMemberRefProps((int)token).Signature.ToPointer())) != 6)
{
return(this.ResolveMethod((int)token, genericTypeArguments, genericMethodArguments));
}
return(this.ResolveField((int)token, genericTypeArguments, genericMethodArguments));
}
internal FieldInfo ResolveLiteralField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
FieldInfo field;
System.Reflection.MetadataToken token = new System.Reflection.MetadataToken(metadataToken);
if (!this.MetadataImport.IsValidToken((int)token))
{
throw new ArgumentOutOfRangeException("metadataToken", string.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_InvalidToken", new object[] { token, this }), new object[0]));
}
string name = this.MetadataImport.GetName((int)token).ToString();
int parentToken = this.MetadataImport.GetParentToken((int)token);
Type type = this.ResolveType(parentToken, genericTypeArguments, genericMethodArguments);
type.GetFields();
try
{
field = type.GetField(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly);
}
catch
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), new object[] { token, this }), "metadataToken");
}
return(field);
}
private Object GetDefaultValueInternal(bool raw)
{
Contract.Assert(!m_noMetadata);
if (m_noDefaultValue)
{
return(DBNull.Value);
}
object defaultValue = null;
// Why check the parameter type only for DateTime and only for the ctor arguments?
// No check on the parameter type is done for named args and for Decimal.
// We should move this after MdToken.IsNullToken(m_tkParamDef) and combine it
// with the other custom attribute logic. But will that be a breaking change?
// For a DateTime parameter on which both an md constant and a ca constant are set,
// which one should win?
if (ParameterType == typeof(DateTime))
{
if (raw)
{
CustomAttributeTypedArgument value =
CustomAttributeData.Filter(
CustomAttributeData.GetCustomAttributes(this), typeof(DateTimeConstantAttribute), 0);
if (value.ArgumentType != null)
{
return(new DateTime((long)value.Value));
}
}
else
{
object[] dt = GetCustomAttributes(typeof(DateTimeConstantAttribute), false);
if (dt != null && dt.Length != 0)
{
return(((DateTimeConstantAttribute)dt[0]).Value);
}
}
}
#region Look for a default value in metadata
if (!MdToken.IsNullToken(m_tkParamDef))
{
// This will return DBNull.Value if no constant value is defined on m_tkParamDef in the metadata.
defaultValue = MdConstant.GetValue(m_scope, m_tkParamDef, ParameterType.GetTypeHandleInternal(), raw);
}
#endregion
if (defaultValue == DBNull.Value)
{
#region Look for a default value in the custom attributes
if (raw)
{
foreach (CustomAttributeData attr in CustomAttributeData.GetCustomAttributes(this))
{
Type attrType = attr.Constructor.DeclaringType;
if (attrType == typeof(DateTimeConstantAttribute))
{
defaultValue = DateTimeConstantAttribute.GetRawDateTimeConstant(attr);
}
else if (attrType == typeof(DecimalConstantAttribute))
{
defaultValue = DecimalConstantAttribute.GetRawDecimalConstant(attr);
}
else if (attrType.IsSubclassOf(s_CustomConstantAttributeType))
{
defaultValue = CustomConstantAttribute.GetRawConstant(attr);
}
}
}
else
{
Object[] CustomAttrs = GetCustomAttributes(s_CustomConstantAttributeType, false);
if (CustomAttrs.Length != 0)
{
defaultValue = ((CustomConstantAttribute)CustomAttrs[0]).Value;
}
else
{
CustomAttrs = GetCustomAttributes(s_DecimalConstantAttributeType, false);
if (CustomAttrs.Length != 0)
{
defaultValue = ((DecimalConstantAttribute)CustomAttrs[0]).Value;
}
}
}
#endregion
}
if (defaultValue == DBNull.Value)
{
m_noDefaultValue = true;
}
return(defaultValue);
}
[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);
}
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;
}
internal FieldInfo ResolveLiteralField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
FieldInfo field;
System.Reflection.MetadataToken token = new System.Reflection.MetadataToken(metadataToken);
if (!this.MetadataImport.IsValidToken((int) token))
{
throw new ArgumentOutOfRangeException("metadataToken", string.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_InvalidToken", new object[] { token, this }), new object[0]));
}
string name = this.MetadataImport.GetName((int) token).ToString();
int parentToken = this.MetadataImport.GetParentToken((int) token);
Type type = this.ResolveType(parentToken, genericTypeArguments, genericMethodArguments);
type.GetFields();
try
{
field = type.GetField(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly);
}
catch
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), new object[] { token, this }), "metadataToken");
}
return field;
}
public Type ResolveType(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
Type type2;
System.Reflection.MetadataToken token = new System.Reflection.MetadataToken(metadataToken);
if (token.IsGlobalTypeDefToken)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveModuleType"), new object[] { token }), "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]));
}
if ((!token.IsTypeDef && !token.IsTypeSpec) && !token.IsTypeRef)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveType"), new object[] { token, this }), "metadataToken");
}
RuntimeTypeHandle[] typeInstantiationContext = ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] methodInstantiationContext = ConvertToTypeHandleArray(genericMethodArguments);
try
{
Type runtimeType = this.GetModuleHandle().ResolveTypeHandle(metadataToken, typeInstantiationContext, methodInstantiationContext).GetRuntimeType();
if (runtimeType == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveType"), new object[] { token, this }), "metadataToken");
}
type2 = runtimeType;
}
catch (BadImageFormatException exception)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), exception);
}
return type2;
}
public string ResolveString(int metadataToken)
{
System.Reflection.MetadataToken token = new System.Reflection.MetadataToken(metadataToken);
if (!token.IsString)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_ResolveString"), new object[] { metadataToken, this.ToString() }));
}
if (!this.MetadataImport.IsValidToken((int) token))
{
throw new ArgumentOutOfRangeException("metadataToken", string.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_InvalidToken", new object[] { token, this }), new object[0]));
}
string userString = this.MetadataImport.GetUserString(metadataToken);
if (userString == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_ResolveString"), new object[] { metadataToken, this.ToString() }));
}
return userString;
}
public byte[] ResolveSignature(int metadataToken)
{
ConstArray memberRefProps;
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]));
}
if (((!token.IsMemberRef && !token.IsMethodDef) && (!token.IsTypeSpec && !token.IsSignature)) && !token.IsFieldDef)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", new object[] { token, this }), new object[0]), "metadataToken");
}
if (token.IsMemberRef)
{
memberRefProps = this.MetadataImport.GetMemberRefProps(metadataToken);
}
else
{
memberRefProps = this.MetadataImport.GetSignatureFromToken(metadataToken);
}
byte[] buffer = new byte[memberRefProps.Length];
for (int i = 0; i < memberRefProps.Length; i++)
{
buffer[i] = memberRefProps[i];
}
return buffer;
}
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 unsafe MemberInfo ResolveMember(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
System.Reflection.MetadataToken token = new System.Reflection.MetadataToken(metadataToken);
if (token.IsProperty)
{
throw new ArgumentException(Environment.GetResourceString("InvalidOperation_PropertyInfoNotAvailable"));
}
if (token.IsEvent)
{
throw new ArgumentException(Environment.GetResourceString("InvalidOperation_EventInfoNotAvailable"));
}
if (token.IsMethodSpec || token.IsMethodDef)
{
return this.ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments);
}
if (token.IsFieldDef)
{
return this.ResolveField(metadataToken, genericTypeArguments, genericMethodArguments);
}
if ((token.IsTypeRef || token.IsTypeDef) || token.IsTypeSpec)
{
return this.ResolveType(metadataToken, genericTypeArguments, genericMethodArguments);
}
if (!token.IsMemberRef)
{
throw new ArgumentException("metadataToken", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMember", new object[] { token, this }), new object[0]));
}
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]));
}
if (*(((byte*) this.MetadataImport.GetMemberRefProps((int) token).Signature.ToPointer())) != 6)
{
return this.ResolveMethod((int) token, genericTypeArguments, genericMethodArguments);
}
return this.ResolveField((int) token, genericTypeArguments, genericMethodArguments);
}
