ICyclicWorker CyclicWorkerContexts(DependencyContext context)
{
if (typeof(IOptionsDialogWatcher).IsAssignableFrom(context.ImplementationType))
return _container.GetInstance<CyclicBackgroundWorker>();
return _container.GetInstance<CyclicWorker>();
}
public JObject Save(DependencyContext dependencyContext)
{
using (var memoryStream = new MemoryStream())
{
new DependencyContextWriter().Write(dependencyContext, memoryStream);
using (var readStream = new MemoryStream(memoryStream.ToArray()))
{
using (var textReader = new StreamReader(readStream))
{
using (var reader = new JsonTextReader(textReader))
{
return JObject.Load(reader);
}
}
}
}
}
public void GetRuntimeAssemblyNamesExtractsCorrectAssemblyName(string path, string expected)
{
var context = new DependencyContext(new TargetInfo(".NETStandard,Version=v1.3", string.Empty, string.Empty, true),
compilationOptions: CompilationOptions.Default,
compileLibraries: new CompilationLibrary[] { },
runtimeLibraries: new[] {
new RuntimeLibrary("package", "System.Banana", "1.0.0", "hash",
new [] {
new RuntimeAssetGroup(string.Empty, Path.Combine("lib", path))
},
new RuntimeAssetGroup[] { },
new ResourceAssembly[] { },
new Dependency[] { },
serviceable: false)
},
runtimeGraph: new RuntimeFallbacks[] { });
var assets = context.GetDefaultAssemblyNames();
assets.Should().OnlyContain(a => a.Name == expected);
}
private static IEnumerable <Assembly> LoadAdditionalApplicationParts(
Assembly entryAssembly,
DependencyContext dependencyContext,
IReadOnlyDictionary <string, AssemblyPart> existingAssemblyParts,
IEnumerable <IAssemblyDiscoveryRule> rules
)
{
var assemblyPartsToAdd = new Dictionary <string, AssemblyPart>();
var context = new AssemblyDiscoveryRuleContext(entryAssembly);
var candidateLibraries = dependencyContext
.RuntimeLibraries
.Where(l => !existingAssemblyParts.ContainsKey(l.Name) && rules.Any(r => r.CanInclude(l, context)));
foreach (var assembly in candidateLibraries
.SelectMany(l => l.GetDefaultAssemblyNames(dependencyContext))
.Select(Assembly.Load))
{
yield return(assembly);
}
}
private List <Assembly> GetAssemblies(NacosSdkOptions options)
{
var assemblies = new List <Assembly>();
if (options.ConfigFilterAssemblies == null || !options.ConfigFilterAssemblies.Any())
{
return(assemblies);
}
DependencyContext context = DependencyContext.Default;
var libs = context.CompileLibraries.Where(lib => options.ConfigFilterAssemblies.Contains(lib.Name));
foreach (var lib in libs)
{
var assembly = Assembly.Load(new AssemblyName(lib.Name));
assemblies.Add(assembly);
}
return(assemblies);
}
public override IEnumerable <PPtr <Object> > FetchDependencies(DependencyContext context)
{
foreach (PPtr <Object> asset in base.FetchDependencies(context))
{
yield return(asset);
}
yield return(context.FetchDependency(SkyboxMaterial, SkyboxMaterialName));
yield return(context.FetchDependency(HaloTexture, HaloTextureName));
yield return(context.FetchDependency(SpotCookie, SpotCookieName));
yield return(context.FetchDependency(CustomReflection, CustomReflectionName));
if (IsReadGeneratedSkyboxReflection(context.Version, context.Flags))
{
yield return(context.FetchDependency(GeneratedSkyboxReflection, GeneratedSkyboxReflectionName));
}
yield return(context.FetchDependency(Sun, SunName));
}
public void Build()
{
var dependencyContext = DependencyContext.Load(Assembly.GetEntryAssembly());
IEnumerable <Assembly> assemblys = dependencyContext.RuntimeLibraries
.SelectMany(p => p.GetDefaultAssemblyNames(dependencyContext))
.Select(Assembly.Load);
var types = assemblys.SelectMany(p => p.GetTypes());
foreach (var type in types)
{
if (!typeof(IDomainService).GetTypeInfo().IsAssignableFrom(type))
{
continue;
}
if (!type.GetTypeInfo().IsClass)
{
continue;
}
this._services.AddSingleton(type);
}
}
public CustomAssemblyResolver(string assemblyDirectory)
{
RemoveSearchDirectory(".");
RemoveSearchDirectory("bin");
AddSearchDirectory(assemblyDirectory);
_dependencyContext = DepsJsonUtils.LoadDependencyContext(assemblyDirectory);
var runtimeConfigPath = Directory.GetFiles(assemblyDirectory, "*.runtimeconfig.dev.json", SearchOption.TopDirectoryOnly)
.FirstOrDefault();
if (runtimeConfigPath != null)
{
var runtimeConfigContent = File.ReadAllText(runtimeConfigPath);
foreach (var path in DepsJsonUtils.GetAdditionalPaths(runtimeConfigContent))
{
AddSearchDirectory(path);
}
}
}
private void ResolveDenpendency()
{
var assemblies = new DirectoryInfo(new FileInfo(CurrentAssembly.Location).DirectoryName).GetFiles("*.dll");
foreach (var item in assemblies)
{
if (item.FullName == CurrentAssembly.Location)
{
continue;
}
var assembly = LoadFromAssemblyPath(item.FullName);
if (!DependencyContext.Default.CompileLibraries.Any(m => m.Name == assembly.GetName().Name))
{
DependencyAssemblies.Add(assembly);
}
}
string currentName = CurrentAssembly.GetName().Name;
DependencyCompilationLibrary = DependencyContext.Load(CurrentAssembly).CompileLibraries.Where(de => de.Name != currentName && !DependencyContext.Default.CompileLibraries.Any(m => m.Name == de.Name)).ToList();
}
public void WriteDoesNotDisposeStream()
{
DependencyContext context = Create(
"Target",
"Target/runtime",
runtimeGraph: new[]
{
new RuntimeFallbacks("win7-x64", new [] { "win6", "win5" }),
new RuntimeFallbacks("win8-x64", new [] { "win7-x64" }),
});
DisposeAwareMemoryStream stream = new DisposeAwareMemoryStream();
using (stream)
{
new DependencyContextWriter().Write(context, stream);
Assert.False(stream.IsDisposed);
}
Assert.True(stream.IsDisposed);
}
public static IEnumerable <Assembly> GetCandidateAssemblies(params string[] tagAssemblies)
{
if (tagAssemblies == null)
{
throw new ArgumentNullException(nameof(tagAssemblies));
}
if (tagAssemblies.Length == 0)
{
throw new ArgumentException("At least one tag assembly name must be specified.", nameof(tagAssemblies));
}
var context = DependencyContext.Load(Assembly.GetEntryAssembly());
var loadContext = AssemblyLoadContext.Default;
var referenceAssemblies = new HashSet <string>(tagAssemblies, StringComparer.OrdinalIgnoreCase);
return(context.RuntimeLibraries
.Where(x => x.Dependencies.Any(d => referenceAssemblies.Contains(d.Name)))
.SelectMany(x => x.GetDefaultAssemblyNames(context))
.Select(x => loadContext.LoadFromAssemblyName(x)));
}
public void GetRuntimeAssemblyNamesExtractsCorrectAssemblyName(string path, string expected)
{
var context = new DependencyContext(new TargetInfo(".NETStandard,Version=v1.3", string.Empty, string.Empty, true),
compilationOptions: CompilationOptions.Default,
compileLibraries: new CompilationLibrary[] { },
runtimeLibraries: new[] {
new RuntimeLibrary("package", "System.Banana", "1.0.0", "hash",
new [] {
new RuntimeAssetGroup(string.Empty, Path.Combine("lib", path))
},
new RuntimeAssetGroup[] { },
new ResourceAssembly[] { },
new Dependency[] { },
serviceable: false)
},
runtimeGraph: new RuntimeFallbacks[] { });
var assets = context.GetDefaultAssemblyNames();
assets.Should().OnlyContain(a => a.Name == expected);
}
private void ExecuteCore()
{
DependencyContext context;
using (var depsStream = File.OpenRead(DepsFilePath))
{
context = new DependencyContextJsonReader().Read(depsStream);
}
LockFile lockFile = LockFileUtilities.GetLockFile(AssetsFilePath, NullLogger.Instance);
if (lockFile == null)
{
throw new ArgumentException($"Could not load a LockFile at '{AssetsFilePath}'.", nameof(AssetsFilePath));
}
var manager = new RuntimeGraphManager();
var graph = manager.Collect(lockFile);
var expandedGraph = manager.Expand(graph, Runtime);
var trimmedRuntimeLibraries = context.RuntimeLibraries;
if (PackagesToRemove != null && PackagesToRemove.Any())
{
trimmedRuntimeLibraries = RuntimeReference.RemoveReferences(context.RuntimeLibraries, PackagesToRemove);
}
context = new DependencyContext(
context.Target,
context.CompilationOptions,
context.CompileLibraries,
trimmedRuntimeLibraries,
expandedGraph
);
using (var depsStream = File.Create(DepsFilePath))
{
new DependencyContextWriter().Write(context, depsStream);
}
}
public void PopulateFeature(IEnumerable <ApplicationPart> parts, MetadataReferenceFeature feature)
{
var libraryPaths = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var assemblyPart in parts.OfType <AssemblyPart>())
{
var dependencyContext = DependencyContext.Load(assemblyPart.Assembly);
if (dependencyContext != null)
{
foreach (var library in dependencyContext.CompileLibraries)
{
if (string.Equals("reference", library.Type, StringComparison.OrdinalIgnoreCase))
{
foreach (var libraryAssembly in library.Assemblies)
{
libraryPaths.Add(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, libraryAssembly));
}
}
else
{
try
{
foreach (var path in library.ResolveReferencePaths())
{
libraryPaths.Add(path);
}
}
catch (InvalidOperationException)
{
if (PluginManagerService.GetPluginManager().PluginLoaded(library.Name + ".dll",
out int version, out string module))
{
libraryPaths.Add(module);
}
else
{
throw;
}
}
}
/// <summary>
/// Configure the Application Blocks and <see cref="Container">composition root</see>
/// and build the application's <see cref="ConsoleApplicationContext" />.
/// </summary>
/// <param name="dependencyContext">
/// Optional: A <see cref="DependencyContext" /> to use for all registration
/// discovery.
/// </param>
/// <returns>
/// The <see cref="ConsoleApplicationContext" /> that will serve as the run context of
/// your console application
/// </returns>
public ConsoleApplicationContext Build <TAppConfigInterface, TAppConfigImplementation>(
DependencyContext dependencyContext = null
)
where TAppConfigInterface : class, IApplicationConfiguration
where TAppConfigImplementation : class, TAppConfigInterface
{
var container = new Container();
container.Options.DefaultLifestyle = defaultLifestyle;
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
var frameworkConfiguration = frameworkConfigurationBuilder.Build();
container
.AddApplicationConfiguration <TAppConfigInterface, TAppConfigImplementation>(frameworkConfiguration, hostingEnvironment)
.AddEventLogging(defaultLifestyle)
.AddCommands(defaultLifestyle, dependencyContext)
.AddBootstrappers(dependencyContext);
foreach (var module in modules)
{
module.RegisterServices(container);
}
container.Verify();
if (container.GetRegistration(typeof(IEnumerable <IBootstrapper>)) != null)
{
using (AsyncScopedLifestyle.BeginScope(container))
{
// Resolve and run IBootstrappers
foreach (var bootstrapper in container.GetAllInstances <IBootstrapper>())
{
bootstrapper.Bootstrap();
}
}
}
return(new ConsoleApplicationContext(container));
}
static List <IRunnerReporter> GetAvailableRunnerReporters()
{
var result = new List <IRunnerReporter>();
var dependencyModel = DependencyContext.Load(typeof(Program).GetTypeInfo().Assembly);
var assemblyNames = new List <RuntimeAssembly>(dependencyModel.RuntimeLibraries.SelectMany(r => r.Assemblies));
foreach (var assemblyName in assemblyNames)
{
Assembly assembly;
try
{
assembly = Assembly.Load(assemblyName.Name);
}
catch
{
continue;
}
foreach (var type in assembly.DefinedTypes)
{
if (type == null || type.IsAbstract || type == typeof(DefaultRunnerReporter).GetTypeInfo() || type.ImplementedInterfaces.All(i => i != typeof(IRunnerReporter)))
{
continue;
}
var ctor = type.DeclaredConstructors.FirstOrDefault(c => c.GetParameters().Length == 0);
if (ctor == null)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Type {type.FullName} in assembly {assembly} appears to be a runner reporter, but does not have an empty constructor.");
Console.ResetColor();
continue;
}
result.Add((IRunnerReporter)ctor.Invoke(new object[0]));
}
}
return(result);
}
private IEnumerable <PluginDependency> GetPluginDependencies(DependencyContext pluginDependencyContext)
{
var dependencies = new List <PluginDependency>();
var runtimeId = GetCorrectRuntimeIdentifier();
var dependencyGraph = DependencyContext.Default.RuntimeGraph.FirstOrDefault(g => g.Runtime == runtimeId);
// List of supported runtimes, includes the default runtime and the fallbacks for this dependency context
var runtimes = new List <string> {
dependencyGraph?.Runtime
}.AddRangeToList <string>(dependencyGraph?.Fallbacks);
foreach (var runtimeLibrary in pluginDependencyContext.RuntimeLibraries)
{
var assets = runtimeLibrary.RuntimeAssemblyGroups.GetDefaultAssets();
foreach (var runtime in runtimes)
{
var runtimeSpecificGroup = runtimeLibrary.RuntimeAssemblyGroups.FirstOrDefault(g => g.Runtime == runtime);
if (runtimeSpecificGroup != null)
{
assets = runtimeSpecificGroup.AssetPaths;
break;
}
}
foreach (var asset in assets)
{
var path = asset.StartsWith("lib/")
? Path.GetFileName(asset)
: asset;
dependencies.Add(new PluginDependency
{
DependencyNameWithoutExtension = Path.GetFileNameWithoutExtension(asset),
SemVer = ParseSemVer(runtimeLibrary.Version),
DependencyPath = path,
ProbingPath = Path.Combine(runtimeLibrary.Name.ToLowerInvariant(), runtimeLibrary.Version, path)
});
}
}
return(dependencies);
}
public void Register(DependencyContext context)
{
var builder = context.ContainerBuilder;
var config = context.AppConfig as ServiceConfiguration;
//web helper
builder.RegisterType <WebHelper>().As <IWebHelper>().InstancePerLifetimeScope();
if (config.CachingEnabled)
{
//cache manager
builder.RegisterType <PerRequestCacheManager>().As <ICacheManager>().InstancePerLifetimeScope();
builder.RegisterType <MemoryCacheManager>().As <IStaticCacheManager>().SingleInstance();
}
else
{
//null logger
builder.RegisterType <NullCacheManager>().As <ICacheManager>().SingleInstance();
}
//logging
if (config.LoggingEnabled)
{
//default logger
builder.RegisterType <DefaultLogger>().As <ILogger>().InstancePerLifetimeScope();
}
else
{
//null logger
builder.RegisterType <NullLogger>().As <ILogger>().InstancePerLifetimeScope();
}
//dapper data context
builder.Register(c => ProviderFactory.GetProvider(config.DatabaseProviderName)).As <IDataProvider>().SingleInstance();
builder.Register(c => c.Resolve <IDataProvider>().CreateConnection(config.ConnectionString)).InstancePerLifetimeScope();
builder.Register(c => new DataContext(c.Resolve <IDataProvider>(), c.Resolve <IDbConnection>())).As <IDataContext>().InstancePerLifetimeScope();
//providers
builder.RegisterType <PictureProvider>().As <IPictureProvider>().InstancePerLifetimeScope();
}
private List <TypeInfo> GetTypeInfos(CrontabOptions options)
{
HashSet <Assembly> assemblys = new HashSet <Assembly>();
if (options.ScanAllAssembly)
{
var entryAssembly = Assembly.GetEntryAssembly();
var dependencyContext = DependencyContext.Load(entryAssembly);
if (dependencyContext == null)
{
assemblys.Add(entryAssembly);
}
else
{
var assName = Assembly.GetExecutingAssembly().GetName().Name;
var libs = dependencyContext.RuntimeLibraries.Where(lib => lib.Dependencies.Any(dep => string.Equals(assName, dep.Name, StringComparison.Ordinal)));
var assNames = libs.SelectMany(lib => lib.GetDefaultAssemblyNames(dependencyContext));
foreach (var name in assNames)
{
var assembly = Assembly.Load(new AssemblyName(name.Name));
assemblys.Add(assembly);
}
}
}
if (options.Assemblies != null && options.Assemblies.Count > 0)
{
foreach (var assembly in options.Assemblies)
{
assemblys.Add(assembly);
}
}
if (assemblys.Count == 0)
{
assemblys.Add(Assembly.GetEntryAssembly());
}
var types = assemblys.SelectMany(a => a.DefinedTypes.Where(y => y.GetCustomAttribute <CrontabJobAttribute>() != null)).ToList();
return(types);
}
public override IEnumerable <PPtr <Object> > FetchDependencies(DependencyContext context)
{
foreach (PPtr <Object> asset in base.FetchDependencies(context))
{
yield return(asset);
}
MonoBehaviourLayout layout = context.Layout.MonoBehaviour;
#if UNIVERSAL
yield return(context.FetchDependency(GeneratorAsset, layout.GeneratorAssetName));
#endif
yield return(context.FetchDependency(Script, layout.ScriptName));
if (Structure != null)
{
foreach (PPtr <Object> asset in context.FetchDependencies(Structure, Structure.Type.Name))
{
yield return(asset);
}
}
}
private static List <AssemblyData> ResolveAssemblies(DependencyContext dependencyContext)
{
return(dependencyContext.CompileLibraries
.SelectMany(l =>
{
try
{
var paths = l.ResolveReferencePaths();
return paths.Select(p => new AssemblyData
{
Library = l,
AssemblyFullPath = p,
AssemblyFileName = Path.GetFileNameWithoutExtension(p)
});
}
catch (Exception)
{
return Enumerable.Empty <AssemblyData>();
}
})
.ToList());
}
public override bool Execute()
{
LoadConflicts();
DependencyContext sourceDeps;
using (var sourceStream = File.Open(DepsFilePath, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete))
{
sourceDeps = new DependencyContextJsonReader().Read(sourceStream);
}
DependencyContext trimmedDeps = TrimConflicts(sourceDeps);
var writer = new DependencyContextWriter();
using (var fileStream = File.Create(DepsFilePath))
{
writer.Write(trimmedDeps, fileStream);
}
return(!Log.HasLoggedErrors);
}
public AssemblyResolver()
{
_resolverDependencyContext = DependencyContext.Load(typeof(AssemblyResolver).Assembly);
var codeGenPath = Path.GetDirectoryName(new Uri(typeof(AssemblyResolver).Assembly.CodeBase).LocalPath);
_assemblyResolver = new CompositeCompilationAssemblyResolver(
new ICompilationAssemblyResolver[]
{
new AppBaseCompilationAssemblyResolver(codeGenPath),
new ReferenceAssemblyPathResolver(),
new PackageCompilationAssemblyResolver()
});
AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly;
_loadContext = AssemblyLoadContext.GetLoadContext(typeof(AssemblyResolver).Assembly);
_loadContext.Resolving += AssemblyLoadContextResolving;
if (_loadContext != AssemblyLoadContext.Default)
{
AssemblyLoadContext.Default.Resolving += AssemblyLoadContextResolving;
}
}
public IEnumerable <PPtr <Object> > FetchDependencies(DependencyContext context)
{
if (Type == PrimitiveType.Complex)
{
if (IsArray)
{
ISerializableStructure[] structures = (ISerializableStructure[])Value;
foreach (PPtr <Object> asset in context.FetchDependencies(structures, Name))
{
yield return(asset);
}
}
else
{
ISerializableStructure structure = (ISerializableStructure)Value;
foreach (PPtr <Object> asset in context.FetchDependencies(structure, Name))
{
yield return(asset);
}
}
}
}
public IEnumerable <PPtr <Object> > FetchDependencies(DependencyContext context)
{
if (HasTerrainLayers(context.Version))
{
foreach (PPtr <Object> asset in context.FetchDependencies(TerrainLayers, TerrainLayersName))
{
yield return(asset);
}
}
else
{
foreach (PPtr <Object> asset in context.FetchDependencies(Splats, SplatsName))
{
yield return(asset);
}
}
foreach (PPtr <Object> asset in context.FetchDependencies(AlphaTextures, AlphaTexturesName))
{
yield return(asset);
}
}
protected override Assembly[] FindAllItems()
{
string[] filters =
{
"System",
"Microsoft",
"netstandard",
"dotnet",
"Window",
"mscorlib"
};
DependencyContext context = DependencyContext.Default;
List <string> names = new List <string>();
string[] dllNames = context.CompileLibraries.SelectMany(m => m.Assemblies).Distinct().Select(m => m.Replace(".dll", "")).ToArray();
names = (from name in dllNames
let i = name.LastIndexOf('/') + 1
select name.Substring(i, name.Length - i)).Where(c => !filters.Any(c.StartsWith))
.Distinct()
.ToList();
return(LoadFiles(names));
}
static List <IRunnerReporter> GetAvailableRunnerReporters()
{
var result = new List <IRunnerReporter>();
var dependencyModel = DependencyContext.Load(typeof(Program).GetTypeInfo().Assembly);
foreach (var assemblyName in dependencyModel.GetRuntimeAssemblyNames(RuntimeEnvironment.GetRuntimeIdentifier()))
{
try
{
var assembly = Assembly.Load(assemblyName);
foreach (var type in assembly.DefinedTypes)
{
#pragma warning disable CS0618
if (type == null || type.IsAbstract || type == typeof(DefaultRunnerReporter).GetTypeInfo() || type == typeof(DefaultRunnerReporterWithTypes).GetTypeInfo() || type.ImplementedInterfaces.All(i => i != typeof(IRunnerReporter)))
{
continue;
}
#pragma warning restore CS0618
var ctor = type.DeclaredConstructors.FirstOrDefault(c => c.GetParameters().Length == 0);
if (ctor == null)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Type {type.FullName} in assembly {assembly} appears to be a runner reporter, but does not have an empty constructor.");
Console.ResetColor();
continue;
}
result.Add((IRunnerReporter)ctor.Invoke(new object[0]));
}
}
catch
{
continue;
}
}
return(result);
}
public void GetCandidateLibraries_ReturnsLibrariesReferencingAnyMvcAssembly()
{
// Arrange
var dependencyContext = new DependencyContext(
new TargetInfo("framework", "runtime", "signature", isPortable: true),
CompilationOptions.Default,
new CompilationLibrary[0],
new[]
{
GetLibrary("Foo", "Microsoft.AspNetCore.Mvc.Core"),
GetLibrary("Bar", "Microsoft.AspNetCore.Mvc"),
GetLibrary("Qux", "Not.Mvc.Assembly", "Unofficial.Microsoft.AspNetCore.Mvc"),
GetLibrary("Baz", "Microsoft.AspNetCore.Mvc.Abstractions"),
},
Enumerable.Empty <RuntimeFallbacks>());
// Act
var candidates = DefaultAssemblyPartDiscoveryProvider.GetCandidateLibraries(dependencyContext);
// Assert
Assert.Equal(new[] { "Foo", "Bar", "Baz" }, candidates.Select(a => a.Name));
}
public static Assembly LoadPlugin(string path)
{
Assembly assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path);
_dependencyContext = DependencyContext.Load(assembly);
_assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[]
{
new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)),
new ReferenceAssemblyPathResolver(),
new PackageCompilationAssemblyResolver()
});
_loadContext = AssemblyLoadContext.GetLoadContext(assembly);
if (_loadContext != null)
{
_loadContext.Resolving += OnResolving;
}
return(assembly);
}
//private Assembly AssemblyResolving(AssemblyLoadContext arg1, AssemblyName arg2)
//{
// if (arg2.FullName == CurrentAssembly.FullName)
// {
// return CurrentAssembly;
// }
// var deps = DependencyContext.Default;
// if (deps.CompileLibraries.Any(d => d.Name == arg2.Name))
// {
// return Assembly.Load(arg2);
// }
// foreach (var item in DependencyAssemblies)
// {
// if (item.FullName == arg2.FullName)
// {
// return item;
// }
// }
// return null;
//}
private void ResolveDenpendency(Assembly assembly)
{
string currentName = assembly.GetName().Name;
List <CompilationLibrary> dependencyCompilationLibrary = DependencyContext.Load(assembly)
.CompileLibraries.Where(de => de.Name != currentName && !DependencyContext.Default.CompileLibraries.Any(m => m.Name == de.Name))
.ToList();
dependencyCompilationLibrary.Each(libaray =>
{
foreach (var item in libaray.ResolveReferencePaths(new DependencyAssemblyResolver(Path.GetDirectoryName(assembly.Location))))
{
DependencyAssemblies.Add(AssemblyLoadContext.Default.LoadFromAssemblyPath(item));
}
});
PluginDescriptor plugin = null;
foreach (var typeInfo in assembly.DefinedTypes)
{
if (typeInfo.IsAbstract || typeInfo.IsInterface)
{
continue;
}
if (PluginTypeInfo.IsAssignableFrom(typeInfo))
{
plugin = new PluginDescriptor();
plugin.PluginType = typeInfo.AsType();
plugin.Assembly = assembly;
plugin.Dependency = dependencyCompilationLibrary;
plugin.CurrentPluginPath = CurrentPath;
}
}
if (plugin != null)
{
PluginActivtor.LoadedPlugins.Add(plugin);
}
}
/// <summary>
/// Adds all assemblies referencing Orleans found in the provided assembly's <see cref="DependencyContext"/>.
/// </summary>
/// <param name="manager">The builder.</param>
/// <returns>The builder with the additionally included assemblies.</returns>
public static IApplicationPartManagerWithAssemblies AddFromDependencyContext(this IApplicationPartManager manager, Assembly entryAssembly)
{
entryAssembly = entryAssembly ?? Assembly.GetCallingAssembly();
var dependencyContext = DependencyContext.Default;
if (entryAssembly != null)
{
dependencyContext = DependencyContext.Load(entryAssembly) ?? DependencyContext.Default;
manager = manager.AddApplicationPart(entryAssembly);
}
if (dependencyContext == null)
{
return(new ApplicationPartManagerWithAssemblies(manager, Array.Empty <Assembly>()));
}
var assemblies = new List <Assembly>();
foreach (var lib in dependencyContext.RuntimeLibraries)
{
if (!lib.Dependencies.Any(dep => dep.Name.Contains("Orleans")))
{
continue;
}
try
{
var asm = Assembly.Load(lib.Name);
manager.AddApplicationPart(new AssemblyPart(asm));
assemblies.Add(asm);
}
catch
{
// Ignore any exceptions thrown during non-explicit assembly loading.
}
}
return(new ApplicationPartManagerWithAssemblies(manager, assemblies));
}
private static ConcurrentBag <AssemblyData> ResolveAssemblies(DependencyContext dependencyContext)
{
return(new ConcurrentBag <AssemblyData>(dependencyContext.CompileLibraries
.SelectMany(l => {
try
{
var paths = l.ResolveReferencePaths();
return paths.Select(p => new AssemblyData {
Library = l,
AssemblyFullPath = p,
AssemblyFileName = Path.GetFileNameWithoutExtension(p)
});
}
catch (Exception)
{
try
{
Assembly a;
if (TryLoadAssemblyFromUserFolders(l.Name, out a))
{
return new List <AssemblyData>()
{
new AssemblyData {
Library = l,
AssemblyFullPath = a.Location,
AssemblyFileName = Path.GetFileNameWithoutExtension(a.Location)
}
};
}
return Enumerable.Empty <AssemblyData>();
}
catch (Exception e)
{
return Enumerable.Empty <AssemblyData>();
}
}
})
.ToList()));
}
/// <inheritdoc />
public IEnumerable <string> GetReferencePaths()
{
if (Assembly.IsDynamic)
{
// Skip loading process for dynamic assemblies. This prevents DependencyContextLoader from reading the
// .deps.json file from either manifest resources or the assembly location, which will fail.
return(Enumerable.Empty <string>());
}
var dependencyContext = DependencyContext.Load(Assembly);
if (dependencyContext != null)
{
return(dependencyContext.CompileLibraries.SelectMany(library => library.ResolveReferencePaths()));
}
// If an application has been compiled without preserveCompilationContext, return the path to the assembly
// as a reference. For runtime compilation, this will allow the compilation to succeed as long as it least
// one application part has been compiled with preserveCompilationContext and contains a super set of types
// required for the compilation to succeed.
return(new[] { Assembly.Location });
}
public ContextualLogger(DependencyContext context)
{
Assert.IsNotNull(context, "context should not be null.");
this.Context = context;
}
public ContextualLogger(DependencyContext context)
{
this.Context = context;
}
private DependencyContext CreateDependencyContext(Runtime.Project project, FrameworkName frameworkName)
{
var dependencyContext = new DependencyContext(project.ProjectDirectory, _options.Configuration, frameworkName);
dependencyContext.Walk(project.Name, project.Version);
return dependencyContext;
}
