public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseAutoFacContainer(AssemblyPaths.From("Dependous"), logger: (o) => Console.WriteLine($"{o}"))
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
});
public string ChangeWorkingDirectory()
{
var currentWorkingDirectory = Directory.GetCurrentDirectory();
if (!string.IsNullOrEmpty(WorkingDirectory))
{
Directory.SetCurrentDirectory(WorkingDirectory);
}
else if (!string.IsNullOrEmpty(Project))
{
var workingDirectory = Path.GetDirectoryName(Project);
if (Directory.Exists(workingDirectory))
{
Directory.SetCurrentDirectory(workingDirectory);
}
}
else if (AssemblyPaths.Any())
{
var workingDirectory = Path.GetDirectoryName(AssemblyPaths.First());
if (Directory.Exists(workingDirectory))
{
Directory.SetCurrentDirectory(workingDirectory);
}
}
return(currentWorkingDirectory);
}
public static AssemblyPaths ForWeavedAssembly(AssemblyPaths unweavedAssemblyPaths)
{
var dllPath = unweavedAssemblyPaths.DllPath.Replace(".DLL", ".Weaved.dll");
var pdbPath = unweavedAssemblyPaths.PdbPath.Replace(".Pdb", ".Weaved.Pdb");
return(new AssemblyPaths(dllPath, pdbPath));
}
internal static void Register(string assemblyPath)
{
if (!string.IsNullOrEmpty(assemblyPath))
{
AssemblyPaths.Add(assemblyPath);
}
}
/// <summary>
/// Adds Dependous and Autofac as the preferred IOC container.
/// </summary>
/// <param name="hostBuilder">The host builder.</param>
/// <param name="assemblyNameFilter">The assembly name filter.</param>
/// <param name="configurationBuilder">The configuration builder.</param>
/// <param name="logger">The logger.</param>
/// <param name="containerBuilder">The container builder.</param>
/// <returns></returns>
public static IHostBuilder UseAutoFacContainer(this IHostBuilder hostBuilder,
AssemblyPaths assemblyPaths,
Action <IDependousConfiguration> configurationBuilder = null,
Action <object> logger = null,
Action <ContainerBuilder> containerBuilder = null)
{
AutoFacSetup.SetAutoFacCircularDependencyLimit();
return(hostBuilder.UseServiceProviderFactory(new AutoFacServiceProviderFactoryDecorator(assemblyPaths, configurationBuilder, logger, containerBuilder)));
}
public TestDecoration(ITestOutputHelper outputHelper)
{
output = outputHelper;
var serviceCollection = new ServiceCollection();
serviceCollection.AddDependencyScanning();
container = serviceCollection.BuildAutoFacContainer(AssemblyPaths.From("SportsConnect", "Dependous"),
logger: (item) => { output.WriteLine($"{item}"); Console.WriteLine(item); });
}
/// <summary>
/// Adds Dependous and Autofac as the preferred IOC container.
/// </summary>
/// <param name="hostBuilder">The host builder.</param>
/// <param name="assemblyNameFilter">The assembly name filter.</param>
/// <param name="configurationBuilder">The configuration builder.</param>
/// <param name="logger">The logger.</param>
/// <param name="containerBuilder">The container builder.</param>
/// <returns></returns>
public static IContainer BuildAutoFacContainer(this IServiceCollection services,
AssemblyPaths assemblyPaths,
Action <IDependousConfiguration> configurationBuilder = null,
Action <object> logger = null,
Action <ContainerBuilder> containerBuilder = null)
{
var container = new AutoFacServiceProviderFactoryDecorator(assemblyPaths, configurationBuilder, logger, containerBuilder).CreateBuilder(services).Build();
return(container);
}
protected async Task <TResult> RunIsolatedAsync(string configurationFile)
{
var assemblyDirectory = AssemblyPaths.Any() ? Path.GetDirectoryName(Path.GetFullPath(PathUtilities.ExpandFileWildcards(AssemblyPaths).First())) : configurationFile;
var bindingRedirects = GetBindingRedirects();
var assemblies = GetAssemblies(assemblyDirectory);
using (var isolated = new AppDomainIsolation <IsolatedCommandAssemblyLoader <TResult> >(assemblyDirectory, AssemblyConfig, bindingRedirects, assemblies))
{
return(await Task.Run(() => isolated.Object.Run(GetType().FullName, JsonConvert.SerializeObject(this), AssemblyPaths, ReferencePaths)).ConfigureAwait(false));
}
}
internal AutoFacServiceProviderFactoryDecorator(
AssemblyPaths assemblyPaths,
Action <IDependousConfiguration> configurationBuilder = null,
Action <object> logger = null,
Action <ContainerBuilder> containerBuilder = null)
{
_assemblyPaths = assemblyPaths;
_configurationBuilder = configurationBuilder;
_logger = logger ?? ((x) => { });
_decorateer = new AutofacServiceProviderFactory(containerBuilder);
}
private IEnumerable <string> ResolveAvailableDlls()
{
var coreDlls = new[] { typeof(object).Assembly.Location };
var runtimeDlls = Directory.GetFiles(RuntimeEnvironment.GetRuntimeDirectory(), "*.dll");
var moduleDlls = AssemblyPaths.SelectMany(p => Directory.GetFiles(p, "*.dll"));
return(coreDlls
.Concat(runtimeDlls)
.Concat(moduleDlls)
.Distinct()
.ToList());
}
private static void TryCleanupWeavedFiles(AssemblyPaths assemblyPaths)
{
if (File.Exists(assemblyPaths.DllPath))
{
File.Delete(assemblyPaths.DllPath);
}
if (File.Exists(assemblyPaths.PdbPath))
{
File.Delete(assemblyPaths.PdbPath);
}
}
protected UnifiedWeaverTestBase()
{
var source = AssemblyPaths.OfExecutingAssembly();
var weave = AssemblyPaths.ForWeavedAssembly(source);
TryCleanupWeavedFiles(weave);
File.Copy(source.DllPath, weave.DllPath, true);
File.Copy(source.PdbPath, weave.PdbPath, true);
Source = source;
Weave = weave;
}
private void SanitizeInput()
{
AssemblyPaths = AssemblyPaths.Select(p => p
.Replace('\\', Path.DirectorySeparatorChar)
.Replace('/', Path.DirectorySeparatorChar))
.Distinct()
.ToArray();
AssemblyNames = AssemblyNames
.Where(n => !string.IsNullOrWhiteSpace(n))
.Distinct()
.ToArray();
}
public ResolvedPackageReference(
string packageName,
string packageVersion,
IReadOnlyList <FileInfo> assemblyPaths,
DirectoryInfo packageRoot = null,
IReadOnlyList <DirectoryInfo> probingPaths = null) : base(packageName, packageVersion)
{
if (string.IsNullOrWhiteSpace(packageVersion))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(packageVersion));
}
AssemblyPaths = assemblyPaths ?? throw new ArgumentNullException(nameof(assemblyPaths));
ProbingPaths = probingPaths ?? Array.Empty <DirectoryInfo>();
PackageRoot = packageRoot ?? AssemblyPaths.FirstOrDefault()?.Directory.Parent.Parent;
}
private DefaultAssemblyResolver CreateAssemblyResolver()
{
var assemblyResolver = new DefaultAssemblyResolver();
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (assembly.Location.Replace('\\', '/').StartsWith(Application.dataPath.Substring(0, Application.dataPath.Length - 7)))
{
AssemblyPaths.Add(assembly.Location);
}
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assembly.Location));
}
return(assemblyResolver);
}
public AutofacContainerTests(ITestOutputHelper outputHelper)
{
output = outputHelper;
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <MyObject>();
serviceCollection.AddSingleton(new TestObject());
serviceCollection.AddDependencyScanning(b => b.AddSingleton <MyObject>().AddSingleton(new TestObject()));
container = serviceCollection.BuildAutoFacContainer(AssemblyPaths.From("Dependous"),
logger: (item) => { output.WriteLine($"{item}"); Console.WriteLine(item); }, configurationBuilder: (cb) =>
{
cb.PersistScanResults = true;
// cb.InterceptAll<DynamicInterceptor>();
cb.AddProbingPaths(pb => pb.AddProbingPath("../../../../../tests/Dependous.Probing/bin/Debug/netstandard2.1", (p) => p.StartsWith("Dependous.Probing")));
});
}
private string[] GenerateCommandLineCommands()
{
var args = new List <string>();
if (RootDescriptorFiles != null)
{
foreach (var rootFile in RootDescriptorFiles)
{
args.Add("-x");
args.Add(rootFile.ItemSpec);
}
}
foreach (var assemblyItem in RootAssemblyNames)
{
args.Add("-a");
args.Add(assemblyItem.ItemSpec);
}
var assemblyDirs = AssemblyPaths.Select(p => Path.GetDirectoryName(p.ItemSpec))
.GroupBy(d => d).Select(ds => ds.First());
foreach (var dir in assemblyDirs)
{
args.Add("-d");
args.Add(dir);
}
if (OutputDirectory != null)
{
args.Add("-out");
args.Add(OutputDirectory.ItemSpec);
}
if (ExtraArgs != null)
{
args.AddRange(ExtraArgs.Split(' '));
}
if (DumpDependencies)
{
args.Add("--dump-dependencies");
}
return(args.ToArray());
}
protected Task <TResult> RunIsolatedAsync(string configurationFile)
{
var assemblyDirectory = AssemblyPaths.Any() ? Path.GetDirectoryName(Path.GetFullPath(PathUtilities.ExpandFileWildcards(AssemblyPaths).First())) : configurationFile;
var bindingRedirects = GetBindingRedirects();
var assemblies = GetAssemblies(assemblyDirectory);
if (UseNuGetCache)
{
var defaultNugetPackages = LoadDefaultNugetCache();
ReferencePaths = ReferencePaths.Concat(defaultNugetPackages).ToArray();
}
using (var isolated = new AppDomainIsolation <IsolatedCommandAssemblyLoader>(assemblyDirectory, AssemblyConfig, bindingRedirects, assemblies))
{
return(Task.FromResult(isolated.Object.Run(GetType().FullName, JsonConvert.SerializeObject(this), AssemblyPaths, ReferencePaths)));
}
}
public void BrowseAssemblies()
{
var win = new OpenFileDialog
{
DefaultExt = ".dll",
Multiselect = true,
};
if (win.ShowDialog() != true)
{
return;
}
var newPaths = win.FileNames.Except(AssemblyPaths, StringComparer.OrdinalIgnoreCase).ToArray();
foreach (var fileName in newPaths)
{
AssemblyPaths.Add(fileName);
}
}
public ResolvedPackageReference(
string packageName,
string packageVersion,
IReadOnlyList <string> assemblyPaths,
string packageRoot = null,
IReadOnlyList <string> probingPaths = null) : base(packageName, packageVersion)
{
if (string.IsNullOrWhiteSpace(packageVersion))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(packageVersion));
}
AssemblyPaths = assemblyPaths ?? throw new ArgumentNullException(nameof(assemblyPaths));
ProbingPaths = probingPaths ?? Array.Empty <string>();
PackageRoot = packageRoot;
if (PackageRoot == null &&
AssemblyPaths.FirstOrDefault() is {} path)
{
PackageRoot = new FileInfo(path).Directory?.Parent?.Parent?.FullName;
}
}
private static void Main(string[] args)
{
InitializeOptions(args);
if (Debug)
{
Debugger.Launch();
}
var assemblies = AssemblyPaths.Select(Assembly.LoadFrom);
var listeners = CreateListener().ToArray();
var result = Evaluator.Run(assemblies, listeners);
if (Pause)
{
System.Console.WriteLine("Press <enter> to terminate...");
System.Console.Read();
}
var exitCode = -1 * (int)result.State;
Environment.Exit(exitCode);
}
public void RemoveAssembly()
{
AssemblyPaths.Remove(SelectedAssemblyPath);
}
/// <summary>
/// Discovers the assemblies.
/// </summary>
/// <param name="services">The services.</param>
/// <param name="assemblyPath">The assembly path.</param>
/// <returns></returns>
public static AssemblyLocatorResult DiscoverAssemblies(this IServiceCollection services, AssemblyPaths assemblyPath)
{
Func <AssemblySearchPatternFactory, AssemblySearchPatternFactory> builder = (b) =>
{
foreach (var item in assemblyPath.Paths)
{
b.StartsWith(item);
}
return(b);
};
return(DiscoverAssemblies(services, builder));
}
