public static MetadataAssembly LoadMetadataAssembly(string path)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
path = Path.GetFullPath(path);
MetadataAssembly assembly;
if (s_assemblies.TryGetValue(path, out assembly))
{
return(assembly);
}
var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
var peReader = new PEReader(stream);
MetadataReader metadata = peReader.GetMetadataReader();
assembly = new MetadataAssembly(peReader, metadata, path);
s_assemblies.Add(path, assembly);
return(assembly);
}
internal MetadataGenericParameterType(
MetadataAssembly assembly,
GenericParameterHandle handle,
MetadataType declaringType)
: this(assembly, handle, declaringType, null)
{
}
internal MetadataType(MetadataType parentType, TypeDefinitionHandle handle)
{
_isNested = true;
_parent = parentType;
_assembly = parentType._assembly;
_metadata = parentType._assembly.Metadata;
Handle = handle;
}
internal MetadataGenericConstructedType(
MetadataAssembly assembly,
MetadataType definition,
MetadataType[] instantiation)
: base(assembly, definition.Handle)
{
_typeArguments = instantiation;
_genericDefinition = definition;
}
internal static MetadataType GetMetadataType(MetadataAssembly assembly, EntityHandle handle)
{
if (handle.Kind == HandleKind.TypeDefinition)
{
return(assembly.GetType((TypeDefinitionHandle)handle));
}
if (handle.Kind != HandleKind.TypeReference)
{
throw new ArgumentException("Invalid handle kind.", nameof(handle));
}
TypeReference typeRef = assembly.Metadata.GetTypeReference((TypeReferenceHandle)handle);
string @namespace = assembly.Metadata.GetString(typeRef.Namespace);
string name = assembly.Metadata.GetString(typeRef.Name);
string fullName = string.IsNullOrEmpty(@namespace)
? name
: string.Join(Type.Delimiter.ToString(), @namespace, name);
MetadataType resolvedType = null;
MetadataAssembly resolvedAssembly = null;
if (typeRef.ResolutionScope.Kind == HandleKind.TypeReference)
{
var parent = GetMetadataType(assembly, typeRef.ResolutionScope);
resolvedType = parent.GetNestedMetadataType(fullName, Util.AllFlags);
resolvedAssembly = resolvedType.GetMetadataAssembly();
}
else if (typeRef.ResolutionScope.Kind == HandleKind.AssemblyReference)
{
AssemblyReference assemblyRef =
assembly.Metadata.GetAssemblyReference((AssemblyReferenceHandle)typeRef.ResolutionScope);
resolvedAssembly = ResolveAssembly(assembly.Metadata, assemblyRef);
resolvedType = resolvedAssembly.GetType(fullName) as MetadataType;
}
if (resolvedType != null)
{
return(resolvedType);
}
// Try to find the type in the core framework library as a fallback. I couldn't quickly
// find a way to determine which assembly a type would be forwarded to programmatically.
if (!fullName.StartsWith("System.", StringComparison.Ordinal))
{
return(null);
}
resolvedAssembly = ResolveAssembly(typeof(object).Assembly.GetName());
return(resolvedAssembly.GetType(fullName) as MetadataType);
}
internal MetadataGenericParameterType(
MetadataAssembly assembly,
GenericParameterHandle handle,
MetadataType declaringType,
MetadataMethodInfo declaringMethod)
: base(assembly, default(TypeDefinitionHandle))
{
_isMethodParameter = declaringMethod != null;
_declaringMethod = declaringMethod;
_declaringType = declaringType;
_metadata = assembly.Metadata;
_handle = handle;
}
internal static MetadataAssembly ResolveAssembly(AssemblyName assemblyName)
{
// Hacky workaround for shims.
if (assemblyName.Name == "System.Runtime" || assemblyName.Name == "netstandard")
{
assemblyName = typeof(object).Assembly.GetName();
}
MetadataAssembly resolvedAssembly = GetMetadataAssembly(assemblyName);
if (resolvedAssembly != null)
{
return(resolvedAssembly);
}
if (ResolutionType == AssemblyResolutionType.CurrentAppDomain)
{
Assembly foundAssembly = AppDomain.CurrentDomain
.GetAssemblies()
.FirstOrDefault(
assembly => Util.IsAssemblyNameMatch(assemblyName, assembly.GetName()));
if (foundAssembly != null && !string.IsNullOrEmpty(foundAssembly.Location))
{
return(LoadMetadataAssembly(foundAssembly.Location));
}
}
var eventArgs = new MetadataResolveEventArgs(assemblyName);
MetadataAssemblyResolve?.Invoke(null, eventArgs);
if (eventArgs.ResolvedAssembly != null)
{
return(eventArgs.ResolvedAssembly);
}
throw new InvalidOperationException($"Cannot resolve assembly {assemblyName.ToString()}. You can enable automatic metadata assembly resolution using the method MetadataDomain.SetAssemblyResolution.");
}
internal MetadataType(MetadataAssembly assembly, TypeDefinitionHandle handle)
{
_assembly = assembly;
_metadata = assembly.Metadata;
Handle = handle;
}
internal MetadataModule(MetadataAssembly assembly, ModuleDefinition definition)
{
_assembly = assembly;
_metadata = assembly.Metadata;
_definition = definition;
}
