public void TestScanProducesSomeResults()
{
var instance = DependencyScannerFactory.Create();
var scanResult = instance.Scan((f) => f.StartsWith("Dependous.Test.Common"), c => c.AddProbingPaths(pb => pb.AddProbingPath("../../../../../tests/Dependous.Probing/bin/Debug/netstandard2.1")));
Assert.True(scanResult.Metadata.Any());
}
public void ProbeIt()
{
var instance = DependencyScannerFactory.Create();
var result = instance.Scan((b) =>
b.StartsWith("Junk"),
(c) => c.AddProbingPaths(pb =>
pb.AddProbingPath("../../../../../tests/Dependous.Probing/bin/Debug/netstandard2.1", (p) => p.StartsWith("Dependous.Probing"))));
Assert.True(result.Metadata.Any());
}
/// <summary>
/// Scans for dependencies and builds the autofac container.
/// </summary>
/// <param name="patternBuilder">The pattern builder.</param>
/// <param name="dependencyScanner">The dependency scanner. If null, uses the default scanner</param>
/// <param name="configurationBuilder">The configuration builder.</param>
/// <param name="logger">The logger.</param>
/// <param name="containerConfigurator">The container configurator.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException">No dependency scanner registered. Make sure you call AddDependencyScanning before calling this method</exception>
public static IContainer BuildContainer(
Func <AssemblySearchPatternFactory, AssemblySearchPatternFactory> patternBuilder = null,
Func <IDependencyScanner> dependencyScanner = null,
Action <IDependousConfiguration> configurationBuilder = null,
Action <object> logger = null,
Action <ContainerBuilder, IReadOnlyCollection <DependencyMetadata> > containerConfigurator = null)
{
logger = logger ?? ((x) => { });
dependencyScanner = dependencyScanner ?? (() => DependencyScannerFactory.Create());
var scanner = dependencyScanner();
if (scanner == null)
{
throw new InvalidOperationException("No dependency scanner registered. Make sure you call AddDependencyScanning before calling this method");
}
Action <IDependousConfiguration> internalBuilder = (config) =>
{
//automatically discovers AutoFac modules and Sources as well any DLR dynamic types
config.AddAdditionalDiscoveryTypes(d => d.RegisterType <IModule>(SL.Singleton)
.RegisterType <IRegistrationSource>(SL.Singleton));
configurationBuilder?.Invoke(config);
};
var scanResults = scanner.Scan(patternBuilder, internalBuilder, logger);
logger($"Assembly Scan Completed In {scanResults.Duration.TotalMilliseconds}ms{Environment.NewLine} {String.Join(Environment.NewLine, scanResults.ScannedAssemblies.Select(x => x.FullName))}");
logger($"Registering Dependencies {Environment.NewLine} { String.Join(Environment.NewLine, scanResults.Metadata.Select(x => x.DependencyType.FullName))}");
if (scanResults.ScanExceptions != null && scanResults.ScanExceptions.Any())
{
foreach (var error in scanResults.ScanExceptions)
{
logger(error);
}
}
var containerRegistrationService = new AutoFacContainerRegistrationService(scanResults.Configuration);
if (scanResults.Configuration.PersistScanResults)
{
containerRegistrationService.Builder.RegisterInstance(scanResults);
}
containerConfigurator?.Invoke(containerRegistrationService.Builder, scanResults.Metadata);
var allRegistrations = containerRegistrationService.RegisterAll(scanResults.Metadata);
logger($"Registered {allRegistrations.Count()} dependencies.");
var container = containerRegistrationService.Builder.Build();
return(container);
}
public void test_custom_assembly_locator_and_type_service()
{
Mock <IAssemblyLocator> mockAssemblyLocator = new Mock <IAssemblyLocator>();
Mock <IAssemblyTypeService> mockTypeService = new Mock <IAssemblyTypeService>();
Mock <IDependousConfiguration> mockConfig = new Mock <IDependousConfiguration>();
mockAssemblyLocator.Setup(x => x.Locate(searchFactory, It.IsAny <IDependousConfiguration>())).Returns(() => locatorResult);
mockTypeService.Setup(x => x.GetTypes(assemblyName)).Returns(this.GetDefaultTypes());
var instance = DependencyScannerFactory.Create(() => mockAssemblyLocator.Object, () => mockTypeService.Object);
var results = instance.Scan(searchFactory);
Assert.True(results.Metadata.Any());
}
/// <summary>
/// Registers defaults implementations of all required services.
/// </summary>
/// <param name="services">The services.</param>
private static IServiceCollection RegisterDefaults(IServiceCollection services)
{
var buildProvider = services.BuildServiceProvider();
if (buildProvider.GetService <IDependencyScanner>() == null)
{
services.AddSingleton((t) => DependencyScannerFactory.Create());
}
if (buildProvider.GetService <IAssemblyLocator>() == null)
{
services.AddSingleton((t) => AssemblyLocatorFactory.Resolve());
}
if (buildProvider.GetService <IAssemblyTypeService>() == null)
{
services.AddSingleton((t) => AssemblyTypeFactory.Resolve());
}
return(services);
}
