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