public void WhenInitializingAModuleWithACatalogPendingToBeLoaded_ThenLoadsTheCatalogInitializesTheModule() { var aggregateCatalog = new AggregateCatalog(new AssemblyCatalog(typeof(MefModuleInitializer).Assembly)); var compositionContainer = new CompositionContainer(aggregateCatalog); compositionContainer.ComposeExportedValue(aggregateCatalog); var serviceLocatorMock = new Mock<IServiceLocator>(); var loggerFacadeMock = new Mock<ILoggerFacade>(); var serviceLocator = serviceLocatorMock.Object; var loggerFacade = loggerFacadeMock.Object; compositionContainer.ComposeExportedValue(serviceLocator); compositionContainer.ComposeExportedValue(loggerFacade); var moduleInitializer = compositionContainer.GetExportedValue<IModuleInitializer>(); var repository = compositionContainer.GetExportedValue<DownloadedPartCatalogCollection>(); var moduleInfo = new ModuleInfo("TestModuleForInitializer", typeof(TestModuleForInitializer).AssemblyQualifiedName); repository.Add(moduleInfo, new TypeCatalog(typeof(TestModuleForInitializer))); moduleInitializer.Initialize(moduleInfo); ComposablePartCatalog existingCatalog; Assert.IsFalse(repository.TryGet(moduleInfo, out existingCatalog)); var module = compositionContainer.GetExportedValues<IModule>().OfType<TestModuleForInitializer>().First(); Assert.IsTrue(module.Initialized); }
public void WhenInitializingAModuleWithNoCatalogPendingToBeLoaded_ThenInitializesTheModule() { var aggregateCatalog = new AggregateCatalog(new AssemblyCatalog(typeof(MefModuleInitializer).Assembly)); var compositionContainer = new CompositionContainer(aggregateCatalog); compositionContainer.ComposeExportedValue(aggregateCatalog); var serviceLocatorMock = new Mock<IServiceLocator>(); var loggerFacadeMock = new Mock<ILoggerFacade>(); var serviceLocator = serviceLocatorMock.Object; var loggerFacade = loggerFacadeMock.Object; compositionContainer.ComposeExportedValue(serviceLocator); compositionContainer.ComposeExportedValue(loggerFacade); aggregateCatalog.Catalogs.Add(new TypeCatalog(typeof(TestModuleForInitializer))); var moduleInitializer = compositionContainer.GetExportedValue<IModuleInitializer>(); var moduleInfo = new ModuleInfo("TestModuleForInitializer", typeof(TestModuleForInitializer).AssemblyQualifiedName); var module = compositionContainer.GetExportedValues<IModule>().OfType<TestModuleForInitializer>().First(); Assert.IsFalse(module.Initialized); moduleInitializer.Initialize(moduleInfo); Assert.IsTrue(module.Initialized); }
public VsPackage() { _instance = this; Tracer = new OutputWindowTracer(this); _compositionCatalog = new AggregateCatalog(); _compositionContainer = new CompositionContainer(_compositionCatalog, true); _exportProvider = new ExportProviderAdapter(_compositionContainer); _compositionContainer.ComposeExportedValue(_exportProvider); }
public WispPlugProvider(WispManagerInterface wispManager) { AggregateCatalog catalog = new AggregateCatalog(); catalog.Catalogs.Add(new DirectoryCatalog(".")); CompositionContainer container = new CompositionContainer(catalog); container.ComposeExportedValue("wispManager", wispManager); container.ComposeParts(this); }
private void CreateBindingContainer() { // We leverage the Feature Runtime container, where all their components and extensions publish already. var defaultCatalog = this.componentModel.GetCatalog(NuPattern.VisualStudio.Composition.Catalog.DefaultCatalogName); var ourCatalog = this.componentModel.GetCatalog(Catalog.DefaultCatalogName); if (defaultCatalog == null || ourCatalog == null) { throw new InvalidOperationException(Resources.BindingCompositionService_CatalogsNotAvailable); } try { // Transparently change the INuPatternCompositionService implementation for all components // without code changes by providing an instance earlier in the chain. // See http://codebetter.com/blogs/glenn.block/archive/2009/05/14/customizing-container-behavior-part-2-of-n-defaults.aspx this.defaultCompositionProvider = new CompositionContainer(); defaultCompositionProvider.ComposeExportedValue <INuPatternCompositionService>(this); defaultCompositionProvider.ComposeExportedValue <SVsServiceProvider>((SVsServiceProvider)serviceProvider); // Decorated catalog of parts. // NOTE: caching the catalog also caches the instantiated shared parts, if any. this.bindingCatalog = new BindingComponentCatalog(new AggregateCatalog(ourCatalog, defaultCatalog)); var bindingProvider = new CatalogExportProvider(this.bindingCatalog); this.container = new CompositionContainer( defaultCompositionProvider, bindingProvider, componentModel.DefaultExportProvider); bindingProvider.SourceProvider = this.container; } catch (Exception ex) { tracer.Error(ex, Resources.BindingCompositionService_FailedToInitialize); throw; } // Used by the CompositionServiceBindingContext to create a new CompositionContainer over // this one for dynamic context resolution. this.container.ComposeExportedValue <ExportProvider>(container); }
public void Execute() { using (var catalog = new AssemblyCatalog(GetType().Assembly)) using (var container = new CompositionContainer(catalog)) { container.ComposeExportedValue(ModuleDefinition); container.ComposeExportedValue(this); var directoryName = Path.GetDirectoryName(AssemblyPath); foreach (var targetFile in Directory.EnumerateFiles(directoryName, "*.dll")) { if (targetFile != AssemblyPath) { container.GetExportedValue <AssemblyProcessor>().Execute(targetFile); } } container.GetExportedValue <AssemblyProcessor>().Execute(ModuleDefinition); } }
private CompositionContainer CreateCompositionContainer() { var container = new CompositionContainer(CachedInfo.Catalog); container.ComposeExportedValue <MockVs>(this); var batch = new CompositionBatch(); container.Compose(batch); return(container); }
public void BeforeTest() { windowManagementModule = new WindowManagementModule(); windowFocusEventProducer = new WindowFocusEventProducer(); windowMovementEventProducer = new WindowMovementEventProducer(); windowResizingEventProducer = new WindowResizingEventProducer(); windowStateChangedEventProducer = new WindowStateChangedEventProducer(); container = new CompositionContainer(); container.ComposeExportedValue(windowFocusEventProducer); container.ComposeExportedValue(windowMovementEventProducer); container.ComposeExportedValue(windowResizingEventProducer); container.ComposeExportedValue(windowStateChangedEventProducer); container.ComposeParts(windowManagementModule); nativeWindowManagement = new NativeWindowMock(); hookNativeMethods = new HookNativeMethodsMock(); hookNativeMethods.Initialize(); }
protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); var catalog = new AggregateCatalog( new AssemblyCatalog(Assembly.GetExecutingAssembly()), new AssemblyCatalog(typeof(IDialogService).Assembly)); _container = new CompositionContainer(catalog); _container.ComposeExportedValue(_container); _container.ComposeExportedValue("AppName", "Services and Drivers"); _container.ComposeExportedValue <IUIServices>(new UIServicesDefaults()); var vm = _container.GetExportedValue <MainViewModel>(); var win = new MainWindow { DataContext = vm }; win.Show(); }
public void VerifyGetAllInstancesReturnsCorrectInstances() { string firstStringInstance = nameof(firstStringInstance); string secondStringInstance = nameof(secondStringInstance); var container = new CompositionContainer(); container.ComposeExportedValue(firstStringInstance); container.ComposeExportedValue(secondStringInstance); container.ComposeExportedValue(typeof(string)); container.ComposeExportedValue(Math.PI); var serviceLocator = new MefServiceLocator(container); var instances = serviceLocator.GetAllInstances <string>(); Assert.That(instances.ToList(), Has.Count.EqualTo(2)); Assert.That(instances, Has.Exactly(1).EqualTo(firstStringInstance)); Assert.That(instances, Has.Exactly(1).EqualTo(secondStringInstance)); }
/// <summary> /// Composes the parts. /// </summary> private void ComposeParts() { var errors = false; // Load the modules. var extensionCatalogs = new AggregateCatalog(); var extensionsDirectory = Path.Combine(this.HomeDirectory, "Extensions"); // Create the extension directory if it doesn't exist. if (!Directory.Exists(extensionsDirectory)) { Directory.CreateDirectory(extensionsDirectory); Logger.Debug("Missing directory {0} has been re-created.", extensionsDirectory); } foreach (var subDirectory in Directory.GetDirectories(extensionsDirectory)) { var catalog = new DirectoryCatalog(subDirectory); try { if (catalog.Parts.Any()) { extensionCatalogs.Catalogs.Add(catalog); Logger.Debug("Adding a new DirectoryCatalog {0}.", subDirectory); } } catch (Exception ex) { Logger.ErrorException(ex, ex.Message); errors = true; } } try { Logger.Debug("Loading composition parts."); var compositionContainer = new CompositionContainer(extensionCatalogs); compositionContainer.ComposeExportedValue(nameof(IHost), this); compositionContainer.ComposeParts(this); } catch (Exception ex) { Logger.ErrorException(ex, ex.Message); errors = true; } if (errors) { this.ShowBalloonToolTip("Loading extensions failed", "One or more extensions failed to load. Check log file for more information.", BalloonIcon.Error); } }
public void PartsShouldHaveImportsSatisfiedBeforeBeingUsedToSatisfyRecomposableImports() { var container = new CompositionContainer(); var fooOptional = new FooWithOptionalImport(); container.ComposeParts(fooOptional); container.ComposeExportedValue <string>("FooSimpleImport", "NotNullOrEmpty"); container.ComposeParts(new FooWithSimpleImport()); Assert.True(!string.IsNullOrEmpty(fooOptional.OptionalImport.SimpleValue)); }
protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); Catalog = new AggregateCatalog( new AssemblyCatalog(Assembly.GetExecutingAssembly()), new DirectoryCatalog(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "*.modules.*.dll")); Container = new CompositionContainer(Catalog); var ui = new UIServicesDefaults(); Container.ComposeExportedValue <IUIServices>(ui); Container.ComposeExportedValue(Container); var vm = Container.GetExportedValue <MainViewModel>(); var win = new MainWindow { DataContext = vm }; win.Show(); ui.MessageBoxService.SetOwner(win); }
public IEnumerable <Tuple <string, T> > GetModules() { var container = new CompositionContainer(_catalog); container.ComposeExportedValue(_catalog); var exports = container.GetExports <T, Dictionary <string, object> >().ToList(); var modules = exports.Select(export => new Tuple <string, T>(export.Metadata[_nameAttribute].ToString(), export.Value)); return(modules); }
public void TestConstructorInjectionWithMultipleConstructors() { string ExpectedConstructorParameterValue = "42"; var catalog = new TypeCatalog(typeof(Foo), typeof(FooImporter)); var container = new CompositionContainer(catalog); container.ComposeExportedValue <string>(ConstructorParameterContract, ExpectedConstructorParameterValue); var fooImporter = container.GetExportedValue <FooImporter>(); Assert.AreEqual(1, fooImporter.FooList.Count, "Expect a single IFoo import in the list"); Assert.AreEqual(ExpectedConstructorParameterValue, fooImporter.FooList[0].Value.ConstructorParameter, "Expected foo's ConstructorParameter to have the correct value."); }
protected void Application_Start() { AggregateCatalog catalog = new AggregateCatalog(); DirectoryCatalog directoryCatalog = new DirectoryCatalog(AssemblyDirectory); catalog.Catalogs.Add(directoryCatalog); CompositionContainer = new CompositionContainer(catalog); CompositionContainer.ComposeExportedValue("RedisConnString", ConfigurationManager.AppSettings["RedisConnectionString"]); CompositionContainer.ComposeParts(this); GlobalConfiguration.Configure(WebApiConfig.Register); }
private static JobRunner LoadJobRunner(Settings settings) { AssemblyCatalog catalog = new AssemblyCatalog(typeof(WorkerRole).Assembly); var container = new CompositionContainer(catalog); // Load settings settings = settings ?? new Settings(); container.ComposeExportedValue(settings); // Get the job runner return(container.GetExportedValue <JobRunner>()); }
public void ShouldForwardResolveToInnerContainerWhenKeyIsUsed() { object myInstance = new object(); CompositionContainer compositionContainer = new CompositionContainer(); compositionContainer.ComposeExportedValue <object>("key", myInstance); IServiceLocator containerAdapter = new MefServiceLocatorAdapter(compositionContainer); Assert.AreSame(myInstance, containerAdapter.GetInstance(typeof(object), "key")); }
public AppBootstrapper() { var path = AppDomain.CurrentDomain.SetupInformation.ApplicationBase; var catalog = new AggregateCatalog(); catalog.Catalogs.Add(new AssemblyCatalog(typeof(AppBootstrapper).Assembly)); catalog.Catalogs.Add(new DirectoryCatalog(path)); var isolatingCatalog = new IsolatingCatalog(catalog); _container = new CompositionContainer(isolatingCatalog); _container.ComposeExportedValue(_container); }
public void Throw_If_Crash_Dump_Cannot_Be_Loaded() { // arrange var container = new CompositionContainer(); container.ComposeExportedValue <IConverter>(new Converter()); Action mightThrow = () => new CoreComponentFactory(container, new FileInfo(@"C:\this\doesnt\exist.dmp")); // act // assert mightThrow.Should().Throw <ApplicationException>(); }
public void BeforeTest() { //initialize module, producers and configuration mouseModule = new MouseModule(); mouseClickEventProducer = new MouseClickEventProducer(); mouseMoveEventProducer = new MouseMoveEventProducer(); mouseScrollEventProducer = new MouseScrollEventProducer(); mouseModuleConfiguration = new TestMouseModuleConfiguration(); // initialize the container and fulfill the MEF inports exports container = new CompositionContainer(); container.ComposeExportedValue(mouseClickEventProducer); container.ComposeExportedValue(mouseMoveEventProducer); container.ComposeExportedValue(mouseScrollEventProducer); container.ComposeExportedValue(mouseModuleConfiguration); container.ComposeParts(mouseModule); //initialzie the hookNativeMethodsMock hookNativeMethodsMock = new HookNativeMethodsMock(); hookNativeMethodsMock.Initialize(); }
private void Application_Startup(object sender, StartupEventArgs e) { var catalog = new AggregateCatalog(new DeploymentCatalog()); _extension = new DeploymentCatalog("SilverlightMEF.Extensions.xap"); catalog.Catalogs.Add(_extension); var container = new CompositionContainer(catalog); CompositionHost.Initialize(container); container.ComposeExportedValue <ILaunchInterface>(this); CompositionInitializer.SatisfyImports(this); }
public ConceptsModule(IRegionManager regionManager) { RegionManager = regionManager; var catalog = new AggregateCatalog(); catalog.Catalogs.Add(new AssemblyCatalog(typeof(ConceptsModule).Assembly)); _localContainer = new CompositionContainer(catalog); _localContainer.ComposeExportedValue(RegionManager); _localContainer.ComposeParts(this); }
void Inner() { using (var catalog = new AssemblyCatalog(GetType().Assembly)) using (var container = new CompositionContainer(catalog)) { container.ComposeExportedValue(this); container.ComposeExportedValue(BuildEngine); container.ComposeExportedValue(logger); CheckForInvalidConfig(); container.GetExportedValue <TargetPathFinder>().Execute(); logger.LogMessage(string.Format("\tTargetPath: {0}", TargetPath)); container.GetExportedValue <AssemblyResolver>().Execute(); var moduleReader = container.GetExportedValue <ModuleReader>(); moduleReader.Execute(); var fileChangedChecker = container.GetExportedValue <FileChangedChecker>(); if (!fileChangedChecker.ShouldStart()) { return; } container.GetExportedValue <MsCoreReferenceFinder>().Execute(); container.GetExportedValue <AssemblyLoaderImporter>().Execute(); container.GetExportedValue <ModuleLoaderImporter>().Execute(); container.GetExportedValue <DependencyFinder>().Execute(); container.GetExportedValue <ProjectKeyReader>().Execute(); container.GetExportedValue <ResourceCaseFixer>().Execute(); using (var resourceEmbedder = container.GetExportedValue <ResourceEmbedder>()) { resourceEmbedder.Execute(); var savePath = GetSavePath(); container.GetExportedValue <ModuleWriter>().Execute(savePath); } container.GetExportedValue <ReferenceDeleter>().Execute(); } }
private void SetupDefaultServices(CompositionContainer mefContainer) { if (mefContainer.GetExportedValueOrDefault <IResponseParser>() == null) { mefContainer.ComposeExportedValue <IResponseParser>(new ResponseParser()); } if (mefContainer.GetExportedValueOrDefault <IBotServices>() == null) { mefContainer.ComposeExportedValue <IBotServices>(new SlackSendQueueService()); } if (mefContainer.GetExportedValueOrDefault <IBotState>() == null) { mefContainer.ComposeExportedValue <IBotState>(new BotState()); } if (mefContainer.GetExportedValueOrDefault <ISlackApi>() == null) { mefContainer.ComposeExportedValue <ISlackApi>(SlackApi.Create(this.apiKey)); } if (mefContainer.GetExportedValueOrDefault <IBackOffStrategy>() == null) { mefContainer.ComposeExportedValue <IBackOffStrategy>(new BackOffRetry()); } if (mefContainer.GetExportedValueOrDefault <ILog>() == null) { mefContainer.ComposeExportedValue <ILog>(LogManager.GetLogger(typeof(ISlackBot))); } }
private void Initialize(IFileSystem fileSystem, IConsole console) { using (var catalog = new AggregateCatalog(new AssemblyCatalog(GetType().Assembly))) { if (!IgnoreExtensions) { AddExtensionsToCatalog(catalog); } using (var container = new CompositionContainer(catalog)) { var settings = GetCommandLineSettings(fileSystem); var defaultPackageSource = new PackageSource(NuGetConstants.DefaultFeedUrl); var officialPackageSource = new PackageSource(NuGetConstants.DefaultFeedUrl, NuGetResources.OfficialPackageSourceName); var v1PackageSource = new PackageSource(NuGetConstants.V1FeedUrl, NuGetResources.OfficialPackageSourceName); var legacyV2PackageSource = new PackageSource(NuGetConstants.V2LegacyFeedUrl, NuGetResources.OfficialPackageSourceName); var packageSourceProvider = new PackageSourceProvider( settings, new[] { defaultPackageSource }, new Dictionary <PackageSource, PackageSource> { { v1PackageSource, officialPackageSource }, { legacyV2PackageSource, officialPackageSource } } ); // Register an additional provider for the console specific application so that the user // will be prompted if a proxy is set and credentials are required var credentialProvider = new SettingsCredentialProvider(new ConsoleCredentialProvider(), packageSourceProvider, console); HttpClient.DefaultCredentialProvider = credentialProvider; container.ComposeExportedValue <IConsole>(console); container.ComposeExportedValue <ISettings>(settings); container.ComposeExportedValue <IPackageRepositoryFactory>(new NuGet.Common.CommandLineRepositoryFactory()); container.ComposeExportedValue <IPackageSourceProvider>(packageSourceProvider); container.ComposeExportedValue <ICredentialProvider>(credentialProvider); container.ComposeParts(this); } } }
private void LoadProcesses() { if ((_configuration.Processes == null) || !_configuration.Processes.Any()) { _log.Warning($"{Name}: No processes configured."); return; } // TODO: Implement appdomain isolation for process assemblies try { var catalog = new AggregateCatalog(); // Add the base directories to the catalog: catalog.Catalogs.Add(new DirectoryCatalog(".", "*.dll")); if (Directory.Exists(AssemblyPath)) { catalog.Catalogs.Add(new DirectoryCatalog(AssemblyPath, "*.dll")); } // Add each process directory to the catalog (if they exist): foreach (var process in _configuration.Processes) { var path = Path.Combine(AssemblyPath, process.Name); if (!Directory.Exists(path)) { continue; } catalog.Catalogs.Add(new DirectoryCatalog(path, "*.dll")); } var container = new CompositionContainer(catalog); // HTTP interface service should be populated where needed: container.ComposeExportedValue("IHttpInterfaceService", _httpInterface as IHttpInterfaceService); container.ComposeParts(this); } catch (ReflectionTypeLoadException ex) { var loaderExceptions = ex.LoaderExceptions != null ? string.Join(", ", ex.LoaderExceptions.Select(x => x.Message)) : string.Empty; _log.Error($"{Name}: Could not load process assemblies: {loaderExceptions}", ex); } catch (Exception ex) { _log.Error($"{Name}: Could not load process assemblies.", ex); } }
public void RegisterInstanceAndResolve() { ServiceAdd instanceOfService = new ServiceAdd(); using (CompositionContainer mefContainer = new CompositionContainer()) { mefContainer.ComposeExportedValue <IService>(instanceOfService); IService service = mefContainer.GetExportedValue <IService>(); //IService service = mefContainer.GetExport<IService>().Value; Assert.That(service.Calc(1, 2), Is.EqualTo(3)); } }
CompositionContainer CreateCompositionContainer() { var compositionServices = new CompositionServices(); var exportProvider = compositionServices.GetExportProvider(); var compositionContainer = new CompositionContainer(exportProvider); var gitHubServiceProvider = exportProvider.GetExportedValue <IGitHubServiceProvider>(); var externalShowDialogService = new ExternalShowDialogService(gitHubServiceProvider, this); compositionContainer.ComposeExportedValue <IShowDialogService>(externalShowDialogService); return(compositionContainer); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { AggregateCatalog catalog = new AggregateCatalog(); DirectoryCatalog directoryCatalog = new DirectoryCatalog(AssemblyDirectory); catalog.Catalogs.Add(directoryCatalog); CompositionContainer = new CompositionContainer(catalog); CompositionContainer.ComposeExportedValue("RedisConnString", Configuration.GetValue <string>("RedisConnectionString")); CompositionContainer.ComposeParts(this); services.AddControllers(); services.AddApplicationInsightsTelemetry(); }
private INuPatternCompositionService CreateCompositionService(IGuidanceExtension extension, string extensionId) { var extensionContainer = new CompositionContainer(extensionsGlobalContainer); // Expose IGuidanceExtension to the container extensionContainer.ComposeExportedValue(extension); extensionContainer.ComposeExportedValue(InstalledGuidanceExtensions.First(r => r.ExtensionId == extensionId)); extensionContainer.ComposeExportedValue <ExportProvider>(extensionContainer); var compositionService = new NuPatternCompositionService(extensionContainer); // Expose IGuidanceExtensionCompositionService to the container extensionContainer.ComposeExportedValue <INuPatternCompositionService>(compositionService); // Satisfy imports at this level, so that the right guidance extension-level stuff is injected instead // (i.e. the guidance extension might have specified an import of the IGudianceExtensionCompositionService and // would have gotten the global one. compositionService.SatisfyImportsOnce(extension); return(compositionService); }
/// <summary> /// Build MEF catalog and create composition container /// </summary> /// <returns>Configured composition container</returns> private CompositionContainer CreateCompositionContainer() { // In addition to explicitly exported classes, auto-export all web api controllers var rb = new RegistrationBuilder(); rb.ForTypesMatching <ApiController>(t => typeof(ApiController).IsAssignableFrom(t) && t.Name.EndsWith("Controller")) .Export() .SetCreationPolicy(CreationPolicy.NonShared); var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly(), rb); // Create composition container var container = new CompositionContainer(catalog); container.ComposeExportedValue <INameGenerator>(new NameGenerator()); container.ComposeExportedValue(new BooksDemoDataOptions { MinimumNumberOfBooks = Int32.Parse(ConfigurationManager.AppSettings["MinimumNumberOfBooks"]), MaximumNumberOfBooks = Int32.Parse(ConfigurationManager.AppSettings["MaximumNumberOfBooks"]) }); return(container); }
private static Mock<IModuleManager> SetupModuleManager(CompositionContainer container) { Mock<IModuleManager> mockModuleManager = new Mock<IModuleManager>(); container.ComposeExportedValue<IModuleManager>(mockModuleManager.Object); return mockModuleManager; }
public void DeclaredModuleWithTypeInUnreferencedAssemblyIsUpdatedWithTypeNameFromExportAttribute() { AggregateCatalog aggregateCatalog = new AggregateCatalog(); CompositionContainer compositionContainer = new CompositionContainer(aggregateCatalog); var mockFileTypeLoader = new Mock<MefFileModuleTypeLoader>(); mockFileTypeLoader.Setup(tl => tl.CanLoadModuleType(It.IsAny<ModuleInfo>())).Returns(true); ModuleCatalog moduleCatalog = new ModuleCatalog(); ModuleInfo moduleInfo = new ModuleInfo { ModuleName = "MefModuleOne", ModuleType = "some type" }; moduleCatalog.AddModule(moduleInfo); compositionContainer.ComposeExportedValue<IModuleCatalog>(moduleCatalog); compositionContainer.ComposeExportedValue<MefFileModuleTypeLoader>(mockFileTypeLoader.Object); bool wasInit = false; var mockModuleInitializer = new Mock<IModuleInitializer>(); mockModuleInitializer.Setup(x => x.Initialize(It.IsAny<ModuleInfo>())).Callback(() => wasInit = true); var mockLoggerFacade = new Mock<ILoggerFacade>(); MefModuleManager moduleManager = new MefModuleManager( mockModuleInitializer.Object, moduleCatalog, mockLoggerFacade.Object); compositionContainer.SatisfyImportsOnce(moduleManager); moduleManager.Run(); Assert.IsFalse(wasInit); AssemblyCatalog assemblyCatalog = new AssemblyCatalog(GetPathToModuleDll()); aggregateCatalog.Catalogs.Add(assemblyCatalog); compositionContainer.SatisfyImportsOnce(moduleManager); mockFileTypeLoader.Raise(tl => tl.LoadModuleCompleted += null, new LoadModuleCompletedEventArgs(moduleInfo, null)); Assert.AreEqual("MefModulesForTesting.MefModuleOne, MefModulesForTesting, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", moduleInfo.ModuleType); Assert.IsTrue(wasInit); }
private static void SetupRegionBehaviorAdapters(CompositionContainer container) { var regionBehaviorFactory = new RegionBehaviorFactory(new MefServiceLocatorAdapter(container)); #if SILVERLIGHT container.ComposeExportedValue<TabControlRegionAdapter>(new TabControlRegionAdapter(regionBehaviorFactory)); #endif container.ComposeExportedValue<SelectorRegionAdapter>(new SelectorRegionAdapter(regionBehaviorFactory)); container.ComposeExportedValue<ItemsControlRegionAdapter>(new ItemsControlRegionAdapter(regionBehaviorFactory)); container.ComposeExportedValue<ContentControlRegionAdapter>(new ContentControlRegionAdapter(regionBehaviorFactory)); container.ComposeExportedValue<RegionAdapterMappings>(new RegionAdapterMappings()); }
public void ModuleInUnreferencedAssemblyInitializedByModuleInitializer() { AssemblyCatalog assemblyCatalog = new AssemblyCatalog(GetPathToModuleDll()); CompositionContainer compositionContainer = new CompositionContainer(assemblyCatalog); ModuleCatalog moduleCatalog = new ModuleCatalog(); Mock<MefFileModuleTypeLoader> mockFileTypeLoader = new Mock<MefFileModuleTypeLoader>(); compositionContainer.ComposeExportedValue<IModuleCatalog>(moduleCatalog); compositionContainer.ComposeExportedValue<MefFileModuleTypeLoader>(mockFileTypeLoader.Object); bool wasInit = false; var mockModuleInitializer = new Mock<IModuleInitializer>(); mockModuleInitializer.Setup(x => x.Initialize(It.IsAny<ModuleInfo>())).Callback(() => wasInit = true); var mockLoggerFacade = new Mock<ILoggerFacade>(); MefModuleManager moduleManager = new MefModuleManager( mockModuleInitializer.Object, moduleCatalog, mockLoggerFacade.Object); compositionContainer.SatisfyImportsOnce(moduleManager); moduleManager.Run(); Assert.IsTrue(wasInit); }