public static void PathAssemblyResolverBasicPathWithRunningAssemblies()
{
string coreAssemblyPath = TestUtils.GetPathToCoreAssembly();
// Obtain this test class
string thisAssemblyPath = typeof(MetadataLoadContextTests).Assembly.Location;
if (PlatformDetection.IsBrowser)
{
// prepends slash as Assembly.Location only contains the file name on browser (https://github.com/dotnet/runtime/issues/39650)
thisAssemblyPath = "/" + thisAssemblyPath;
}
var resolver = new PathAssemblyResolver(new string[] { coreAssemblyPath, thisAssemblyPath });
using (MetadataLoadContext lc = new MetadataLoadContext(resolver, TestUtils.GetNameOfCoreAssembly()))
{
AssemblyName thisAssemblyName = typeof(MetadataLoadContextTests).Assembly.GetName();
Assembly assembly = lc.LoadFromAssemblyName(thisAssemblyName);
Type t = assembly.GetType(typeof(MetadataLoadContextTests).FullName, throwOnError: true);
Assert.Equal(t.FullName, typeof(MetadataLoadContextTests).FullName);
Assert.Equal(t.Assembly.Location, thisAssemblyPath);
}
}
//
// 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);
}
public static void DuplicateAssembliesPickHigherVersion()
{
using (TempDirectory dir = new TempDirectory())
using (TempDirectory dir2 = new TempDirectory())
using (TempFile core = new TempFile(Path.Combine(dir.Path, TestData.s_PhonyCoreAssemblySimpleName), TestData.s_PhonyCoreAssemblyImage))
using (TempFile tf1 = new TempFile(Path.Combine(dir.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleUnsignedVersioned100Image))
using (TempFile tf2 = new TempFile(Path.Combine(dir2.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleUnsignedVersioned200Image))
{
// tf1 first, then tf2.
{
var resolver = new PathAssemblyResolver(new string[] { core.Path, tf1.Path, tf2.Path });
using (var lc = new MetadataLoadContext(resolver, TestData.s_PhonyCoreAssemblyFullName))
{
Assembly a1 = lc.LoadFromAssemblyName(TestData.s_SimpleUnsignedVersioned100FullName);
Assert.Equal("2.0.0.0", a1.GetName().Version.ToString());
}
}
// Reverse the order.
{
var resolver = new PathAssemblyResolver(new string[] { core.Path, tf2.Path, tf1.Path });
using (var lc = new MetadataLoadContext(resolver, TestData.s_PhonyCoreAssemblyFullName))
{
Assembly a1 = lc.LoadFromAssemblyName(TestData.s_SimpleUnsignedVersioned100FullName);
Assert.Equal("2.0.0.0", a1.GetName().Version.ToString());
}
}
}
}
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);
}
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);
}
}
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 AssemblyMetadataLoader()
{
var files = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll");
MetadataAssemblyResolver metadataAssemblyResolver = new PathAssemblyResolver(files);
_metadataLoadContext = new MetadataLoadContext(metadataAssemblyResolver);
}
private (Stream AssemblyStream, Assembly Assembly, MethodInfo[] DecoratedMethods, string AssemblyPath, string[] AliasCategories) FindAssemblyToAnalyze(IPackageCoreReader package, string[] assembliesPath)
{
foreach (var assemblyPath in assembliesPath)
{
var runtimeAssemblies = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll");
// The assembly resolver makes the assemblies referenced by THIS APPLICATION (i.e.: the AddinDiscoverer) available
// for resolving types when looping through custom attributes. As of this writing, there is one addin written in
// FSharp which was causing 'Could not find FSharp.Core' when looping through its custom attributes. To solve this
// problem, I added a reference to FSharp.Core in Cake.AddinDiscoverer.csproj
var assemblyResolver = new PathAssemblyResolver(runtimeAssemblies);
// It's important to create a new load context for each assembly to ensure one addin does not interfere with another
var loadContext = new MetadataLoadContext(assemblyResolver);
// Load the assembly
var assemblyStream = LoadFileFromPackage(package, assemblyPath);
var assembly = loadContext.LoadFromStream(assemblyStream);
var isModule = assembly
.CustomAttributes
.Any(a => a.AttributeType.Namespace == "Cake.Core.Annotations" && a.AttributeType.Name == "CakeModuleAttribute");
// Search for decorated methods.
// Please note that it's important to use the '.ExportedTypes' and the '.CustomAttributes' properties rather than
// the '.GetExportedTypes' and the '.GetCustomAttributes' methods because the latter will instantiate the custom
// attributes which, in our case, will cause exceptions because they are defined in dependencies which are most
// likely not available in the load context.
var decoratedMethods = assembly
.ExportedTypes
.SelectMany(type => type.GetTypeInfo().DeclaredMethods)
.Where(method =>
method.CustomAttributes.Any(a =>
a.AttributeType.Namespace == "Cake.Core.Annotations" &&
(a.AttributeType.Name == "CakeMethodAliasAttribute" || a.AttributeType.Name == "CakePropertyAliasAttribute")))
.ToArray();
// Search for alias categories
var aliasCategories = assembly
.ExportedTypes
.SelectMany(t => t.CustomAttributes)
.Where(a => a.AttributeType.Namespace == "Cake.Core.Annotations" && a.AttributeType.Name == "CakeAliasCategoryAttribute")
.Select(a => a.ConstructorArguments[0].Value?.ToString())
.Where(category => !string.IsNullOrEmpty(category))
.Distinct(StringComparer.OrdinalIgnoreCase)
.ToArray();
if (isModule || decoratedMethods.Any())
{
return(assemblyStream, assembly, decoratedMethods, assemblyPath, aliasCategories);
}
}
return(null, null, Array.Empty <MethodInfo>(), string.Empty, Array.Empty <string>());
}
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 PathAssemblyResolver GetTrakxAssemblyResolver()
{
var executingAssembly = Assembly.GetExecutingAssembly();
var executingAssemblyLocation = new FileInfo(executingAssembly.Location).Directory !.GetFiles("Trakx.*.dll")
.Select(f => f.FullName).ToList();
var runtimeAssembliesLocations =
Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll");
var assemblyPaths = runtimeAssembliesLocations.Union(executingAssemblyLocation);
var resolver = new PathAssemblyResolver(assemblyPaths);
return(resolver);
}
#pragma warning disable S3442 // "abstract" classes should not have "public" constructors
internal ReadmeDocumentationUpdaterBase(ITestOutputHelper output, IReadmeEditor?editor, int maxRecursions = 1)
#pragma warning restore S3442 // "abstract" classes should not have "public" constructors
{
_output = output;
var readmeDirectoryInfo = GetRepositoryRootDirectory();
var readmeFilePath = Path.Combine(readmeDirectoryInfo.FullName, "README.md");
_editor = editor ?? new ReadmeEditor(readmeFilePath);
_resolver = GetTrakxAssemblyResolver();
_maxRecursions = maxRecursions;
ImplementingAssembly = GetType().Assembly;
}
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());
}
}
}
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);
}
public static IMetadataContext CreateContextForDirectories(params string[] assembliesDirectories)
{
string[] runtimeAssemblies = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll");
var paths = new List <string>(runtimeAssemblies);
foreach (var directory in assembliesDirectories)
{
paths.AddRange(Directory.GetFiles(directory, "*.dll"));
}
var pathAssemblyResolver = new PathAssemblyResolver(paths);
var metadataLoadContext = new MetadataLoadContext(pathAssemblyResolver);
return(new MetadataContext(pathAssemblyResolver, metadataLoadContext));
}
private string GetAssemblyVersion()
{
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)
{
// Load assembly into MetadataLoadContext.
var assembly = mlc.LoadFromAssemblyPath(Constants.WolvenKitDll);
var name = assembly.GetName();
return(name.Version.ToString());
}
}
public static void RelocatableAssembly()
{
string coreAssemblyPath = TestUtils.GetPathToCoreAssembly();
string coreAssemblyName = Path.GetFileNameWithoutExtension(coreAssemblyPath);
// Ensure mscorlib is specified since we want to relocate an older mscorlib later.
string coreDirectory = Path.GetDirectoryName(coreAssemblyPath);
string mscorLibPath = Path.Combine(coreDirectory, "mscorlib.dll");
using (TempDirectory dir = new TempDirectory())
using (TempFile relocatableAsmFile = new TempFile(Path.Combine(dir.Path, TestData.s_RetargetableAssemblySimpleName), TestData.s_RetargetableImage))
{
var resolver = new PathAssemblyResolver(new string[] { coreAssemblyPath, mscorLibPath, relocatableAsmFile.Path });
using (MetadataLoadContext lc = new MetadataLoadContext(resolver, coreAssemblyName))
{
Assembly retargetableAssembly = lc.LoadFromAssemblyName(TestData.s_RetargetableAssemblySimpleName);
Assert.NotNull(retargetableAssembly);
// The assembly only contains a reference to an older, retargetable mscorlib.
AssemblyName[] assemblyNames = retargetableAssembly.GetReferencedAssemblies();
AssemblyName retargetableAssemblyName = assemblyNames[0];
Assert.Equal(AssemblyNameFlags.Retargetable, retargetableAssemblyName.Flags);
Assert.Equal(new Version(2, 0, 5, 0), retargetableAssemblyName.Version);
// Trigger PathAssemblyResolver.Resolve for the older mscorlib.
Type myType = retargetableAssembly.GetType("Relocate.MyClass");
FieldInfo[] fields = myType.GetFields();
Assert.Equal(1, fields.Length);
FieldInfo field = fields[0];
Assert.Equal("MyObj", field.Name);
// Verify that LoadFromAssemblyName also finds the newer mscorlib.
Assembly mscorlib = lc.LoadFromAssemblyName(retargetableAssemblyName);
Assert.True(mscorlib.GetName().Version > retargetableAssemblyName.Version);
// The older reference has a different public key token, which requires AssemblyNameFlags.Retargetable to find the newer assembly.
byte[] newerPKT = mscorlib.GetName().GetPublicKeyToken();
Assert.NotEmpty(newerPKT);
byte[] olderPKT = retargetableAssemblyName.GetPublicKeyToken();
Assert.NotEmpty(olderPKT);
Assert.False(Enumerable.SequenceEqual(newerPKT, olderPKT));
}
}
}
public static void DuplicateUnsignedAssembliesSameVersions()
{
using (TempDirectory dir = new TempDirectory())
using (TempDirectory dir2 = new TempDirectory())
using (TempFile core = new TempFile(Path.Combine(dir.Path, TestData.s_PhonyCoreAssemblySimpleName), TestData.s_PhonyCoreAssemblyImage))
using (TempFile tf1 = new TempFile(Path.Combine(dir.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleUnsignedVersioned100Image))
using (TempFile tf2 = new TempFile(Path.Combine(dir2.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleUnsignedVersioned100Image))
{
var resolver = new PathAssemblyResolver(new string[] { core.Path, tf1.Path, tf2.Path });
using (var lc = new MetadataLoadContext(resolver, TestData.s_PhonyCoreAssemblyFullName))
{
Assembly a1 = lc.LoadFromAssemblyName(TestData.s_SimpleVersionedShortName);
Assembly a2 = lc.LoadFromAssemblyName(TestData.s_SimpleUnsignedVersioned100FullName);
Assert.Same(a1, a2);
}
}
}
private List <RefInfo> GetRefInfos(string srcDir)
{
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 dlls = Directory.GetFiles(srcDir, "*.dll");
var facades = Directory.GetFiles(Path.Combine(srcDir, "Facades"), "*.dll");
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) ? $"@Mono.ReferenceAssemblies.v4.5//:build/.NETFramework/v4.5/Facades/{name}"
: $"@Mono.ReferenceAssemblies.v4.5//:build/.NETFramework/v4.5/{name}";
var refInfo = new RefInfo();
refInfo.Name = name.ToLower();
refInfo.Version = metadata.GetName().Version.ToString();
refInfo.Ref = refname;
refInfo.Deps.AddRange(depNames);
result.Add(refInfo);
}
catch (Exception)
{
}
}
return(result);
}
public static void PathAssemblyResolverBasicPathWithRunningAssemblies()
{
string coreAssemblyPath = TestUtils.GetPathToCoreAssembly();
// Obtain this test class
string thisAssemblyPath = AssemblyPathHelper.GetAssemblyLocation(typeof(MetadataLoadContextTests).Assembly);
var resolver = new PathAssemblyResolver(new string[] { coreAssemblyPath, thisAssemblyPath });
using (MetadataLoadContext lc = new MetadataLoadContext(resolver, TestUtils.GetNameOfCoreAssembly()))
{
AssemblyName thisAssemblyName = typeof(MetadataLoadContextTests).Assembly.GetName();
Assembly assembly = lc.LoadFromAssemblyName(thisAssemblyName);
Type t = assembly.GetType(typeof(MetadataLoadContextTests).FullName, throwOnError: true);
Assert.Equal(t.FullName, typeof(MetadataLoadContextTests).FullName);
Assert.Equal(t.Assembly.Location, thisAssemblyPath);
}
}
//
// 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);
}
}
using (var w = File.CreateText(OutputPath !))
EmitTable(w);
}
public static SemVersion GetAssemblyVersion(string assemblyName)
{
var runtimeAssemblies = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll");
var paths = new List <string>(runtimeAssemblies);
if (paths == null)
{
return(SemVersion.Parse("1.0.0"));
}
var resolver = new PathAssemblyResolver(paths);
var mlc = new MetadataLoadContext(resolver);
using (mlc)
{
var assembly = mlc.LoadFromAssemblyPath(assemblyName);
var productVersion = "1.0.0";
var attributes = assembly.CustomAttributes.ToList();
for (var i = 0; i < attributes.Count; i++)
{
var a = attributes[i];
try
{
var t = a.AttributeType.Name;
if (t == nameof(AssemblyInformationalVersionAttribute))
{
productVersion = (string)a.ConstructorArguments.First().Value;
break;
}
}
catch (FileNotFoundException ex)
{
// We are missing the required dependency assembly.
Console.WriteLine($"Error while getting attribute type: {ex.Message}");
}
}
var version = SemVersion.Parse(productVersion);
return(version);
}
}
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);
using 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);
}
}
string tmpFileName = Path.GetTempFileName();
using (var w = File.CreateText(tmpFileName))
{
EmitPInvokeTable(w, modules, pinvokes);
EmitNativeToInterp(w, callbacks);
}
if (Utils.CopyIfDifferent(tmpFileName, OutputPath, useHash: false))
{
Log.LogMessage(MessageImportance.Low, $"Generating pinvoke table to '{OutputPath}'.");
}
else
{
Log.LogMessage(MessageImportance.Low, $"PInvoke table in {OutputPath} is unchanged.");
}
FileWrites = OutputPath;
File.Delete(tmpFileName);
}
private AssemblyInformation LoadManagedAssembly(string entryDll)
{
var fileInfo = new FileInfo(entryDll);
var directoryPath = Path.GetDirectoryName(entryDll);
if (directoryPath == null)
{
throw new FileNotFoundException(entryDll);
}
var runtimeAssemblies = (AppDomain.CurrentDomain.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string)?.Split(Path.PathSeparator) ?? new string[0];
var resolver = new PathAssemblyResolver(runtimeAssemblies);
using var context = new MetadataLoadContext(resolver);
var assembly = context.LoadFromAssemblyPath(entryDll);
return(GetRootManaged(context, assembly.GetName(), directoryPath, fileInfo.Extension.Replace(".", "", StringComparison.InvariantCulture)));
}
private List <RefInfo> GetRefInfos(string srcDir, string package, string version, string sdkDir, string sdkVersion)
{
var brokenDependencies = new string[] { "netstandard" };
var result = new List <RefInfo>();
var packageDir = GetPackagePath(srcDir, package, version);
var frameworkDir = GetRefsDir(srcDir, package, version);
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 = $"@{package}.{version}//:{relative}/{name}";
var stdlibpath = GetStdlibPath(sdkDir, name, version, sdkVersion);
var refInfo = new RefInfo();
refInfo.Name = name.ToLower();
refInfo.Ref = refname;
refInfo.StdlibPath = stdlibpath;
refInfo.Deps.AddRange(depNames);
result.Add(refInfo);
}
catch (Exception)
{
}
}
return(result);
}
public static void SnippetsMetadataLoadContext()
{
//<SnippetRuntimeAssemblies>
// Get the array of runtime assemblies.
string[] runtimeAssemblies = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll");
// Create the list of assembly paths consisting of runtime assemblies and the inspected assembly.
var paths = new List <string>(runtimeAssemblies);
paths.Add("ExampleAssembly.dll");
// Create PathAssemblyResolver that can resolve assemblies using the created list.
var resolver = new PathAssemblyResolver(paths);
//</SnippetRuntimeAssemblies>
//<SnippetCreateContext>
var mlc = new MetadataLoadContext(resolver);
using (mlc)
{
// Load assembly into MetadataLoadContext.
Assembly assembly = mlc.LoadFromAssemblyPath("ExampleAssembly.dll");
AssemblyName name = assembly.GetName();
// Print assembly attribute information.
Console.WriteLine($"{name.Name} has following attributes: ");
foreach (CustomAttributeData attr in assembly.GetCustomAttributesData())
{
try
{
Console.WriteLine(attr.AttributeType);
}
catch (FileNotFoundException ex)
{
// We are missing the required dependency assembly.
Console.WriteLine($"Error while getting attribute type: {ex.Message}");
}
}
}
//</SnippetCreateContext>
}
public static List <RefInfo> GetSdkInfos(string sdkd, string package, Sdk sdk)
{
var brokenDependencies = new string[] { };
var result = new List <RefInfo>();
var sdkDir = Path.Combine(sdkd, "shared", package, sdk.InternalVersionFolder);
var dlls = Directory.GetFiles(sdkDir, "*.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 refInfo = new RefInfo();
refInfo.Name = name.ToLower();
refInfo.Version = metadata.GetName().Version.ToString();
refInfo.StdlibPath =
$"@core_sdk_{sdk.Version}//:core/shared/Microsoft.NETCore.App/{sdk.InternalVersionFolder}/{name}";
refInfo.Ref =
$"@core_sdk_{sdk.Version}//:core/shared/Microsoft.NETCore.App/{sdk.InternalVersionFolder}/{name}";
refInfo.Deps.AddRange(depNames);
result.Add(refInfo);
}
catch (Exception)
{
}
}
return(result);
}
public static void DuplicateSignedAndUnsignedAssemblies()
{
using (TempDirectory dir = new TempDirectory())
using (TempDirectory dir2 = new TempDirectory())
using (TempFile core = new TempFile(Path.Combine(dir.Path, TestData.s_PhonyCoreAssemblySimpleName), TestData.s_PhonyCoreAssemblyImage))
using (TempFile tf1 = new TempFile(Path.Combine(dir.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleSignedVersioned100Image))
using (TempFile tf2 = new TempFile(Path.Combine(dir2.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleUnsignedVersioned100Image))
{
var resolver = new PathAssemblyResolver(new string[] { core.Path, tf1.Path, tf2.Path });
using (var lc = new MetadataLoadContext(resolver, TestData.s_PhonyCoreAssemblyFullName))
{
Assert.Equal(1, lc.GetAssemblies().Count());
// These are treated as different since one contains a PublicKeyToken and one does not.
Assembly a1 = lc.LoadFromAssemblyName(TestData.s_SimpleUnsignedVersioned100FullName);
Assembly a2 = lc.LoadFromAssemblyName(TestData.s_SimpleSignedVersioned100FullName);
Assert.NotSame(a1, a2);
Assert.Equal(3, lc.GetAssemblies().Count());
}
}
}
private List <RefInfo> GetSdkInfos(string sdk, string package, string version)
{
var brokenDependencies = new string[] { };
var result = new List <RefInfo>();
var sdkDir = Path.Combine(sdk, "shared", package, version);
var dlls = Directory.GetFiles(sdkDir, "*.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 refInfo = new RefInfo();
refInfo.Name = name.ToLower();
refInfo.Deps.AddRange(depNames);
result.Add(refInfo);
}
catch (Exception)
{
}
}
return(result);
}
public static void DuplicateSignedAssembliesDifferentVersions()
{
using (TempDirectory dir = new TempDirectory())
using (TempDirectory dir2 = new TempDirectory())
using (TempFile core = new TempFile(Path.Combine(dir.Path, TestData.s_PhonyCoreAssemblySimpleName), TestData.s_PhonyCoreAssemblyImage))
using (TempFile tf1 = new TempFile(Path.Combine(dir.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleSignedVersioned100Image))
using (TempFile tf2 = new TempFile(Path.Combine(dir2.Path, TestData.s_SimpleVersionedShortName), TestData.s_SimpleSignedVersioned200Image))
{
var resolver = new PathAssemblyResolver(new string[] { core.Path, tf1.Path, tf2.Path });
using (var lc = new MetadataLoadContext(resolver, TestData.s_PhonyCoreAssemblyFullName))
{
Assert.Equal(1, lc.GetAssemblies().Count());
// Using simple name will find first assembly that matches.
Assembly a1 = lc.LoadFromAssemblyName(TestData.s_SimpleVersionedShortName);
Assembly a2 = lc.LoadFromAssemblyName(TestData.s_SimpleSignedVersioned100FullName);
Assembly a3 = lc.LoadFromAssemblyName(TestData.s_SimpleSignedVersioned200FullName);
Assert.True(object.ReferenceEquals(a1, a2) || object.ReferenceEquals(a1, a3));
Assert.Equal(3, lc.GetAssemblies().Count());
}
}
}
