public ResourceLoader(IFileSystem fileSystem, IAssemblies assemblies)
{
_fileSystem = fileSystem;
_assembly = assemblies.EntryAssembly;
_externalFolders = new Dictionary <string, List <string> >(10);
_getFilesInFolderFunc = getFilesInFolder; //Caching delegate to avoid memory allocations in critical path
}
/// <summary>
/// Initializes a new instance of the <see cref="ManifestResourceStreamConfigurationObjectsProvider"/> class.
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> for getting assembly for embedded resources.</param>
/// <param name="parsers"><see cref="IConfigurationFileParsers"/> for parsing.</param>
public ManifestResourceStreamConfigurationObjectsProvider(
IAssemblies assemblies,
IConfigurationFileParsers parsers)
{
_entryAssembly = assemblies.EntryAssembly;
_parsers = parsers;
}
/// <summary>
/// Initializes a new instance of <see cref="TypeFinder"/>
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> for getting assemblies</param>
/// <param name="contractToImplementorsMap"><see cref="IContractToImplementorsMap"/> for keeping track of the relationship between contracts and implementors</param>
public TypeFinder(IAssemblies assemblies, IContractToImplementorsMap contractToImplementorsMap)
{
_assemblies = assemblies;
_contractToImplementorsMap = contractToImplementorsMap;
CollectTypes();
}
/// <summary>
/// Initialize systems needed for the type system and discovery mechanisms to work.
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> that will be used.</param>
/// <param name="scheduler"><see cref="IScheduler"/> to use for scheduling work.</param>
/// <param name="logger"><see cref="ILogger"/> for logging.</param>
/// <param name="entryAssembly"><see cref="Assembly"/> to use as entry assembly - null indicates it will ask for the entry assembly.</param>
/// <returns><see cref="ITypeFinder"/> that can be used.</returns>
public static ITypeFinder Start(IAssemblies assemblies, IScheduler scheduler, ILogger logger, Assembly entryAssembly = null)
{
if (entryAssembly == null)
{
entryAssembly = Assembly.GetEntryAssembly();
}
IContractToImplementorsMap contractToImplementorsMap;
#if false // Re-enable when https://github.com/dolittle-fundamentals/DotNET.Fundamentals/issues/219 is fixed
if (CachedContractToImplementorsMap.HasCachedMap(entryAssembly))
{
var before = DateTime.UtcNow;
logger.Information("Contract to implementors map cache found - using it instead of dynamically discovery");
contractToImplementorsMap = new CachedContractToImplementorsMap(
new ContractToImplementorsSerializer(logger),
entryAssembly);
Console.WriteLine($"CachedMap : {DateTime.UtcNow.Subtract(before).ToString("G")}");
}
else
#endif
{
logger.Information("Using runtime discovery for contract to implementors map");
contractToImplementorsMap = new ContractToImplementorsMap(scheduler);
contractToImplementorsMap.Feed(entryAssembly.GetTypes());
var typeFeeder = new TypeFeeder(scheduler, logger);
typeFeeder.Feed(assemblies, contractToImplementorsMap);
}
return(new TypeFinder(contractToImplementorsMap));
}
/// <summary>
/// Initializes a new instance of <see cref="ContractToImplementorsSerializer"/>
/// </summary>
/// <param name="scheduler"></param>
/// <param name="assemblies"></param>
/// <param name="logger"></param>
public ContractToImplementorsSerializer(
IScheduler scheduler,
IAssemblies assemblies,
ILogger logger)
{
_logger = logger;
var before = DateTime.UtcNow;
scheduler.PerformForEach(assemblies.GetAll(), assembly =>
{
try
{
var types = assembly.GetTypes();
foreach (var type in types)
{
if (!string.IsNullOrEmpty(type.AssemblyQualifiedName))
{
_typesByName[type.AssemblyQualifiedName] = type;
}
}
}
catch (ReflectionTypeLoadException ex)
{
foreach (var loaderException in ex.LoaderExceptions)
{
_logger.Error($"Failed to load: {loaderException.Source} {loaderException.Message}");
}
}
});
Console.WriteLine($"Gathering Types : {DateTime.UtcNow.Subtract(before).ToString("G")}");
}
/// <summary>
/// Initializes a new instance of <see cref="TypeDiscoverer">TypeDiscoverer</see>
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> for getting assemblies</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> for finding types from all collected types</param>
/// <param name="contractToImplementorsMap"><see cref="IContractToImplementorsMap"/> for keeping track of the relationship between contracts and implementors</param>
public TypeDiscoverer(IAssemblies assemblies, ITypeFinder typeFinder, IContractToImplementorsMap contractToImplementorsMap)
{
_assemblies = assemblies;
_typeFinder = typeFinder;
_contractToImplementorsMap = contractToImplementorsMap;
CollectTypes();
}
/// <inheritdoc/>
public IContainer Provide(IAssemblies assemblies, IBindingCollection bindings)
{
var containerBuilder = new ContainerBuilder();
containerBuilder.AddDolittle(assemblies, bindings);
var autofacContainer = containerBuilder.Build();
return(new Container(autofacContainer));
}
public ObjectFactoriesProcessor(ILog log, IAssemblies assemblies, IFactoryFinder factoryFinder, IConstructorCallFinder constructorCallFinder, IFactoryCallWeaver factoryCallWeaver, IFactoryMapSerializer factoryMapSerializer)
{
_log = log;
_factoryMapSerializer = factoryMapSerializer;
_assemblies = assemblies;
_factoryCallWeaver = factoryCallWeaver;
_constructorCallFinder = constructorCallFinder;
_factoryFinder = factoryFinder;
}
/// <summary>
/// Initializes a new instance of <see cref="BootResult"/>
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> used</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> used</param>
/// <param name="bindings"><see cref="IBindingCollection">Bindings</see> setup</param>
public BootResult(
IAssemblies assemblies,
ITypeFinder typeFinder,
IBindingCollection bindings)
{
Assemblies = assemblies;
TypeFinder = typeFinder;
Bindings = bindings;
}
public ObjectFactoriesProcessor(ILog log, IAssemblies assemblies, IFactoryFinder factoryFinder, IConstructorCallFinder constructorCallFinder, IFactoryCallWeaver factoryCallWeaver, IFactoryMapSerializer factoryMapSerializer)
{
_log = log;
_factoryMapSerializer = factoryMapSerializer;
_assemblies = assemblies;
_factoryCallWeaver = factoryCallWeaver;
_constructorCallFinder = constructorCallFinder;
_factoryFinder = factoryFinder;
}
public override ObjectFactoriesProcessor Create()
{
_assembly = _mocks.DynamicMock <IAssembly>();
_assemblies = _mocks.DynamicMock <IAssemblies>();
_factoryFinder = _mocks.DynamicMock <IFactoryFinder>();
_constructorCallFinder = _mocks.DynamicMock <IConstructorCallFinder>();
_factoryCallWeaver = _mocks.DynamicMock <IFactoryCallWeaver>();
_factoryMapSerializer = _mocks.DynamicMock <IFactoryMapSerializer>();
return(new ObjectFactoriesProcessor(new NullLogger(), _assemblies, _factoryFinder, _constructorCallFinder, _factoryCallWeaver, _factoryMapSerializer));
}
public IOSDevice(IAssemblies assemblies)
{
DisplayDensity = 1;
GraphicsBackend = new OpenGLESBackend();
BitmapLoader = new IOSBitmapLoader(GraphicsBackend);
BrushLoader = new IOSBrushLoader();
FontLoader = new IOSFontLoader();
ConfigFile = new AndroidEngineConfigFile();
Assemblies = assemblies;
FileSystem = new AndroidFileSystem();
KeyboardState = new IOSKeyboardState();
}
public AndroidDevice(IAssemblies assemblies)
{
DisplayDensity = Resources.System.DisplayMetrics.Density;
GraphicsBackend = new OpenGLESBackend();
BitmapLoader = new AndroidBitmapLoader(GraphicsBackend);
BrushLoader = new AndroidBrushLoader();
FontLoader = new AndroidFontLoader();
ConfigFile = new AndroidEngineConfigFile();
Assemblies = assemblies;
FileSystem = new AndroidFileSystem();
KeyboardState = new AndroidKeyboardState();
}
/// <summary>
/// Initializes a new instance of <see cref="TypeDiscoverer">TypeDiscoverer</see>
/// </summary>
public TypeDiscoverer(IAssemblies assemblies)
{
_assemblies = assemblies;
#if(SILVERLIGHT)
_types = new Dictionary<string, IDictionary<string, Type>>();
#else
_types = new ConcurrentDictionary<string, IDictionary<string, Type>>();
#endif
_implementingTypes = new Dictionary<Type, Type[]>();
CollectTypes();
}
/// <summary>
/// Initialize a new instanace of <see cref="BootloaderResult"/>
/// </summary>
/// <param name="container"><see cref="IContainer"/> configured</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> configured</param>
/// <param name="assemblies"><see cref="IAssemblies"/> configured</param>
/// <param name="bindings"><see cref="IBindingCollection"/> configured</param>
/// <param name="bootStageResults"><see cref="BootStageResults">Results from each boot stage</see></param>
public BootloaderResult(
IContainer container,
ITypeFinder typeFinder,
IAssemblies assemblies,
IBindingCollection bindings,
IEnumerable <BootStageResult> bootStageResults)
{
Container = container;
TypeFinder = typeFinder;
Assemblies = assemblies;
Bindings = bindings;
BootStageResults = bootStageResults;
}
static IContainer DiscoverAndConfigureContainer(
IContainer bootContainer,
IAssemblies assemblies,
ITypeFinder typeFinder,
IBindingCollection bindingCollection)
{
var containerProviderType = typeFinder.FindSingle <ICanProvideContainer>();
ThrowIfMissingContainerProvider(containerProviderType);
var containerProvider = bootContainer.Get(containerProviderType) as ICanProvideContainer;
var container = containerProvider.Provide(assemblies, bindingCollection);
return(container);
}
static IBindingCollection GetBootBindings(
IAssemblies assemblies,
ITypeFinder typeFinder,
IScheduler scheduler,
IFileSystem fileSystem,
ILoggerManager loggerManager)
{
return(new BindingCollection(new[]
{
Bind(typeof(IAssemblies), assemblies),
Bind(typeof(ITypeFinder), typeFinder),
Bind(typeof(IScheduler), scheduler),
Bind(typeof(IFileSystem), fileSystem),
Bind(typeof(ILoggerManager), loggerManager),
Bind(typeof(GetContainer), (GetContainer)(() => _container))
}));
}
/// <inheritdoc/>
public void Feed(IAssemblies assemblies, IContractToImplementorsMap map)
{
_scheduler.PerformForEach(assemblies.GetAll(), assembly =>
{
try
{
var types = assembly.GetTypes();
map.Feed(types);
}
catch (ReflectionTypeLoadException ex)
{
foreach (var loaderException in ex.LoaderExceptions)
{
_logger.Error("TypeFeed failure for assembly {assemblyName} : {loaderExceptionSource} {loaderExceptionMessage}", assembly.FullName, loaderException.Source, loaderException.Message);
}
}
});
}
/// <summary>
/// Initialize systems needed for the type system and discovery mechanisms to work.
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> that will be used.</param>
/// <param name="scheduler"><see cref="IScheduler"/> to use for scheduling work.</param>
/// <param name="logger"><see cref="ILogger"/> for logging.</param>
/// <param name="entryAssembly"><see cref="Assembly"/> to use as entry assembly - null indicates it will ask for the entry assembly.</param>
/// <returns><see cref="ITypeFinder"/> that can be used.</returns>
public static ITypeFinder Start(IAssemblies assemblies, IScheduler scheduler, ILogger logger, Assembly entryAssembly = null)
{
if (entryAssembly == null)
{
entryAssembly = Assembly.GetEntryAssembly();
}
IContractToImplementorsMap contractToImplementorsMap;
contractToImplementorsMap = new ContractToImplementorsMap(scheduler);
contractToImplementorsMap.Feed(entryAssembly.GetTypes());
var typeFeeder = new TypeFeeder(scheduler, logger);
typeFeeder.Feed(assemblies, contractToImplementorsMap);
return(new TypeFinder(contractToImplementorsMap));
}
/// <inheritdoc/>
public void Feed(IAssemblies assemblies, IContractToImplementorsMap map)
{
_scheduler.PerformForEach(assemblies.GetAll(), assembly =>
{
try
{
var types = assembly.GetTypes();
map.Feed(types);
}
catch (ReflectionTypeLoadException ex)
{
foreach (var loaderException in ex.LoaderExceptions)
{
_logger.Error($"Failed to load: {loaderException.Source} {loaderException.Message}");
}
}
});
}
/// <summary>
/// Initialize the entire DependencyInversion pipeline.
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> for the application.</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> for doing discovery.</param>
/// <param name="scheduler"><see cref="IScheduler"/> for scheduling work.</param>
/// <param name="fileSystem"><see cref="IFileSystem"/> to use.</param>
/// <param name="loggerManager"><see cref="ILoggerManager"/> for creating loggers.</param>
/// <param name="bindings">Additional bindings.</param>
/// <param name="bootContainer">A <see cref="BootContainer"/> used during booting.</param>
/// <returns>Configured <see cref="IContainer"/> and <see cref="IBindingCollection"/>.</returns>
public static BootResult Start(
IAssemblies assemblies,
ITypeFinder typeFinder,
IScheduler scheduler,
IFileSystem fileSystem,
ILoggerManager loggerManager,
IEnumerable <Binding> bindings = null,
BootContainer bootContainer = null)
{
var logger = loggerManager.CreateLogger(typeof(Boot));
logger.Trace("DependencyInversion start");
var initialBindings = GetBootBindings(assemblies, typeFinder, scheduler, fileSystem, loggerManager);
if (bootContainer == null)
{
bootContainer = new BootContainer(initialBindings, new NewBindingsNotificationHub());
}
_container = bootContainer;
var otherBindings = new List <Binding>();
if (bindings != null)
{
otherBindings.AddRange(bindings);
}
otherBindings.Add(Bind(typeof(IContainer), () => _container, false));
logger.Trace("Discover and Build bindings");
var bindingCollection = DiscoverAndBuildBuildBindings(
bootContainer,
typeFinder,
scheduler,
logger,
initialBindings,
otherBindings);
logger.Trace("Discover container");
_container = DiscoverAndConfigureContainer(bootContainer, assemblies, typeFinder, bindingCollection);
BootContainer.ContainerReady(_container);
logger.Trace("Return boot result");
return(new BootResult(_container, bindingCollection));
}
/// <summary>
/// Add Dolittle specifics to the <see cref="ContainerBuilder"/>
/// </summary>
/// <param name="containerBuilder"><see cref="ContainerBuilder"/> to extend</param>
/// <param name="assemblies">Discovered <see cref="IAssemblies"/></param>
/// <param name="bindings"><see cref="IBindingCollection">Bindings</see> to hook up</param>
public static void AddDolittle(this ContainerBuilder containerBuilder, IAssemblies assemblies, IBindingCollection bindings)
{
var allAssemblies = assemblies.GetAll().ToArray();
containerBuilder.RegisterAssemblyModules(allAssemblies);
var selfBindingRegistrationSource = new SelfBindingRegistrationSource(type =>
!type.Namespace.StartsWith("Microsoft") &&
!type.Namespace.StartsWith("System"));
selfBindingRegistrationSource.RegistrationConfiguration = HandleLifeCycleFor;
containerBuilder.AddBindingsPerTenantRegistrationSource();
containerBuilder.RegisterSource(selfBindingRegistrationSource);
containerBuilder.RegisterSource(new FactoryForRegistrationSource());
containerBuilder.RegisterSource(new OpenGenericTypeCallbackRegistrationSource());
DiscoverAndRegisterRegistrationSources(containerBuilder, allAssemblies);
RegisterUpBindingsIntoContainerBuilder(bindings, containerBuilder);
}
static IBindingCollection DiscoverBindings(
IContainer bootContainer,
IAssemblies assemblies,
ITypeFinder typeFinder,
IScheduler scheduler,
ILogger logger)
{
logger.Trace("Discover Bindings");
var bindingConventionManager = new BindingConventionManager(bootContainer, typeFinder, scheduler, logger);
logger.Trace("Discover and setup bindings");
var bindingsFromConventions = bindingConventionManager.DiscoverAndSetupBindings();
logger.Trace("Discover binding providers and get bindings");
var bindingsFromProviders = DiscoverBindingProvidersAndGetBindings(bootContainer, typeFinder, scheduler);
logger.Trace("Compose bindings in new collection");
var bindingCollection = new BindingCollection(bindingsFromProviders, bindingsFromConventions);
return(bindingCollection);
}
/// <summary>
/// Initialize the entire DependencyInversion pipeline with a specified <see cref="Type"/> of container
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> for the application</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> for doing discovery</param>
/// <param name="scheduler"><see cref="IScheduler"/> for scheduling work</param>
/// <param name="fileSystem"><see cref="IFileSystem"/> to use</param>
/// <param name="logger"><see cref="ILogger"/> for doing logging</param>
/// <param name="containerType"><see cref="Type"/>Container type</param>
/// <param name="bindings">Additional bindings</param>
/// <param name="bootContainer">A <see cref="BootContainer"/> used during booting</param>
/// <returns>Configured <see cref="IContainer"/> and <see cref="IBindingCollection"/></returns>
public static IBindingCollection Start(
IAssemblies assemblies,
ITypeFinder typeFinder,
IScheduler scheduler,
IFileSystem fileSystem,
ILogger logger,
Type containerType,
IEnumerable <Binding> bindings = null,
BootContainer bootContainer = null)
{
logger.Trace("DependencyInversion start");
var initialBindings = GetBootBindings(assemblies, typeFinder, scheduler, fileSystem, logger);
if (bootContainer == null)
{
bootContainer = new BootContainer(initialBindings, new NewBindingsNotificationHub());
}
_container = bootContainer;
var otherBindings = new List <Binding>();
if (bindings != null)
{
otherBindings.AddRange(bindings);
}
otherBindings.Add(Bind(typeof(IContainer), containerType, true));
logger.Trace("Discover and Build bindings");
var bindingCollection = DiscoverAndBuildBuildBindings(
bootContainer,
assemblies,
typeFinder,
scheduler,
logger,
initialBindings,
otherBindings);
return(bindingCollection);
}
static void DiscoverClassMapsAndAddAssemblies(
IAssemblies assemblies,
ITypeDiscoverer typeDiscoverer,
MappingConfiguration mappings)
{
var assembliesWithFluentMappings = typeDiscoverer
.FindMultiple(typeof(IMappingProvider))
.Select(t => t.Assembly)
.Distinct();
foreach (var assembly in assembliesWithFluentMappings)
{
mappings.FluentMappings.AddFromAssembly(assembly).Conventions.Add(DefaultLazy.Never(), AutoImport.Never());
}
var assembliesWithHbmMappings = assemblies
.GetAll()
.Where(a => a.GetManifestResourceNames().Any(s => s.EndsWith(".hbm.xml")));
foreach (var assembly in assembliesWithHbmMappings)
{
mappings.HbmMappings.AddFromAssembly(assembly);
}
}
static IBindingCollection DiscoverAndBuildBuildBindings(
IContainer bootContainer,
IAssemblies assemblies,
ITypeFinder typeFinder,
IScheduler scheduler,
ILogger logger,
IBindingCollection initialBindings,
IEnumerable <Binding> bindings)
{
logger.Trace("Discover bindings");
var discoveredBindings = DiscoverBindings(bootContainer, assemblies, typeFinder, scheduler, logger);
logger.Trace("Create a new binding collection");
var bindingCollection = new BindingCollection(initialBindings, discoveredBindings, bindings);
foreach (var binding in bindingCollection)
{
logger.Trace($"Discovered Binding : {binding.Service.AssemblyQualifiedName} - {binding.Strategy.GetType().Name}");
}
var asmBindings = bindingCollection.Where(_ => _.Service == typeof(IAssemblies)).ToArray();
return(bindingCollection);
}
public ResourceLoader(IFileSystem fileSystem, IAssemblies assemblies)
{
_fileSystem = fileSystem;
_assembly = assemblies.EntryAssembly;
_externalFolders = new Dictionary <string, List <string> >(10);
}
