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 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); }