public MethodRef(TypeRef declaringType, int metadataToken, ImmutableArray <TypeRef> genericMethodArguments)
: this(
declaringType,
metadataToken,
declaringType.Resolve().Assembly.ManifestModule.ResolveMethod(metadataToken).Name,
declaringType.Resolve().Assembly.ManifestModule.ResolveMethod(metadataToken).GetParameterTypes(declaringType.Resolver),
genericMethodArguments)
{
}
internal static void GetInputAssemblies(this TypeRef typeRef, ISet <AssemblyName> assemblies)
{
Requires.NotNull(assemblies, nameof(assemblies));
if (typeRef != null)
{
assemblies.Add(typeRef.AssemblyName);
foreach (var typeArg in typeRef.GenericTypeArguments)
{
GetInputAssemblies(typeArg, assemblies);
}
// Base types may define [InheritedExport] attributes or otherwise influence MEF
// so we should include them as input assemblies.
// Resolving a TypeRef is a necessary cost in order to identify the transitive closure of base types.
var type = typeRef.Resolve();
foreach (var baseType in type.EnumTypeAndBaseTypes())
{
assemblies.Add(baseType.GetTypeInfo().Assembly.GetName());
}
// Interfaces may also define [InheritedExport] attributes, metadata view filters, etc.
foreach (var iface in type.GetTypeInfo().GetInterfaces())
{
assemblies.Add(iface.GetTypeInfo().Assembly.GetName());
}
}
}
public ConstructorRef(TypeRef declaringType, int metadataToken)
: this(
declaringType,
metadataToken,
declaringType.Resolve().Assembly.ManifestModule.ResolveMethod(metadataToken).GetParameterTypes(declaringType.Resolver))
{
}
public FieldRef(TypeRef declaringType, int metadataToken)
: this(
declaringType,
metadataToken,
declaringType.Resolve().Assembly.ManifestModule.ResolveField(metadataToken).Name)
{
}
public PropertyRef(TypeRef declaringType, int metadataToken, int?getMethodMetadataToken, int?setMethodMetadataToken)
: this(
declaringType,
metadataToken,
getMethodMetadataToken,
setMethodMetadataToken,
declaringType.Resolve().Assembly.ManifestModule.ResolveMember(metadataToken).Name)
{
}
public ParameterRef(TypeRef declaringType, int methodMetadataToken, int parameterIndex)
{
var methodBase = declaringType.Resolve().Assembly.ManifestModule.ResolveMethod(methodMetadataToken);
if (methodBase is ConstructorInfo ctor)
{
this.Constructor = new ConstructorRef(ctor, declaringType.Resolver);
this.Method = default(MethodRef);
}
else
{
this.Method = new MethodRef((MethodInfo)methodBase, declaringType.Resolver);
this.Constructor = default(ConstructorRef);
}
this.parameterIndex = parameterIndex;
}
