public override Assembly?Resolve(MetadataLoadContext context, AssemblyName assemblyName) { string?name = assemblyName.Name; if (name != null) { foreach (var asm in context.GetAssemblies()) { if (asm.GetName().Name == name) { return(asm); } } string dllName = name + ".dll"; foreach (var libraryPath in libraryPaths) { string path = Path.Combine(libraryPath, dllName); if (File.Exists(path)) { return(context.LoadFromAssemblyPath(path)); } } foreach (var reference in references) { if (Path.GetFileName(reference).Equals(dllName, StringComparison.OrdinalIgnoreCase)) { return(context.LoadFromAssemblyPath(reference)); } } } return(null); }
// // For a given assembly name and its full path, Reflection-Only load the assembly directly // from the file in disk or load the file to memory and then create assembly instance from // memory buffer data. // private static Assembly ReflectionOnlyLoadAssembly(string assemblyName, string fullPathToAssembly) { Assembly assembly = null; // If the assembly path is empty, try to load assembly by name. LoadFromAssemblyName // will result in a MetadataLoadContext.Resolve event that will contain more information about the // requested assembly. if (String.IsNullOrEmpty(fullPathToAssembly)) { return(_metadataLoadContext.LoadFromAssemblyName(assemblyName)); } else if (_cachedMetadataLoadContextAssemblies.TryGetValue(fullPathToAssembly, out assembly)) { return(assembly); } else if (!String.IsNullOrEmpty(assemblyName) && _cachedMetadataLoadContextAssemblies.TryGetValue(assemblyName, out assembly)) { return(assembly); } else { assembly = _metadataLoadContext.LoadFromAssemblyPath(fullPathToAssembly); } // Add the assembly to the cache. ReflectionHelper.ReflectionOnlyLoadAssembly // receives frequent calls requesting the same assembly. if (assembly != null && fullPathToAssembly != null) { _cachedMetadataLoadContextAssemblies.Add(fullPathToAssembly, assembly); _cachedMetadataLoadContextAssembliesByNameNoExtension.Add(Path.GetFileNameWithoutExtension(fullPathToAssembly), assembly); } return(assembly); }
public static void GetLoadModules2() { using (TempDirectory td = new TempDirectory()) { string assemblyPath = Path.Combine(td.Path, "n.dll"); string myRes1Path = Path.Combine(td.Path, "MyRes1"); string myRes2Path = Path.Combine(td.Path, "MyRes2"); File.WriteAllBytes(assemblyPath, TestData.s_AssemblyWithResourcesInManifestFilesImage); File.WriteAllBytes(myRes1Path, TestData.s_MyRes1); File.WriteAllBytes(myRes2Path, TestData.s_MyRes2); using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { Assembly a = lc.LoadFromAssemblyPath(assemblyPath); Module res1 = a.GetModule("MyRes1"); Module res2 = a.GetModule("MyRes2"); { Module[] modules = a.GetLoadedModules(getResourceModules: true); Assert.Equal(3, modules.Length); Assert.Contains <Module>(a.ManifestModule, modules); Assert.Contains <Module>(res1, modules); Assert.Contains <Module>(res2, modules); } { Module[] modules = a.GetLoadedModules(getResourceModules: false); Assert.Equal(1, modules.Length); Assert.Equal(a.ManifestModule, modules[0]); } } } }
public static void ModuleGetTypes() { using (TempDirectory td = new TempDirectory()) { string assemblyPath = Path.Combine(td.Path, "MultiModule.dll"); string bobNetModulePath = Path.Combine(td.Path, "Bob.netmodule"); File.WriteAllBytes(assemblyPath, TestData.s_MultiModuleDllImage); File.WriteAllBytes(bobNetModulePath, TestData.s_JoeNetModuleImage); // Note: ScopeName ("Joe") intentionally different from manifest name ("Bob") using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { Assembly a = lc.LoadFromAssemblyPath(assemblyPath); Type[] types = a.ManifestModule.GetTypes(); Assert.Equal(2, types.Length); AssertMainModuleTypesFound(types, a); Module bob = a.GetModule("Bob.netmodule"); Assert.NotNull(bob); Type[] bobTypes = bob.GetTypes(); Assert.Equal(2, bobTypes.Length); AssertBobModuleTypesFound(bobTypes, a); } } }
// // Given the runtime generated icall table, and a set of assemblies, generate // a smaller linked icall table mapping tokens to C function names // The runtime icall table should be generated using // mono --print-icall-table // public void GenIcallTable(string runtimeIcallTableFile, string[] assemblies) { ReadTable(runtimeIcallTableFile); var resolver = new PathAssemblyResolver(assemblies); var mlc = new MetadataLoadContext(resolver, "System.Private.CoreLib"); foreach (var aname in assemblies) { var a = mlc.LoadFromAssemblyPath(aname); foreach (var type in a.GetTypes()) { ProcessType(type); } } string tmpFileName = Path.GetTempFileName(); using (var w = File.CreateText(tmpFileName)) EmitTable(w); if (Utils.CopyIfDifferent(tmpFileName, OutputPath, useHash: false)) { Log.LogMessage(MessageImportance.Low, $"Generating icall table to '{OutputPath}'."); } else { Log.LogMessage(MessageImportance.Low, $"Icall table in {OutputPath} is unchanged."); } FileWrites = OutputPath; File.Delete(tmpFileName); }
/// <summary> /// Try to make sure all assemblies with the given attribute have been loaded into the current AppDomain /// </summary> /// <typeparam name="T">Assembly Attribute Type</typeparam> /// <remarks>This method depends on assemblies existing as separate files on disk and will not work for applications published with /p:PublishSingleFile=true</remarks> private static void TryLoadAssembliesWithAttribute <T>() where T : AssemblyContainsTypeAttribute { var runtimeAssemblies = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll"); using var loadContext = new MetadataLoadContext(new PathAssemblyResolver(AllRelevantPaths(runtimeAssemblies, typeof(T)))); var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); var assemblypaths = Directory.EnumerateFiles(AppDomain.CurrentDomain.BaseDirectory).Where(f => f.EndsWith("dll", StringComparison.InvariantCultureIgnoreCase)); foreach (var assembly in assemblypaths) { var filename = Path.GetFileNameWithoutExtension(assembly); if (!loadedAssemblies.Any(a => a.FullName.StartsWith(filename, StringComparison.InvariantCultureIgnoreCase))) { try { var assemblyRef = loadContext.LoadFromAssemblyPath(assembly); // haven't been able to get actual type comparison to work (assembly of the attribute not found?), falling back on matching the type name if (CustomAttributeData.GetCustomAttributes(assemblyRef).Any(attr => attr.AttributeType.FullName.Equals(typeof(T).FullName))) { FindAssembly(filename); } } catch { // most failures here are situations that aren't relevant, so just fail silently } } } }
protected async Task <List <RefInfo> > GetRefInfosImpl(string configDir, string pack) { var sdk = await ZipDownloader.DownloadIfNedeed(configDir, WindowsUrl); var brokenDependencies = new[] { "system.printing", "presentationframework" }; var result = new List <RefInfo>(); var refDir = GetRefsDir(sdk, pack); var relative = Path.GetRelativePath(sdk, refDir).Replace('\\', '/'); var dlls = Directory.GetFiles(refDir, "*.dll"); PathAssemblyResolver resolver = null; if (dlls.All(x => Path.GetFileName(x) != "mscorlib.dll")) { // Locate mscorlib require for MetadataLoadContext var mscorlibDir = GetRefsDir(sdk, "Microsoft.NETCore.App.Ref"); resolver = new PathAssemblyResolver(dlls.Union(new[] { Path.Combine(mscorlibDir, "mscorlib.dll") })); } else { resolver = new PathAssemblyResolver(dlls); } using var lc = new MetadataLoadContext(resolver); var known = dlls.Select(x => Path.GetFileNameWithoutExtension(x).ToLower()).ToArray(); foreach (var d in dlls) { try { var metadata = lc.LoadFromAssemblyPath(d); var deps = metadata.GetReferencedAssemblies(); var depNames = deps .Where(y => !brokenDependencies.Contains(y.Name.ToLower()) && known.Contains(y.Name.ToLower())) .Select(x => $"\":{x.Name.ToLower()}.dll\""); var name = Path.GetFileName(d); var refname = $"@core_sdk_{Version}//:core/{relative}/{name}"; var stdlibname = GetStdlibPath(sdk, name, pack, InternalVersionFolder, Version); var refInfo = new RefInfo(); refInfo.Name = name.ToLower(); refInfo.Version = metadata.GetName().Version.ToString(); refInfo.Ref = refname; refInfo.StdlibPath = stdlibname; refInfo.Pack = pack; refInfo.Deps.AddRange(depNames); if (stdlibname != null) { result.Add(refInfo); } } catch (Exception) { } } return(result); }
private void GenPInvokeTable(string[] pinvokeModules, string[] assemblies) { var modules = new Dictionary <string, string> (); foreach (var module in pinvokeModules) { modules [module] = module; } var pinvokes = new List <PInvoke>(); var resolver = new PathAssemblyResolver(assemblies); var mlc = new MetadataLoadContext(resolver, "System.Private.CoreLib"); foreach (var aname in assemblies) { var a = mlc.LoadFromAssemblyPath(aname); foreach (var type in a.GetTypes()) { CollectPInvokes(pinvokes, type); } } Log.LogMessage(MessageImportance.Normal, $"Generating pinvoke table to '{OutputPath}'."); using (var w = File.CreateText(OutputPath !)) { EmitPInvokeTable(w, modules, pinvokes); } }
public static void LoadFromAssemblyPathNull() { using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { Assert.Throws <ArgumentNullException>(() => lc.LoadFromAssemblyPath(null)); } }
private static (AssemblyInformation assembly, Assembly?msAssembly) CreateManagedAssemblyInformation(MetadataLoadContext context, AssemblyName assemblyName, string baseDirectory, string extension = "dll") { var assemblyPath = FilePathProvider.GetAssemblyPath($"{assemblyName.Name}.{extension}", baseDirectory); Assembly?assembly = null; try { assembly = File.Exists(assemblyPath) ? context.LoadFromAssemblyPath(assemblyPath ?? string.Empty) : context.LoadFromAssemblyName(assemblyName); } catch { // In this case, assembly is not found } var assemblyShortName = assemblyName.Name ?? string.Empty; var assemblyVersion = assemblyName.Version?.ToString() ?? string.Empty; var info = new AssemblyInformation(assemblyShortName, assembly?.GetName().Version?.ToString() ?? assemblyVersion, assemblyPath) { IsLocalAssembly = assemblyPath != null || assembly == null, AssemblyName = assemblyName.FullName, IsResolved = assembly != null }; info.EnhancePropertiesWithFile(); info.EnhanceProperties(assembly?.GetModules().First()); return(info, assembly); }
public void GenPInvokeTable(string[] pinvokeModules, string[] assemblies) { var modules = new Dictionary <string, string>(); foreach (var module in pinvokeModules) { modules [module] = module; } var pinvokes = new List <PInvoke>(); var callbacks = new List <PInvokeCallback>(); var resolver = new PathAssemblyResolver(assemblies); var mlc = new MetadataLoadContext(resolver, "System.Private.CoreLib"); foreach (var aname in assemblies) { var a = mlc.LoadFromAssemblyPath(aname); foreach (var type in a.GetTypes()) { CollectPInvokes(pinvokes, callbacks, type); } } using (var w = File.CreateText(OutputPath !)) { EmitPInvokeTable(w, modules, pinvokes); EmitNativeToInterp(w, callbacks); } }
/// <exception cref="ArgumentNullException">Throws exception if Name property of assemblyName is null</exception> /// <inheritdoc /> public override Assembly Resolve(MetadataLoadContext context, AssemblyName assemblyName) { Assembly candidateWithSamePkt = null; Assembly candidateIgnoringPkt = null; if (assemblyName == null) { throw new ArgumentNullException(nameof(assemblyName)); } if (assemblyName.Name == null) { throw new ArgumentNullException(nameof(assemblyName.Name)); } if (_zipEntries.TryGetValue(assemblyName.Name, out List <IArchiveEntry> archiveEntries)) { ReadOnlySpan <byte> pktFromName = assemblyName.GetPublicKeyToken(); foreach (var archiveEntry in archiveEntries) { using var entryStream = archiveEntry.ExtractToStream(); var assemblyFromZip = context.LoadFromStream(entryStream); var assemblyNameFromZip = assemblyFromZip.GetName(); if (assemblyName.Name != null && assemblyName.Name.Equals(assemblyNameFromZip.Name, StringComparison.OrdinalIgnoreCase)) { ReadOnlySpan <byte> pktFromAssembly = assemblyNameFromZip.GetPublicKeyToken(); // Find exact match on PublicKeyToken including treating no PublicKeyToken as its own entry. if (pktFromName.SequenceEqual(pktFromAssembly)) { // Pick the highest version. if (candidateWithSamePkt == null || assemblyNameFromZip.Version > candidateWithSamePkt.GetName().Version) { candidateWithSamePkt = assemblyFromZip; } } // If assemblyName does not specify a PublicKeyToken, then still consider those with a PublicKeyToken. else if (candidateWithSamePkt == null && pktFromName.IsEmpty) { // Pick the highest version. if (candidateIgnoringPkt == null || assemblyNameFromZip.Version > candidateIgnoringPkt.GetName().Version) { candidateIgnoringPkt = assemblyFromZip; } } } } } var assembly = candidateWithSamePkt ?? candidateIgnoringPkt; if (assemblyName.Name != null && (assembly == null) && (assemblyName.Name.Equals(_coreAssemblyName, StringComparison.InvariantCultureIgnoreCase))) { assembly = context.LoadFromAssemblyPath(_coreAssemblyPath); } return(assembly); }
public override Assembly Resolve(MetadataLoadContext context, AssemblyName assemblyName) { // We know these assemblies are located in the Host, so don't bother loading them from the plugin location if (this.platformAssemblies.Contains(assemblyName.Name)) { return(context.LoadFromAssemblyPath(AssemblyLoadContext.Default.LoadFromAssemblyName(assemblyName).Location)); } // Check if the file is found in the plugin location var candidateFile = Path.Combine(assemblyPath, $"{assemblyName.Name}.dll"); if (File.Exists(candidateFile)) { return(context.LoadFromAssemblyPath(candidateFile)); } // Fallback, load from Host AppDomain, this is mostly required for System.* assemblies return(context.LoadFromAssemblyPath(AssemblyLoadContext.Default.LoadFromAssemblyName(assemblyName).Location)); }
public static void AssemblyLocationFile() { using (TempFile tf = TempFile.Create(TestData.s_SimpleAssemblyImage)) using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { Assembly a = lc.LoadFromAssemblyPath(tf.Path); string location = a.Location; Assert.Equal(tf.Path, location); } }
public static void Scenario_GetAssemblyName() { // Ensure you can do all this without resolving dependencies. using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { Assembly a = lc.LoadFromAssemblyPath(typeof(GenericClass1 <>).Assembly.Location); AssemblyName assemblyName = a.GetName(); Console.WriteLine(assemblyName.FullName); } }
public static void ModuleFullyQualifiedNameFromPath() { using (TempFile tf = TempFile.Create(TestData.s_SimpleAssemblyImage)) using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { string path = tf.Path; Assembly a = lc.LoadFromAssemblyPath(path); Module m = a.ManifestModule; Assert.Equal(path, m.FullyQualifiedName); } }
public AssemblyMetadata GetReflectedAssemblyFromFile(string assemblyPath) { if (string.IsNullOrWhiteSpace(assemblyPath)) { throw new ArgumentException("assemblyPath"); } var assembly = _metadataLoadContext.LoadFromAssemblyPath(assemblyPath); return(new AssemblyMetadata(assembly)); }
public static void CoreGetTypeCacheCoverage3() { using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { // Make sure the tricky corner case of a null/empty namespace is covered. Assembly a = lc.LoadFromAssemblyPath(AssemblyPathHelper.GetAssemblyLocation(typeof(TopLevelType).Assembly)); Type t = a.GetType("TopLevelType", throwOnError: true, ignoreCase: false); Assert.Null(t.Namespace); Assert.Equal("TopLevelType", t.Name); } }
public static void Scenario_EnumerateDependencies() { // Ensure you can do all this without resolving dependencies. using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { Assembly a = lc.LoadFromAssemblyPath(typeof(GenericClass1 <>).Assembly.Location); foreach (AssemblyName name in a.GetReferencedAssemblies()) { Console.WriteLine(name.FullName); } } }
protected Assembly LoadAssemblyForRuntime(MetadataLoadContext context, AssemblyName assemblyName) { try { var candidate = GetLoadedAssemblies().FirstOrDefault(a => a.GetName().Name == assemblyName.Name); var candidateName = candidate != null?candidate.GetName() : null; if (candidateName != null && candidateName.Version != assemblyName.Version) { return(context.LoadFromAssemblyPath(AssemblyLoadContext.Default.LoadFromAssemblyName(candidateName).Location)); } return(context.LoadFromAssemblyPath(AssemblyLoadContext.Default.LoadFromAssemblyName(assemblyName).Location)); } catch (FileNotFoundException) when(assemblyName?.Name == "System.Runtime") { var hostRuntimeAssembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly; throw new AssemblyScanningException($"System.Runtime {assemblyName.Version} failed to load. Are you trying to load a new plugin into an old host? Host Runtime Version: {hostRuntimeAssembly.GetName().Version} on {hostRuntimeAssembly.CodeBase}"); } }
public static Assembly GetAssembly(string assemblyName) { var runtimeAssemblies = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll"); var paths = new List <string>(runtimeAssemblies); var resolver = new PathAssemblyResolver(paths); var mlc = new MetadataLoadContext(resolver); using (mlc) { return(mlc.LoadFromAssemblyPath(assemblyName)); } }
public override async Task <List <RefInfo> > GetRefInfos(string configDir) { var package = await PackageDownloader.DownloadPackageIfNedeed(configDir, "Microsoft.NETCore.App", InternalVersionFolder); var sdkDir = await ZipDownloader.DownloadIfNedeed(configDir, WindowsUrl); var brokenDependencies = new string[] { "netstandard" }; var result = new List <RefInfo>(); var packageDir = Path.Combine(package, "packages", $"Microsoft.NETCore.App.{InternalVersionFolder}"); var frameworkDir = Path.Combine(packageDir, "ref"); frameworkDir = Directory.GetDirectories(frameworkDir).OrderByDescending(x => x).First(); var relative = Path.GetRelativePath(packageDir, frameworkDir).Replace('\\', '/'); var dlls = Directory.GetFiles(frameworkDir, "*.dll"); var resolver = new PathAssemblyResolver(dlls); using var lc = new MetadataLoadContext(resolver); var known = dlls.Select(x => Path.GetFileNameWithoutExtension(x).ToLower()).ToArray(); foreach (var d in dlls) { try { var metadata = lc.LoadFromAssemblyPath(d); var deps = metadata.GetReferencedAssemblies(); var depNames = deps .Where(y => !brokenDependencies.Contains(y.Name.ToLower()) && known.Contains(y.Name.ToLower())) .Select(x => $"\":{x.Name.ToLower()}.dll\""); var name = Path.GetFileName(d); var refname = $"@Microsoft.NETCore.App.{InternalVersionFolder}//:{relative}/{name}"; var stdlibpath = GetStdlibPath(sdkDir, name, InternalVersionFolder, Version); var refInfo = new RefInfo(); refInfo.Name = name.ToLower(); refInfo.Version = metadata.GetName().Version.ToString(); refInfo.Ref = refname; refInfo.StdlibPath = stdlibpath; refInfo.Pack = null; refInfo.Deps.AddRange(depNames); result.Add(refInfo); } catch (Exception) { } } return(result); }
private static int CompareAction(AssemblyReflectionInput assembly1Input, AssemblyReflectionInput assembly2Input, Func <Assembly, Assembly, int> compareFunc) { var assembly1Paths = new[] { assembly1Input.AssemblyPath }.Concat(assembly1Input.AssemblyDependencies).Distinct(); var assembly2Paths = new[] { assembly2Input.AssemblyPath }.Concat(assembly2Input.AssemblyDependencies).Distinct(); using var loadContext1 = new MetadataLoadContext(new PathAssemblyResolver(assembly1Paths)); using var loadContext2 = new MetadataLoadContext(new PathAssemblyResolver(assembly2Paths)); var assembly1 = loadContext1.LoadFromAssemblyPath(assembly1Input.AssemblyPath); var assembly2 = loadContext2.LoadFromAssemblyPath(assembly2Input.AssemblyPath); return(compareFunc(assembly1, assembly2)); }
public static void TestRestrictions() { using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { Assembly a = lc.LoadFromAssemblyPath(AssemblyPathHelper.GetAssemblyLocation(typeof(TopLevelType).Assembly)); #pragma warning disable SYSLIB0012 Assert.Throws <NotSupportedException>(() => a.CodeBase); Assert.Throws <NotSupportedException>(() => a.EscapedCodeBase); #pragma warning restore SYSLIB0012 Assert.Throws <NotSupportedException>(() => a.GetObjectData(null, default)); Assert.Throws <NotSupportedException>(() => a.GetSatelliteAssembly(null)); Assert.Throws <NotSupportedException>(() => a.GetSatelliteAssembly(null, null)); foreach (TypeInfo t in a.DefinedTypes) { Assert.Throws <InvalidOperationException>(() => t.IsSecurityCritical); Assert.Throws <InvalidOperationException>(() => t.IsSecuritySafeCritical); Assert.Throws <InvalidOperationException>(() => t.IsSecurityTransparent); foreach (MemberInfo mem in t.GetMember("*", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly)) { ICustomAttributeProvider icp = mem; Assert.Throws <InvalidOperationException>(() => icp.GetCustomAttributes(inherit: false)); Assert.Throws <InvalidOperationException>(() => icp.GetCustomAttributes(null, inherit: false)); Assert.Throws <InvalidOperationException>(() => icp.IsDefined(null, inherit: false)); if (mem is ConstructorInfo c) { Assert.Throws <InvalidOperationException>(() => c.Invoke(Array.Empty <object>())); Assert.Throws <InvalidOperationException>(() => c.Invoke(default(BindingFlags), null, Array.Empty <object>(), null)); Assert.Throws <InvalidOperationException>(() => c.Invoke(null, Array.Empty <object>())); Assert.Throws <InvalidOperationException>(() => c.Invoke(null, default(BindingFlags), null, Array.Empty <object>(), null)); Assert.Throws <InvalidOperationException>(() => c.MethodHandle); Assert.Throws <InvalidOperationException>(() => c.IsSecurityCritical); Assert.Throws <InvalidOperationException>(() => c.IsSecuritySafeCritical); Assert.Throws <InvalidOperationException>(() => c.IsSecurityTransparent); } if (mem is EventInfo e) { Assert.Throws <InvalidOperationException>(() => e.AddEventHandler(null, null)); Assert.Throws <InvalidOperationException>(() => e.RemoveEventHandler(null, null)); } if (mem is FieldInfo f) { Assert.Throws <InvalidOperationException>(() => f.FieldHandle); Assert.Throws <InvalidOperationException>(() => f.GetValue(null)); Assert.Throws <InvalidOperationException>(() => f.GetValueDirect(default));
static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("Required path to dll"); return; } // input.dll outputDir references.txt var path = args[0]; var outputPath = args.Length > 1 ? args[1] : null; var directory = Path.GetDirectoryName(path); var referencePaths = args.Length > 2 ? File.ReadAllLines(args[2]) : new string[0]; var resolver = new PathAssemblyResolver(referencePaths); var corAssembly = referencePaths.Where(m => m.Contains("mscorlib")).Select(a => AssemblyName.GetAssemblyName(a).FullName).FirstOrDefault(); var metadataLoadContext = new MetadataLoadContext(resolver, corAssembly); var uControllerAssembly = metadataLoadContext.LoadFromAssemblyName(typeof(HttpHandler).Assembly.FullName); var handler = uControllerAssembly.GetType(typeof(HttpHandler).FullName); var assembly = metadataLoadContext.LoadFromAssemblyPath(path); var models = new List <HttpModel>(); foreach (var type in assembly.GetExportedTypes()) { if (handler.IsAssignableFrom(type)) { var model = HttpModel.FromType(type); models.Add(model); } } if (models.Count > 0 && outputPath != null) { Directory.CreateDirectory(outputPath); } foreach (var model in models) { var gen = new CodeGenerator(model, metadataLoadContext); if (outputPath != null) { var fileName = Path.Combine(outputPath, model.HandlerType.Name + ".RouteProvider.cs"); File.WriteAllText(fileName, gen.Generate()); } else { Console.WriteLine(gen.Generate()); } } }
public static void LoadFromDifferentLocations() { using (TempFile tf1 = TempFile.Create(TestData.s_SimpleAssemblyImage)) using (TempFile tf2 = TempFile.Create(TestData.s_SimpleAssemblyImage)) // Note this is using SimpleAssemblyResolver in order to resolve LoadFromAssemblyName. using (MetadataLoadContext lc = new MetadataLoadContext(new SimpleAssemblyResolver())) { Assembly a = lc.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assert.NotNull(a); Assembly a1 = lc.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assert.Equal(a, a1); Assembly a2 = lc.LoadFromAssemblyName(new AssemblyName(TestData.s_SimpleAssemblyFullName)); Assert.Equal(a, a2); Assembly a3 = lc.LoadFromAssemblyPath(tf1.Path); Assert.Equal(a, a3); Assembly a4 = lc.LoadFromAssemblyPath(tf2.Path); Assert.Equal(a, a4); } }
public static void LoadFromDifferentLocations() { using (TempFile tf1 = TempFile.Create(TestData.s_SimpleAssemblyImage)) using (TempFile tf2 = TempFile.Create(TestData.s_SimpleAssemblyImage)) using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { // As long as the MVID matches, you can load the same assembly from multiple locations. Assembly a = lc.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assert.NotNull(a); Assembly a1 = lc.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assert.Equal(a, a1); Assembly a2 = lc.LoadFromAssemblyName(new AssemblyName(TestData.s_SimpleAssemblyName)); Assert.Equal(a, a2); Assembly a3 = lc.LoadFromAssemblyPath(tf1.Path); Assert.Equal(a, a3); Assembly a4 = lc.LoadFromAssemblyPath(tf2.Path); Assert.Equal(a, a4); } }
public static void LoadMultiModuleFromDisk_GetModuleNameNotThere() { using (TempDirectory td = new TempDirectory()) { string assemblyPath = Path.Combine(td.Path, "MultiModule.dll"); File.WriteAllBytes(assemblyPath, TestData.s_MultiModuleDllImage); using (MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver())) { Assembly a = lc.LoadFromAssemblyPath(assemblyPath); Assert.Throws <FileNotFoundException>(() => a.GetModule("Bob.netmodule")); } } }
public static void MetadataLoadContextApisAfterDispose() { MetadataLoadContext lc = new MetadataLoadContext(new EmptyCoreMetadataAssemblyResolver()); lc.Dispose(); Assert.Throws <ObjectDisposedException>(() => lc.LoadFromAssemblyName(new AssemblyName("Foo"))); Assert.Throws <ObjectDisposedException>(() => lc.LoadFromAssemblyName("Foo")); Assert.Throws <ObjectDisposedException>(() => lc.LoadFromAssemblyPath("Foo")); Assert.Throws <ObjectDisposedException>(() => lc.LoadFromByteArray(TestData.s_SimpleAssemblyImage)); Assert.Throws <ObjectDisposedException>(() => lc.LoadFromStream(new MemoryStream(TestData.s_SimpleAssemblyImage))); Assert.Throws <ObjectDisposedException>(() => lc.CoreAssembly); Assert.Throws <ObjectDisposedException>(() => lc.GetAssemblies()); }
private List <RefInfo> GetRefInfos(string srcDir, string package, string version) { var brokenDependencies = new string[] { "system.xml", "system.configuration", "system.windows.forms", "system.runtime.remoting", "system.transactions", "system.design", "system.web", "presentationframework", "system.printing", "system.servicemodel", "system.data.services.design", "system.workflow.activities", "system.data" }; var result = new List <RefInfo>(); var packageDir = GetPackagePath(srcDir, package, version); var frameworkDir = GetRefsDir(srcDir, package, version); var facadeDir = Path.Combine(frameworkDir, "Facades"); var relative = Path.GetRelativePath(packageDir, frameworkDir).Replace('\\', '/'); var dlls = Directory.GetFiles(frameworkDir, "*.dll"); var facades = Directory.Exists(facadeDir) ? Directory.GetFiles(facadeDir, "*.dll") : new string[] { }; var allDlls = dlls.Union(facades); var resolver = new PathAssemblyResolver(allDlls); using var lc = new MetadataLoadContext(resolver); var known = allDlls.Select(x => Path.GetFileNameWithoutExtension(x).ToLower()).ToArray(); foreach (var d in allDlls) { try { var metadata = lc.LoadFromAssemblyPath(d); var deps = metadata.GetReferencedAssemblies(); var depNames = deps .Where(y => !brokenDependencies.Contains(y.Name.ToLower()) && known.Contains(y.Name.ToLower())) .Select(x => $"\":{x.Name.ToLower()}.dll\""); var name = Path.GetFileName(d); var refname = facades.Contains(d) ? $"@{package}.{version}//:{relative}/Facades/{name}" : $"@{package}.{version}//:{relative}/{name}"; var refInfo = new RefInfo(); refInfo.Name = name.ToLower(); refInfo.Version = metadata.GetName().Version.ToString(); refInfo.Ref = refname; refInfo.StdlibPath = refname; // Real implementation assemblies are in GAC refInfo.Deps.AddRange(depNames); result.Add(refInfo); } catch (Exception) { } } return(result); }