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; }