/// <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 DefaultViewB(IModuleLoader moduleLoader, IModuleEnumerator moduleEnumerator)
{
this.moduleLoader = moduleLoader;
this.moduleEnumerator = moduleEnumerator;
InitializeComponent();
}
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();
}
