private static Assembly GetRuntimeAssembly(string name)
{
var path = Assembly.GetEntryAssembly().Location;
var library = DependencyContext.Default.RuntimeLibraries.Where(x => x.Name.ToLower() == name.ToLower()).FirstOrDefault();
if (library == null)
{
return null;
}
var r = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[]
{
new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)),
new ReferenceAssemblyPathResolver(),
new PackageCompilationAssemblyResolver()
});
var wrapper = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
library.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths),
library.Dependencies,
library.Serviceable);
var assemblies = new List<string>();
r.TryResolveAssemblyPaths(wrapper, assemblies);
if (assemblies.Count > 0)
{
return AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblies[0]);
}
else
{
return null;
}
}
private static void FindDependency(Assembly assembly)
{
DependencyContext dependencyContext = DependencyContext.Load(assembly);
if (dependencyContext != null)
{
foreach (var compilationLibrary in dependencyContext.CompileLibraries)
{
if (!DependencyDLL.ContainsKey(compilationLibrary.Name) &&
!AppDomain.CurrentDomain.GetAssemblies().Any(a => a.FullName.Split(',')[0] == compilationLibrary.Name))
{
RuntimeLibrary library = dependencyContext.RuntimeLibraries.FirstOrDefault(runtime => runtime.Name == compilationLibrary.Name);
var cb = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
library.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths),
library.Dependencies,
library.Serviceable);
DependencyDLL[library.Name] = cb;
}
}
}
}
/// <summary>
/// 获取CLI版本号
/// </summary>
public static string GetCliVersion()
{
string[] dllNames =
{
"Microsoft.EntityFrameworkCore",
"Microsoft.Extensions.Configuration.Binder",
"Microsoft.Extensions.DependencyInjection",
"Microsoft.Extensions.DependencyInjection.Abstractions",
"Microsoft.Extensions.Configuration.Abstractions"
};
CompilationLibrary lib = null;
foreach (var dllName in dllNames)
{
lib = DependencyContext.Default.CompileLibraries.FirstOrDefault(m => m.Name == dllName);
if (lib != null)
{
break;
}
}
var cliVersion = lib?.Version;
return(cliVersion);
}
public bool TryResolveAssemblyPaths([NotNull] CompilationLibrary library, [NotNull][ItemNotNull] List <string> assemblies)
{
if (_nugetPackageDirectories.Count == 0 || !string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
foreach (var directory in _nugetPackageDirectories)
{
if (!ResolverUtils.TryResolvePackagePath(FileSystem, library, directory, out var packagePath))
{
continue;
}
if (!TryResolveFromPackagePath(library, packagePath, out var fullPathsFromPackage))
{
continue;
}
assemblies.AddRange(fullPathsFromPackage);
return(true);
}
return(false);
}
/// <summary>
/// Invoked when the resolution of an assembly fails.
/// </summary>
private Assembly OnResolving(AssemblyLoadContext context, AssemblyName assemblyName)
{
Debug.WriteLine($"<Coyote> Resolving assembly '{assemblyName.Name}'.");
RuntimeLibrary runtimeLibrary = this.DependencyContext.RuntimeLibraries.FirstOrDefault(
runtime => string.Equals(runtime.Name, assemblyName.Name, StringComparison.OrdinalIgnoreCase));
if (runtimeLibrary != null)
{
var assemblies = new List <string>();
var compilationLibrary = new CompilationLibrary(
runtimeLibrary.Type,
runtimeLibrary.Name,
runtimeLibrary.Version,
runtimeLibrary.Hash,
runtimeLibrary.RuntimeAssemblyGroups.SelectMany(group => group.AssetPaths),
runtimeLibrary.Dependencies,
runtimeLibrary.Serviceable);
if (this.AssemblyResolver.TryResolveAssemblyPaths(compilationLibrary, assemblies) &&
assemblies.Count > 0)
{
return(this.LoadContext.LoadFromAssemblyPath(assemblies[0]));
}
else
{
string directory = Path.GetDirectoryName(this.Assembly.Location);
string path = Directory.EnumerateFiles(directory, $"{runtimeLibrary.Name}.dll").FirstOrDefault();
return(this.LoadContext.LoadFromAssemblyPath(path));
}
}
return(null);
}
private Assembly OnResolvingLoadContextAssemblyReference(AssemblyLoadContext loadContext, AssemblyName assemblyName
, StringBinaryPredicate predicate)
{
bool TryResolveAssemblyPaths(out IEnumerable <string> assemblyPaths)
{
// ReSharper disable once RedundantEmptyObjectOrCollectionInitializer
var paths = (List <string>)(assemblyPaths = new List <string> {
});
var rl = FindMatchingLibrary(Context.RuntimeLibraries, assemblyName, predicate);
if (rl == null)
{
return(false);
}
var groups = rl.RuntimeAssemblyGroups;
var cl = new CompilationLibrary(rl.Type, rl.Name, rl.Version, rl.Hash
, groups.SelectMany(g => g.AssetPaths), rl.Dependencies, rl.Serviceable);
return(Resolver.TryResolveAssemblyPaths(cl, paths) && assemblyPaths.Any());
}
if (TryResolveAssemblyPaths(out var resolvedPaths))
{
return(resolvedPaths.Select(loadContext.LoadFromAssemblyPath).FirstOrDefault());
}
// TODO: TBD: which, it would seem, `additional´ reference paths are intended to augment the naturally resolved DC.
return(AdditionalReferencePaths.Select(GetFileNameWithoutExtension)
.Where(f => predicate(f, assemblyName.Name))
.Select(loadContext.LoadFromAssemblyPath).FirstOrDefault());
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List<string> assemblies)
{
if (!string.Equals(library.LibraryType, "package", StringComparison.OrdinalIgnoreCase))
{
return false;
}
if (!string.IsNullOrEmpty(_packageCacheDirectory))
{
var hashSplitterPos = library.Hash.IndexOf('-');
if (hashSplitterPos <= 0 || hashSplitterPos == library.Hash.Length - 1)
{
throw new InvalidOperationException($"Invalid hash entry '{library.Hash}' for package '{library.PackageName}'");
}
var hashAlgorithm = library.Hash.Substring(0, hashSplitterPos);
var cacheHashPath = Path.Combine(_packageCacheDirectory, $"{library.PackageName}.{library.Version}.nupkg.{hashAlgorithm}");
if (_fileSystem.File.Exists(cacheHashPath) &&
_fileSystem.File.ReadAllText(cacheHashPath) == library.Hash.Substring(hashSplitterPos + 1))
{
string packagePath;
if (ResolverUtils.TryResolvePackagePath(_fileSystem, library, _packageCacheDirectory, out packagePath))
{
assemblies.AddRange( ResolverUtils.ResolveFromPackagePath(_fileSystem, library, packagePath));
return true;
}
}
}
return false;
}
/// <inheritdoc/>
public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
{
var basePath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
@"c:\Program Files\dotnet\shared" :
"/usr/local/share/dotnet/shared";
var found = false;
foreach (var path in Directory.GetDirectories(basePath))
{
if (found)
{
break;
}
var versionDir = Path.Combine(path, library.Version);
if (Directory.Exists(versionDir))
{
foreach (var file in Directory.GetFiles(versionDir))
{
if (found)
{
break;
}
if (Path.GetFileName(file).ToLower().Equals(library.Name.ToLower() + ".dll"))
{
assemblies.Add(file);
found = true;
}
}
}
}
return(found);
}
/// <inheritdoc/>
public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
{
var basePath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)?
@"c:\Program Files\dotnet\store":
"/usr/local/share/dotnet/store";
var cpuBasePath = Path.Combine(basePath, RuntimeInformation.ProcessArchitecture.ToString().ToLowerInvariant());
if (!Directory.Exists(cpuBasePath))
{
return(false);
}
var found = false;
foreach (var targetFrameworkBasePath in Directory.GetDirectories(cpuBasePath))
{
var libraryBasePath = Path.Combine(targetFrameworkBasePath, library.Path);
foreach (var assembly in library.Assemblies)
{
var assemblyPath = Path.Combine(libraryBasePath, assembly);
if (File.Exists(assemblyPath))
{
assemblies.Add(assemblyPath);
found = true;
}
}
}
return(found);
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string>?assemblies)
{
ThrowHelper.ThrowIfNull(library);
if (_nugetPackageDirectories == null || _nugetPackageDirectories.Length == 0 ||
!string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
foreach (string directory in _nugetPackageDirectories)
{
string packagePath;
if (ResolverUtils.TryResolvePackagePath(_fileSystem, library, directory, out packagePath))
{
if (TryResolveFromPackagePath(_fileSystem, library, packagePath, out IEnumerable <string>?fullPathsFromPackage))
{
assemblies?.AddRange(fullPathsFromPackage);
return(true);
}
}
}
return(false);
}
private Assembly OnResolving(AssemblyLoadContext context, AssemblyName name)
{
bool NamesMatch(RuntimeLibrary runtime)
{
return(string.Equals(runtime.Name, name.Name, StringComparison.OrdinalIgnoreCase));
}
_logger.LogInformation("Loading " + name.FullName);
var library =
_dependencyContext.RuntimeLibraries.FirstOrDefault(NamesMatch);
if (library != null)
{
var wrapper = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
library.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths),
library.Dependencies,
library.Serviceable);
var assemblies = new List <string>();
_assemblyResolver.TryResolveAssemblyPaths(wrapper, assemblies);
if (assemblies.Count > 0)
{
return(_loadContext.LoadFromAssemblyPath(assemblies[0]));
}
}
_logger.LogWarning("Could not load assembly " + name.FullName);
return(null);
}
private Assembly LoadContextOnResolving(AssemblyLoadContext context, AssemblyName assemblyName)
{
bool NamesMatch(RuntimeLibrary runtime)
{
return(string.Equals(runtime.Name, assemblyName.Name, StringComparison.OrdinalIgnoreCase));
}
#if DEBUG
_trace.WriteLine($"[NetCoreAssemblyRuntimeLoader] Attempting to resolve [{assemblyName}]");
#endif
var runtimeLibrary = _dependencyContext.RuntimeLibraries.FirstOrDefault(x => NamesMatch(x));
if (runtimeLibrary != null)
{
#if DEBUG
_trace.WriteLine($"[NetCoreAssemblyRuntimeLoader] Found [{runtimeLibrary}]");
#endif
var wrapper = new CompilationLibrary(runtimeLibrary.Type, runtimeLibrary.Name,
runtimeLibrary.Version, runtimeLibrary.Hash,
runtimeLibrary.RuntimeAssemblyGroups.SelectMany(a => a.AssetPaths),
runtimeLibrary.Dependencies, runtimeLibrary.Serviceable);
var loadedAssemblies = new List <string>();
if (_resolver.TryResolveAssemblyPaths(wrapper, loadedAssemblies) && loadedAssemblies.Any())
{
return(_loadContext.LoadFromAssemblyPath(loadedAssemblies[0]));
}
}
return(null);
}
private Assembly OnResolving(AssemblyLoadContext context, AssemblyName name)
{
bool NamesMatch(RuntimeLibrary runtime) =>
string.Equals(runtime.Name, name.Name, StringComparison.OrdinalIgnoreCase);
var library = this.dependencyContext.RuntimeLibraries.FirstOrDefault(NamesMatch);
if (library is object)
{
var wrapper = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
library.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths),
library.Dependencies,
library.Serviceable);
var assemblies = new List <string>();
this.assemblyResolver.TryResolveAssemblyPaths(wrapper, assemblies);
if (assemblies.Count > 0)
{
return(this.loadContext.LoadFromAssemblyPath(assemblies[0]));
}
}
return(null);
}
/// <inheritdoc/>
public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
{
if (_nugetPackageDirectories == null || _nugetPackageDirectories.Length == 0 ||
!string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
foreach (var directory in _nugetPackageDirectories)
{
if (TryResolvePackagePath(library, directory, out string packagePath))
{
if (TryResolveFromPackagePath(library, packagePath, out IEnumerable <string> fullPathsFromPackage))
{
if (fullPathsFromPackage.Any())
{
assemblies.AddRange(fullPathsFromPackage);
}
else
{
var libPath = Path.Join(packagePath, "lib");
var dllName = $"{library.Name}.dll";
var paths = Directory.EnumerateFiles(libPath, dllName, SearchOption.AllDirectories);
assemblies.AddRange(paths);
}
return(true);
}
}
}
return(false);
}
private Assembly AssemblyLoadContextResolving(AssemblyLoadContext context, AssemblyName name)
{
// Attempt to resolve the library from one of the dependency contexts.
var library = _resolverDependencyContext?.RuntimeLibraries?.FirstOrDefault(NamesMatch);
if (library == null)
{
return(null);
}
var wrapper = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
library.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths),
library.Dependencies,
library.Serviceable);
var assemblies = new List <string>();
if (_assemblyResolver.TryResolveAssemblyPaths(wrapper, assemblies))
{
foreach (var assembly in assemblies.Select(TryLoadAssemblyFromPath).Where(assembly => assembly != null))
{
return(assembly);
}
}
return(null);
bool NamesMatch(RuntimeLibrary runtime) => string.Equals(runtime.Name, name.Name, StringComparison.OrdinalIgnoreCase);
}
public void PassesLibraryToAllResolvers()
{
var fail = new Mock <ICompilationAssemblyResolver>();
var failTwo = new Mock <ICompilationAssemblyResolver>();
var resolvers = new[]
{
fail.Object,
failTwo.Object
};
var library = new CompilationLibrary(
string.Empty,
string.Empty,
string.Empty,
string.Empty,
Enumerable.Empty <string>(),
Enumerable.Empty <Dependency>(),
false);
var resolver = new CompositeCompilationAssemblyResolver(resolvers);
var result = resolver.TryResolveAssemblyPaths(library, null);
fail.Verify(r => r.TryResolveAssemblyPaths(library, null), Times.Once());
failTwo.Verify(r => r.TryResolveAssemblyPaths(library, null), Times.Once());
}
public void PopulatedAssemblies()
{
var fail = new Mock <ICompilationAssemblyResolver>();
var success = new Mock <ICompilationAssemblyResolver>();
success.Setup(r => r.TryResolveAssemblyPaths(It.IsAny <CompilationLibrary>(), It.IsAny <List <string> >()))
.Returns(true)
.Callback((CompilationLibrary l, List <string> a) =>
{
a.Add("Assembly");
});
var resolvers = new[]
{
fail.Object,
success.Object
};
var assemblies = new List <string>();
var library = new CompilationLibrary(
string.Empty,
string.Empty,
string.Empty,
string.Empty,
Enumerable.Empty <string>(),
Enumerable.Empty <Dependency>(),
false);
var resolver = new CompositeCompilationAssemblyResolver(resolvers);
var result = resolver.TryResolveAssemblyPaths(library, assemblies);
assemblies.Should().Contain("Assembly");
}
public void ResolveDependencies(CompilationLibrary library, List <CompilationLibrary> compileLibraries, string[] packageFolders, List <AssemblyInfo> assemblyReferences)
{
if (library.Name == "NETStandard.Library" || _resolvedDependencies.Any(x => x.Name == library.Name))
{
return;
}
_resolvedDependencies.Add(library);
foreach (var dependency in library.Dependencies)
{
var dep = compileLibraries.FirstOrDefault(x => x.Name.Equals(dependency.Name));
if (dep.Assemblies != null && dep.Assemblies.Count() != 0 && !dep.Assemblies[0].EndsWith("_._"))
{
bool packageFound = AddAssemblyReference(packageFolders, dep, assemblyReferences);
if (!packageFound)
{
throw new ScriptException($"Nuget package {dependency.Name} not found.");
}
ResolveDependencies(dep, compileLibraries, packageFolders, assemblyReferences);
}
}
}
public T Resolve <T>()
where T : class
{
IEnumerable <RuntimeLibrary> libraries = this.DependencyContext.RuntimeLibraries;
if (libraries != null)
{
foreach (RuntimeLibrary library in libraries)
{
var wrapper = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
library.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths),
library.Dependencies,
library.Serviceable);
var assemblies = new List <string>();
this._assemblyResolver.TryResolveAssemblyPaths(wrapper, assemblies);
if (assemblies.Count > 0)
{
foreach (string path in assemblies)
{
this.LoadContext.LoadFromAssemblyPath(path);
Assembly.UnsafeLoadFrom(path);
}
}
}
}
return((T)Activator.CreateInstance(this.Assembly.GetTypes().FirstOrDefault(p => typeof(T).IsAssignableFrom(p))));
}
/// <inheritdoc/>
public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
{
var basePath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)?
@"c:\Program Files\dotnet\sdk\NuGetFallbackFolder":
"/usr/local/share/dotnet/sdk/NuGetFallbackFolder";
if (!Directory.Exists(basePath))
{
return(false);
}
var found = false;
var libraryBasePath = Path.Combine(basePath, library.Path);
foreach (var assembly in library.Assemblies)
{
var assemblyPath = Path.Combine(libraryBasePath, assembly);
if (File.Exists(assemblyPath))
{
assemblies.Add(assemblyPath);
found = true;
}
}
return(found);
}
private Assembly Resolve(AssemblyLoadContext context, AssemblyName assemblyName)
{
var dependency = _dependencyContext.RuntimeLibraries.SingleOrDefault(d => d.Name.Equals(assemblyName.Name, StringComparison.OrdinalIgnoreCase));
if (dependency == null)
{
return(null);
}
var library = new CompilationLibrary(
dependency.Type,
dependency.Name,
dependency.Version,
dependency.Hash,
dependency.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths),
dependency.Dependencies,
dependency.Serviceable);
var assemblies = new List <string>();
if (_resolver.TryResolveAssemblyPaths(library, assemblies) && assemblies.Count > 0)
{
try
{
return(_assemblyLoadContext.LoadFromAssemblyPath(assemblies[0]));
}
catch (Exception e)
{
Debug.Write(e);
}
}
return(null);
}
/// <inheritdoc/>
protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
{
if (unmanagedAssemblyMap.TryGetValue(unmanagedDllName, out var libraryTuple))
{
var library = libraryTuple.Item1;
var assetGroup = libraryTuple.Item2;
var wrapper = new CompilationLibrary(library.Type, library.Name, library.Version, library.Hash,
assetGroup.AssetPaths, library.Dependencies, library.Serviceable);
var assemblies = new List <string>();
if (assemblyResolver.TryResolveAssemblyPaths(wrapper, assemblies))
{
var resolvedAssemblyPath = assemblies.FirstOrDefault(a => string.Equals(unmanagedDllName, Path.GetFileName(a), StringComparison.OrdinalIgnoreCase));
if (resolvedAssemblyPath != null)
{
var assembly = LoadUnmanagedDllFromPath(resolvedAssemblyPath);
if (assembly != null)
{
return(assembly);
}
}
}
}
return(base.LoadUnmanagedDll(unmanagedDllName));
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
{
if (!string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (!string.IsNullOrEmpty(_packageCacheDirectory))
{
var hashSplitterPos = library.Hash.IndexOf('-');
if (hashSplitterPos <= 0 || hashSplitterPos == library.Hash.Length - 1)
{
throw new InvalidOperationException($"Invalid hash entry '{library.Hash}' for package '{library.Name}'");
}
string packagePath;
if (ResolverUtils.TryResolvePackagePath(library, _packageCacheDirectory, out packagePath))
{
var hashAlgorithm = library.Hash.Substring(0, hashSplitterPos);
var cacheHashPath = Path.Combine(packagePath, $"{library.Name}.{library.Version}.nupkg.{hashAlgorithm}");
if (File.Exists(cacheHashPath) &&
File.ReadAllText(cacheHashPath) == library.Hash.Substring(hashSplitterPos + 1))
{
assemblies.AddRange(ResolverUtils.ResolveFromPackagePath(library, packagePath));
return(true);
}
}
}
return(false);
}
private Assembly OnResolving(AssemblyLoadContext context, AssemblyName name)
{
var library = _dependencyContext.RuntimeLibraries.FirstOrDefault((library) =>
{
return(string.Equals(library.Name, name.Name, StringComparison.OrdinalIgnoreCase));
});
if (library != null)
{
var wrapper = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
library.RuntimeAssemblyGroups.SelectMany(group => group.AssetPaths),
library.Dependencies,
library.Serviceable);
var assemblies = new List <string>();
_assemblyResolver.TryResolveAssemblyPaths(wrapper, assemblies);
if (assemblies.Count > 0)
{
return(_loadContext.LoadFromAssemblyPath(assemblies[0]));
}
}
return(null);
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List <string> assemblies)
{
if (!string.Equals(library.Type, "reference", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
var paths = new List <string>();
foreach (var assembly in library.Assemblies)
{
var path = Path.Combine(ApplicationEnvironment.ApplicationBasePath, assembly);
if (!File.Exists(path))
{
return(false);
}
paths.Add(path);
}
assemblies.AddRange(paths);
return(true);
}
private Assembly ResolveAssembly(AssemblyLoadContext context, AssemblyName name)
{
var library = FindMatchingLibrary(this.dependencyContext.RuntimeLibraries, name);
if (library == null)
{
return(null);
}
var wrapper = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
library.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths),
library.Dependencies,
library.Serviceable);
var assemblyPaths = new List <string>();
this.assemblyResolver.TryResolveAssemblyPaths(wrapper, assemblyPaths);
if (assemblyPaths.Count == 0)
{
var matches = from refAssemblyPath in this.ReferencePath
where Path.GetFileNameWithoutExtension(refAssemblyPath).Equals(name.Name, StringComparison.OrdinalIgnoreCase)
select context.LoadFromAssemblyPath(refAssemblyPath);
return(matches.FirstOrDefault());
}
return(assemblyPaths.Select(context.LoadFromAssemblyPath).FirstOrDefault());
}
public DependencyContext Build()
{
bool includeCompilationLibraries = _compilationOptions != null;
IEnumerable <LockFileTargetLibrary> runtimeExports = _projectContext.GetRuntimeLibraries(_privateAssetPackageIds);
IEnumerable <LockFileTargetLibrary> compilationExports =
includeCompilationLibraries ?
_projectContext.GetCompileLibraries(_privateAssetPackageIds) :
Enumerable.Empty <LockFileTargetLibrary>();
var dependencyLookup = compilationExports
.Concat(runtimeExports)
.Distinct()
.Select(library => new Dependency(library.Name, library.Version.ToString()))
.ToDictionary(dependency => dependency.Name, StringComparer.OrdinalIgnoreCase);
var libraryLookup = new LockFileLookup(_projectContext.LockFile);
var runtimeSignature = GenerateRuntimeSignature(runtimeExports);
RuntimeLibrary projectRuntimeLibrary = GetProjectRuntimeLibrary(
_mainProjectInfo,
_projectContext,
dependencyLookup);
IEnumerable <RuntimeLibrary> runtimeLibraries =
new[] { projectRuntimeLibrary }
.Concat(GetLibraries(runtimeExports, libraryLookup, dependencyLookup, runtime: true).Cast <RuntimeLibrary>());
IEnumerable <CompilationLibrary> compilationLibraries;
if (includeCompilationLibraries)
{
CompilationLibrary projectCompilationLibrary = GetProjectCompilationLibrary(
_mainProjectInfo,
_projectContext,
dependencyLookup);
compilationLibraries =
new[] { projectCompilationLibrary }
.Concat(GetFrameworkLibraries())
.Concat(GetLibraries(compilationExports, libraryLookup, dependencyLookup, runtime: false).Cast <CompilationLibrary>());
}
else
{
compilationLibraries = Enumerable.Empty <CompilationLibrary>();
}
var targetInfo = new TargetInfo(
_projectContext.LockFileTarget.TargetFramework.DotNetFrameworkName,
_projectContext.LockFileTarget.RuntimeIdentifier,
runtimeSignature,
_projectContext.IsPortable);
return(new DependencyContext(
targetInfo,
_compilationOptions ?? CompilationOptions.Default,
compilationLibraries,
runtimeLibraries,
new RuntimeFallbacks[] { }));
}
private Assembly?OnResolving(AssemblyLoadContext context, AssemblyName name)
{
//hack for loaded assemblies
if (name.Name == "Mapster")
{
return(typeof(TypeAdapterConfig).Assembly);
}
if (name.Name == "Mapster.Core")
{
return(typeof(MapperAttribute).Assembly);
}
if (name.Name == "System.Text.Json")
{
return(typeof(JsonIgnoreAttribute).Assembly);
}
var(library, assetPath) = (from lib in _dependencyContext.RuntimeLibraries
from grp in lib.RuntimeAssemblyGroups
where grp.Runtime == string.Empty
from path in grp.AssetPaths
where string.Equals(GetAssemblyName(path), name.Name, StringComparison.OrdinalIgnoreCase)
select(lib, path)).FirstOrDefault();
if (library == null)
{
Console.WriteLine("Cannot find library: " + name.Name);
return(null);
}
try
{
var wrapped = new CompilationLibrary(
library.Type,
library.Name,
library.Version,
library.Hash,
new[] { assetPath },
library.Dependencies,
library.Serviceable);
var assemblies = new List <string>();
_assemblyResolver.TryResolveAssemblyPaths(wrapped, assemblies);
if (assemblies.Count == 0)
{
Console.WriteLine($"Cannot find assembly path: {name.Name} (type={library.Type}, version={library.Version})");
return(null);
}
return(_loadContext.LoadFromAssemblyPath(assemblies[0]));
}
catch (Exception ex)
{
Console.WriteLine($"Cannot find assembly path: {name.Name} (type={library.Type}, version={library.Version})");
Console.WriteLine("exception: " + ex.Message);
return(null);
}
}
internal static bool TryResolvePackagePath(IFileSystem fileSystem, CompilationLibrary library, string basePath, out string packagePath)
{
packagePath = Path.Combine(basePath, library.Name, library.Version);
if (fileSystem.Directory.Exists(packagePath))
{
return true;
}
return false;
}
internal static bool TryResolvePackagePath(CompilationLibrary library, string basePath, out string packagePath)
{
packagePath = Path.Combine(basePath, library.Name, library.Version);
if (Directory.Exists(packagePath))
{
return(true);
}
return(false);
}
/// <summary>
/// 构造一个 <see cref="AssemblyDescriptor"/>。
/// </summary>
/// <param name="name">给定的名称。</param>
/// <param name="compiled">给定的已编译程序集。</param>
/// <param name="isItself">是否为已编译程序集自身（可选）。</param>
/// <param name="library">给定的 <see cref="CompilationLibrary"/>（可选）。</param>
public AssemblyDescriptor(string name, Assembly compiled,
bool?isItself = null, CompilationLibrary library = null)
{
Name = name.NotEmpty(nameof(name));
Compiled = compiled.NotNull(nameof(compiled));
IsItself = isItself ?? Name == compiled.GetDisplayName();
Library = library;
}
public DependencyContext Build(
SingleProjectInfo mainProjectInfo,
CompilationOptions compilationOptions,
LockFile lockFile,
NuGetFramework framework,
string runtime)
{
bool includeCompilationLibraries = compilationOptions != null;
LockFileTarget lockFileTarget = lockFile.GetTarget(framework, runtime);
IEnumerable <LockFileTargetLibrary> runtimeExports = lockFileTarget.GetRuntimeLibraries();
IEnumerable <LockFileTargetLibrary> compilationExports =
includeCompilationLibraries ?
lockFileTarget.GetCompileLibraries() :
Enumerable.Empty <LockFileTargetLibrary>();
var dependencyLookup = compilationExports
.Concat(runtimeExports)
.Distinct()
.Select(library => new Dependency(library.Name, library.Version.ToString()))
.ToDictionary(dependency => dependency.Name, StringComparer.OrdinalIgnoreCase);
var libraryLookup = lockFile.Libraries.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase);
var runtimeSignature = GenerateRuntimeSignature(runtimeExports);
IEnumerable <RuntimeLibrary> runtimeLibraries =
GetLibraries(runtimeExports, libraryLookup, dependencyLookup, runtime: true).Cast <RuntimeLibrary>();
IEnumerable <CompilationLibrary> compilationLibraries;
if (includeCompilationLibraries)
{
CompilationLibrary projectCompilationLibrary = GetProjectCompilationLibrary(
mainProjectInfo,
lockFile,
lockFileTarget,
dependencyLookup);
compilationLibraries = new[] { projectCompilationLibrary }
.Concat(
GetLibraries(compilationExports, libraryLookup, dependencyLookup, runtime: false)
.Cast <CompilationLibrary>());
}
else
{
compilationLibraries = Enumerable.Empty <CompilationLibrary>();
}
return(new DependencyContext(
new TargetInfo(framework.DotNetFrameworkName, runtime, runtimeSignature, lockFileTarget.IsPortable()),
compilationOptions ?? CompilationOptions.Default,
compilationLibraries,
runtimeLibraries,
new RuntimeFallbacks[] { }));
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List<string> assemblies)
{
var isProject = string.Equals(library.LibraryType, "project", StringComparison.OrdinalIgnoreCase);
if (!isProject &&
!string.Equals(library.LibraryType, "package", StringComparison.OrdinalIgnoreCase) &&
!string.Equals(library.LibraryType, "referenceassembly", StringComparison.OrdinalIgnoreCase))
{
return false;
}
var refsPath = Path.Combine(_basePath, "refs");
var hasRefs = _fileSystem.Directory.Exists(refsPath);
// Resolving packages and reference assebmlies requires refs folder to exist
if (!isProject && !hasRefs)
{
return false;
}
var directories = new List<string>()
{
_basePath
};
if (hasRefs)
{
directories.Insert(0, refsPath);
}
foreach (var assembly in library.Assemblies)
{
bool resolved = false;
var assemblyFile = Path.GetFileName(assembly);
foreach (var directory in directories)
{
string fullName;
if (ResolverUtils.TryResolveAssemblyFile(_fileSystem, directory, assemblyFile, out fullName))
{
assemblies.Add(fullName);
resolved = true;
break;
}
}
if (!resolved)
{
throw new InvalidOperationException(
$"Can not find assembly file {assemblyFile} at '{string.Join(",", directories)}'");
}
}
return true;
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List<string> assemblies)
{
foreach (var resolver in _resolvers)
{
if (resolver.TryResolveAssemblyPaths(library, assemblies))
{
return true;
}
}
return false;;
}
internal static IEnumerable<string> ResolveFromPackagePath(IFileSystem fileSystem, CompilationLibrary library, string basePath)
{
foreach (var assembly in library.Assemblies)
{
string fullName;
if (!TryResolveAssemblyFile(fileSystem, basePath, assembly, out fullName))
{
throw new InvalidOperationException($"Can not find assembly file for package {library.Name} at '{fullName}'");
}
yield return fullName;
}
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List<string> assemblies)
{
if (string.IsNullOrEmpty(_nugetPackageDirectory) ||
!string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))
{
return false;
}
string packagePath;
if (ResolverUtils.TryResolvePackagePath(_fileSystem, library, _nugetPackageDirectory, out packagePath))
{
assemblies.AddRange(ResolverUtils.ResolveFromPackagePath(_fileSystem, library, packagePath));
return true;
}
return false;
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List<string> assemblies)
{
if (!string.Equals(library.LibraryType, "referenceassembly", StringComparison.OrdinalIgnoreCase))
{
return false;
}
foreach (var assembly in library.Assemblies)
{
string fullName;
if (!TryResolveReferenceAssembly(assembly, out fullName))
{
throw new InvalidOperationException($"Can not find reference assembly '{assembly}' file for package {library.PackageName}");
}
assemblies.Add(fullName);
}
return true;
}
public DependencyContext Create(
string target = null,
string runtime = null,
bool? isPortable = null,
CompilationOptions compilationOptions = null,
CompilationLibrary[] compileLibraries = null,
RuntimeLibrary[] runtimeLibraries = null,
IReadOnlyList<KeyValuePair<string, string[]>> runtimeGraph = null)
{
return new DependencyContext(
target ?? string.Empty,
runtime ?? string.Empty,
isPortable ?? false,
compilationOptions ?? CompilationOptions.Default,
compileLibraries ?? new CompilationLibrary[0],
runtimeLibraries ?? new RuntimeLibrary[0],
runtimeGraph ?? new KeyValuePair<string, string[]>[0]
);
}
public DependencyContext Create(
string target = null,
string runtime = null,
bool? isPortable = null,
CompilationOptions compilationOptions = null,
CompilationLibrary[] compileLibraries = null,
RuntimeLibrary[] runtimeLibraries = null,
IReadOnlyList<RuntimeFallbacks> runtimeGraph = null,
string runtimeSignature = null)
{
return new DependencyContext(new TargetInfo(
target ?? "DefaultTarget",
runtime ?? string.Empty,
runtimeSignature ?? string.Empty,
isPortable ?? false),
compilationOptions ?? CompilationOptions.Default,
compileLibraries ?? new CompilationLibrary[0],
runtimeLibraries ?? new RuntimeLibrary[0],
runtimeGraph ?? new RuntimeFallbacks[0]
);
}
public bool TryResolveAssemblyPaths(CompilationLibrary library, List<string> assemblies)
{
var isProject = string.Equals(library.Type, "project", StringComparison.OrdinalIgnoreCase) ||
string.Equals(library.Type, "msbuildproject", StringComparison.OrdinalIgnoreCase);
var isPackage = string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase);
if (!isProject &&
!isPackage &&
!string.Equals(library.Type, "referenceassembly", StringComparison.OrdinalIgnoreCase))
{
return false;
}
var refsPath = Path.Combine(_basePath, RefsDirectoryName);
var isPublished = _fileSystem.Directory.Exists(refsPath);
// Resolving reference assebmlies requires refs folder to exist
if (!isProject && !isPackage && !isPublished)
{
return false;
}
var directories = new List<string>()
{
_basePath
};
if (isPublished)
{
directories.Insert(0, refsPath);
}
// Only packages can come from shared runtime
var sharedPath = _dependencyContextPaths.SharedRuntime;
if (isPublished && isPackage && !string.IsNullOrEmpty(sharedPath))
{
var sharedDirectory = Path.GetDirectoryName(sharedPath);
var sharedRefs = Path.Combine(sharedDirectory, RefsDirectoryName);
if (_fileSystem.Directory.Exists(sharedRefs))
{
directories.Add(sharedRefs);
}
directories.Add(sharedDirectory);
}
foreach (var assembly in library.Assemblies)
{
bool resolved = false;
var assemblyFile = Path.GetFileName(assembly);
foreach (var directory in directories)
{
string fullName;
if (ResolverUtils.TryResolveAssemblyFile(_fileSystem, directory, assemblyFile, out fullName))
{
assemblies.Add(fullName);
resolved = true;
break;
}
}
if (!resolved)
{
// throw in case when we are published app and nothing found
// because we cannot rely on nuget package cache in this case
if (isPublished)
{
throw new InvalidOperationException(
$"Can not find assembly file {assemblyFile} at '{string.Join(",", directories)}'");
}
return false;
}
}
return true;
}
