/// <summary> /// Gets the <see cref="CompositionContainer"/> for the module the requested url belongs to. /// </summary> /// <param name="relativeRequestUrl">The requested url.</param> /// <returns>A <see cref="CompositionContainer"/> instance.</returns> public CompositionContainer GetContainer(string relativeRequestUrl) { IModuleEnumerator moduleEnumerator = _rootContainer.Services.Get <IModuleEnumerator>(true); IModuleInfo[] modules = moduleEnumerator.EnumerateModules(); if (modules == null) { return(_rootContainer); } List <IModuleInfo> matches = new List <IModuleInfo>(); foreach (IModuleInfo moduleInfo in modules) { if (!String.IsNullOrEmpty(moduleInfo.VirtualPath) && relativeRequestUrl.IndexOf(moduleInfo.VirtualPath, StringComparison.InvariantCultureIgnoreCase) != -1) { matches.Add(moduleInfo); } } if (matches.Count == 0) { return(_rootContainer); } return(_rootContainer.Containers[GetMatch(matches, relativeRequestUrl).Name]); }
public DefaultViewB(IModuleLoader moduleLoader, IModuleEnumerator moduleEnumerator) { this.moduleLoader = moduleLoader; this.moduleEnumerator = moduleEnumerator; InitializeComponent(); }
public ExtensibilityQueryBuilder(IModuleEnumerator moduleEnumerator, IServiceEnumerator serviceEnumerator, IPluginManager pluginManager) { this.ServiceEnumerator = serviceEnumerator; this.ModuleEnumerator = moduleEnumerator; this.PluginManager = pluginManager; }
public ElectronPackageProvider(ILogger logger, IModuleEnumerator enumerator) { var modules = enumerator.Modules.Where(m => m.Loader == "electron"); var loader = new ElectronAsarLoader(logger); this.Interfaces = modules.SelectMany(m => loader.LoadModule(m)).ToList().ToImmutableList(); }
public EmulatorExecutableProvider(ILogger logger, IModuleEnumerator enumerator) { var loader = new EmulatorExecutableLoader(logger); this.Executables = enumerator.Modules .Where(m => m.Loader == "emulatorapp") .SelectMany(m => loader.LoadModule(m)).ToList(); }
private void LoadModules() { IModuleLoaderService loader = rootWorkItem.Services.Get <IModuleLoaderService>(true); IModuleEnumerator modEnumerator = rootWorkItem.Services.Get <IModuleEnumerator>(true); if (modEnumerator != null) { loader.Load(rootWorkItem, modEnumerator.EnumerateModules()); } }
/// <summary> /// Loads the application modules into the root container. /// </summary> protected virtual void LoadModules() { IModuleLoaderService loader = RootContainer.Services.Get <IModuleLoaderService>(true); IModuleEnumerator moduleEnumerator = RootContainer.Services.Get <IModuleEnumerator>(true); if (moduleEnumerator != null) { loader.Load(RootContainer, moduleEnumerator.EnumerateModules()); } }
/// <summary> /// Configures the <see cref="IUnityContainer"/>. May be overwritten in a derived class to add specific /// type mappings required by the application. /// </summary> protected virtual void ConfigureContainer() { Container.RegisterInstance <ILoggerFacade>(LoggerFacade); Container.RegisterInstance <IUnityContainer>(Container); Container.AddNewExtension <UnityBootstrapperExtension>(); IModuleEnumerator moduleEnumerator = GetModuleEnumerator(); if (moduleEnumerator != null) { Container.RegisterInstance <IModuleEnumerator>(moduleEnumerator); } if (_useDefaultConfiguration) { RegisterTypeIfMissing(typeof(IContainerFacade), typeof(UnityContainerAdapter), true); RegisterTypeIfMissing(typeof(IEventAggregator), typeof(EventAggregator), true); RegisterTypeIfMissing(typeof(IModuleLoader), typeof(ModuleLoader), true); } }
/// <summary> /// Initializes the modules. May be overwritten in a derived class to use custom /// module loading and avoid using an <seealso cref="IModuleLoader"/> and /// <seealso cref="IModuleEnumerator"/>. /// </summary> protected virtual void InitializeModules() { IModuleEnumerator moduleEnumerator = Container.TryResolve <IModuleEnumerator>(); if (moduleEnumerator == null) { throw new InvalidOperationException(Resources.NullModuleEnumeratorException); } IModuleLoader moduleLoader = Container.TryResolve <IModuleLoader>(); if (moduleLoader == null) { throw new InvalidOperationException(Resources.NullModuleLoaderException); } ModuleInfo[] moduleInfo = moduleEnumerator.GetStartupLoadedModules(); moduleLoader.Initialize(moduleInfo); }
/// <summary> /// Searches for specific module configuration and configures each module when that configuration is available. /// </summary> protected virtual void ConfigureModules() { IModuleEnumerator moduleEnumerator = RootContainer.Services.Get <IModuleEnumerator>(); IModuleLoaderService moduleLoader = RootContainer.Services.Get <IModuleLoaderService>(); IModuleConfigurationLocatorService moduleConfigurationLocator = RootContainer.Services.Get <IModuleConfigurationLocatorService>(); if (moduleEnumerator != null) { foreach (IModuleInfo moduleInfo in moduleEnumerator.EnumerateModules()) { System.Configuration.Configuration configuraton = moduleConfigurationLocator.FindModuleConfiguration(moduleInfo.Name); if (configuraton != null) { moduleLoader.FindInitializer(moduleInfo.Name).Configure(RootContainer.Services, configuraton); } } } }
/// <summary> /// Creates a new instance of <c>LateNightAboutModel</c>. /// </summary> public LateNightAboutModel(IUnityContainer container) { IModuleEnumerator moduleEnum = container.Resolve <IModuleEnumerator>(); moduleInfos = moduleEnum.GetModules(); }