public void SingletonBehavior() { TypeCatalog catalog = new TypeCatalog(typeof(SingletonExport <,>)); CompositionContainer container = new CompositionContainer(catalog); SingletonExportExportCount.Count = 0; var exports = container.GetExportedValues <IExport <IFoo, IBar> >(); Assert.Equal(1, exports.Count()); // only one instance of the SingletonExport<,> is created Assert.Equal(1, SingletonExportExportCount.Count); exports = container.GetExportedValues <IExport <IFoo, IBar> >(); Assert.Equal(1, exports.Count()); // still only one instance of the SingletonExport<,> is created Assert.Equal(1, SingletonExportExportCount.Count); var import = new SingletonImport <IFoo, IBar>(); container.SatisfyImportsOnce(import); // still only one instance of the SingletonExport<,> is created Assert.Equal(1, SingletonExportExportCount.Count); import = new SingletonImport <IFoo, IBar>(); container.SatisfyImportsOnce(import); // still only one instance of the SingletonExport<,> is created Assert.Equal(1, SingletonExportExportCount.Count); var import2 = new SingletonImport <IBar, IFoo>(); container.SatisfyImportsOnce(import2); // two instances of the SingletonExport<,> is created Assert.Equal(2, SingletonExportExportCount.Count); }
public override IController CreateController( RequestContext requestContext, string controllerName) { IController controller = base.CreateController(requestContext, controllerName); _container.SatisfyImportsOnce(controller); // MEF injection return(controller); }
public ICompositionFactory <T> GetInstanceFactory <T>() where T : class { var factory = new MefCompositionFactory <T>(); Container.SatisfyImportsOnce(factory); if (factory.ExportFactory == null) { throw new CompositionException(string.Format(StringResources.NoExportFound, typeof(T))); } return(factory); }
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); }
public void ConfigureContainerLocator() { var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); var directoryCatalog = new DirectoryCatalog(@".\", "*.dll"); var compositeCatalog = new AggregateCatalog(assemblyCatalog, directoryCatalog); if (Directory.Exists(@".\Addins")) { var addinsCatalog = new DirectoryCatalog(@".\Addins", "*.dll"); compositeCatalog.Catalogs.Add(addinsCatalog); } var compositeContainer = new CompositionContainer(compositeCatalog); ContainerLocator.Container.RegisterCatalog(compositeCatalog); #region ViewModels ContainerLocator.Container.RegisterType <IMainWindowViewModel, MainWindowViewModel>(); ContainerLocator.Container.RegisterType <ITestDetailsViewModel, TestDetailsWindowViewModel>(); #endregion ContainerLocator.Container.RegisterInstance(EventAggregator.Instance); ContainerLocator.Container.RegisterType <ITestManager, TestManager>(); #region Locators ContainerLocator.Container.RegisterType <IViewModelLocator, ViewModelLocator>(); ContainerLocator.Container.RegisterInstance <IWindowService>(GetWindowService()); #endregion #region Serializer IViewModelStateSerializer stateSerializer = new ViewModelStateCompositeSerializer(); compositeContainer.SatisfyImportsOnce(stateSerializer); ContainerLocator.Container.RegisterInstance(stateSerializer); #endregion #region Test Analyser ITestAnalyser testAnalyser = new TestCompositeAnalyser(); compositeContainer.SatisfyImportsOnce(testAnalyser); ContainerLocator.Container.RegisterInstance(testAnalyser); #endregion }
public Program() { var assemblyCatalog = new AssemblyCatalog(typeof(Program).Assembly); var container = new CompositionContainer(assemblyCatalog); container.SatisfyImportsOnce(this); }
static ScriptureProvider() { var scriptureProvider = new ScriptureProvider(); var catalog = new AggregateCatalog(); //Adds all the parts found in the same assembly as the ScriptureProvider class catalog.Catalogs.Add(new AssemblyCatalog(typeof(ScriptureProvider).Assembly)); //Adds all the parts found in assemblies ending in Plugin.dll that reside in the FLExExe path var extensionPath = Path.Combine(Path.GetDirectoryName(FwDirectoryFinder.FlexExe)); catalog.Catalogs.Add(new DirectoryCatalog(extensionPath, "*Plugin.dll")); //Create the CompositionContainer with the parts in the catalog var container = new CompositionContainer(catalog); container.SatisfyImportsOnce(scriptureProvider); // Choose the ScriptureProvider that reports the newest version // (If both Paratext 7 and 8 are installed, the plugin handling 8 will be used) foreach (var provider in scriptureProvider._potentialScriptureProviders) { if (_scriptureProvider == null || provider.Value.MaximumSupportedVersion > _scriptureProvider.MaximumSupportedVersion) { _scriptureProvider = provider.Value; } } #if DEBUG if (_scriptureProvider == null) { throw new ApplicationException("No scripture providers discovered by MEF"); } #endif // DEBUG InitializeIfNeeded(); }
/// <summary> /// Register all the ICarrierClusterStream and ICarrierStream implementations defined in the providerDirectory /// </summary> /// <param name="providerDirectory">Provider directory to scan for carrier implmentations</param> /// <exception cref="Steganography.NoCarrierClusterStreamsFoundException"> /// Thrown when no ICarrierClusterStreams are found and cluster streams are required. /// </exception> /// <exception cref="Steganography.NoCarrierStreamsFoundException">Thrown when no ICarrierStreams are found.</exception> private void RegisterCarrierProviders(string providerDirectory) { CompositionContainer container = new CompositionContainer( new DirectoryCatalog(providerDirectory), CompositionOptions.DisableSilentRejection); container.SatisfyImportsOnce(this); if (_requireClusterStreams && _carrierClusterStreams.Count() == 0) { throw new NoCarrierClusterStreamsFoundException(providerDirectory); } if (_carrierStreams.Count() == 0) { throw new NoCarrierStreamsFoundException(providerDirectory); } if (_carrierClusterStreams.Count() > 0) { _carrierClusterStreams.ToList() .AsParallel() .ForAll(RegisterCarrierClusters); } _carrierStreams.ToList() .AsParallel() .ForAll(RegisterCarrierStreams); }
public AddInController(IXExtension ext) { AppDomain.CurrentDomain.ResolveBindingRedirects(new LocalAppConfigBindingRedirectReferenceResolver()); m_HostModule = new AddInHostModule(ext); m_Ext = ext; var cmdGrp = ext.CommandManager.AddCommandGroup <CadPlusCommands_e>(); cmdGrp.CommandClick += OnCommandClick; var modulesDir = Path.Combine(Path.GetDirectoryName(this.GetType().Assembly.Location), "Modules"); var catalog = CreateDirectoryCatalog(modulesDir, "*.Module.dll"); var container = new CompositionContainer(catalog); container.SatisfyImportsOnce(this); if (m_Modules?.Any() == true) { foreach (var module in m_Modules) { module.Load(ext); } } }
internal DocumentCache(string documentDirectoryPath, string templateDirectoryPath, TimeSpan documentLifespan) { if (!Directory.Exists(documentDirectoryPath)) { throw new DirectoryNotFoundException("Could not find the document directory at \"" + documentDirectoryPath + "\"."); } if (!Directory.Exists(templateDirectoryPath)) { throw new DirectoryNotFoundException("Could not find the template directory at \"" + templateDirectoryPath + "\"."); } this.documentDirectoryPath = documentDirectoryPath; this.templateDirectoryPath = templateDirectoryPath; this.DocumentLifespan = documentLifespan; var catalog = new DirectoryCatalog(templateDirectoryPath); var container = new CompositionContainer(catalog); container.SatisfyImportsOnce(this); if (this.DocumentTemplates.Length == 0) { throw new ArgumentException("Could not find any templates in the provided directory.", "templateDirectoryPath"); } var pdfDocuments = Directory.GetFiles(documentDirectoryPath, "*.pdf"); foreach (var document in pdfDocuments) { var base64Hash = Path.GetFileNameWithoutExtension(document); var hash = GetHashArray(base64Hash); this.cachedDocuments.TryAdd(hash, new CachedDocument(document)); } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var job = _simpleFactory.NewJob(bundle, scheduler); _container.SatisfyImportsOnce(job); return(job); }
private static void Load(ComposablePartCatalog catalog) { if (_instance == null) { _instance = new ImplementationManager(); } //just because we load new implementations doesn't mean we should throw away the old ones var old = _instance.Implementations?.ToArray(); using (CompositionContainer container = new CompositionContainer(catalog)) { //bring in the new ones container.SatisfyImportsOnce(_instance); //but also bring in any old ones that we don't have in the new load if (old != null) { foreach (IImplementation o in old) { if (_instance.Implementations.All(i => i.GetType() != o.GetType())) { _instance.Implementations.Add(o); } } } } }
private void InitializePlugins() { // We look for plugins in our own assembly and in any DLLs that live next to our EXE. // We could force all plugins to be in a "Plugins" directory, but it seems more straightforward // to just leave everything in one directory var builtinPlugins = new AssemblyCatalog(GetType().Assembly); var externalPlugins = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); _catalog = new AggregateCatalog(builtinPlugins, externalPlugins); _container = new CompositionContainer(_catalog); try { _container.SatisfyImportsOnce(this); } catch (CompositionException ex) { if (_log.IsErrorEnabled) { _log.ErrorFormat("MEF Composition Exception: {0}", ex.Message); var errors = String.Join("\n ", ex.Errors.Select(x => x.Description)); _log.ErrorFormat("Composition Errors: {0}", errors); } throw; } }
private void LoadPlugIn() { // 获取当前程序集 //Assembly assCurr = Assembly.GetExecutingAssembly(); // 确定组件搜索范围 //AssemblyCatalog catalog = new AssemblyCatalog(assCurr); DirectoryCatalog catalog = new DirectoryCatalog(@"plugin"); container = new CompositionContainer(catalog); //Fill the imports of this object //try //{ container.SatisfyImportsOnce(this); //} //catch (CompositionException compositionException) //{ // Console.WriteLine(compositionException.ToString()); //} //// 获取已发现的组件 //var components = container.GetExportedValues<IDaqDevice<double>>(); //// 分别调用一下 //foreach (IDaqDevice<double> m in components) //{ // m.Initial(); //} }
public void UnknownExportedModuleIsAddedAndInitializedByModuleInitializer() { var aggregateCatalog = new AggregateCatalog(); var compositionContainer = new CompositionContainer(aggregateCatalog); var moduleCatalog = new ModuleCatalog(); var mockModuleTypeLoader = new Mock <MefXapModuleTypeLoader>(new DownloadedPartCatalogCollection()); compositionContainer.ComposeExportedValue <IModuleCatalog>(moduleCatalog); compositionContainer.ComposeExportedValue <MefXapModuleTypeLoader>(mockModuleTypeLoader.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>(); var moduleManager = new MefModuleManager(mockModuleInitializer.Object, moduleCatalog, mockLoggerFacade.Object); aggregateCatalog.Catalogs.Add(new TypeCatalog(typeof(TestMefModule))); compositionContainer.SatisfyImportsOnce(moduleManager); moduleManager.Run(); Assert.IsTrue(wasInit); Assert.IsTrue(moduleCatalog.Modules.Any(mi => mi.ModuleName == "TestMefModule")); }
public IEnumerable <ToolStripItem> GetExtensionMenuItems() { //for now we're not doing real extension dlls, just kind of faking it. So we will limit this load //to books we know go with this currently "built-in" "extension" for SIL LEAD's SHRP Project. //TODO: this should work, but it doesn't because BookInfo.BookLineage isn't working: if (SHRP_PupilBookExtension.ExtensionIsApplicable(BookSelection.CurrentSelection.BookInfo.BookLineage)) if (SHRP_PupilBookExtension.ExtensionIsApplicable(BookSelection.CurrentSelection.GetBookLineage())) { //load any extension assembly found in the template's root directory //var catalog = new DirectoryCatalog(this.BookSelection.CurrentSelection.FindTemplateBook().FolderPath, "*.dll"); var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); var container = new CompositionContainer(catalog); //inject what we have to offer for the extension to consume container.ComposeExportedValue <string>("PathToBookFolder", BookSelection.CurrentSelection.FolderPath); container.ComposeExportedValue <string>("Language1Iso639Code", _collectionSettings.Language1Iso639Code); container.ComposeExportedValue <Func <IEnumerable <HtmlDom> > >(GetPageDoms); // container.ComposeExportedValue<Func<string>>("pathToPublishedHtmlFile",GetFileForPrinting); container.ComposeExportedValue <Action <int, int, HtmlDom, Action <Image>, Action <Exception> > >(GetThumbnailAsync); container.SatisfyImportsOnce(this); return(_getExtensionMenuItems == null ? new List <ToolStripItem>() : _getExtensionMenuItems()); } else { return(new List <ToolStripMenuItem>()); } }
public MEFViewModelResolver() { var catalog = new AssemblyCatalog(GetType().Assembly); var container = new CompositionContainer(catalog); container.SatisfyImportsOnce(this); }
private static List <IDatabaseModule> FindModules(CompositionContainer container) { try { var moduleContainer = new ModuleContainer(); container.SatisfyImportsOnce(moduleContainer); if (moduleContainer.Modules != null) { var modules = new List <IDatabaseModule>(); foreach (var lModule in moduleContainer.Modules) { try { var module = lModule.Value; modules.Add(module); } catch (Exception ex) { log.Error(ex, "Module Initialization Error"); } } return(modules); } } catch (ReflectionTypeLoadException ex) { log.Error(ex); } catch (UnauthorizedAccessException ex) { log.Error(ex); } catch (Exception ex) { log.Error(ex); } return(null); }
public void CanComposeExportsFromPythonCodeWithDecorator() { var pythonCode = @" @export(IItemSource) class StringItemSource(BasePythonItemSource): def GetAllItems(self): return [""Item 1"", ""Item 2"", ""Item 3""] "; var _engine = Python.CreateEngine(); var script = _engine.CreateScriptSourceFromString(pythonCode); var typeExtractor = new ExtractTypesFromScript(_engine); var exports = typeExtractor.GetPartsFromScript(script, IronPythonCommandsMefExport.InitialScopeTypes).ToList(); var container = new CompositionContainer(); var batch = new CompositionBatch(exports, new ComposablePart[] {}); container.Compose(batch); var instance = new MockImporter(); container.SatisfyImportsOnce(instance); Assert.Equal(1, instance.ItemSources.Count()); }
private void AddResourceImpl(IEnumerable <IResource> formats, CompositionContainer container) { foreach (var impl in formats) { try { var part = AttributedModelServices.CreatePart(impl); if (part.ImportDefinitions.Any()) { container.SatisfyImportsOnce(part); } } catch (Exception X) { System.Diagnostics.Trace.WriteLine(X.Message, impl.Tag); } foreach (var ext in impl.Extensions) { m_extension_map.Add(ext.ToUpperInvariant(), impl); } foreach (var signature in impl.Signatures) { m_signature_map.Add(signature, impl); } } }
private void ComposeParts() { var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); _compositionContainer = new CompositionContainer(catalog); _compositionContainer.SatisfyImportsOnce(this); }
private static List <IInterfacePlugin> LoadPlugins(string path) { //recursive search List <IInterfacePlugin> loadedPlugins = new List <IInterfacePlugin>(); foreach (string folder in Directory.GetDirectories(path)) { loadedPlugins.AddRange(LoadPlugins(folder)); } DirectoryCatalog catalog = new DirectoryCatalog(path, "*.dll"); CompositionContainer container = new CompositionContainer(catalog); PluginWrapper wrapper = new PluginWrapper(); container.SatisfyImportsOnce(wrapper); if (wrapper.LoadedPlugins != null) { loadedPlugins.AddRange(wrapper.LoadedPlugins); } return(loadedPlugins); }
public IEnumerable <ToolStripItem> GetExtensionMenuItems() { //for now we're not doing real extension dlls, just kind of faking it. So we will limit this load //to books we know go with this currently "built-in" "extension" for SIL LEAD's SHRP Project. if (SHRP_PupilBookExtension.ExtensionIsApplicable(BookSelection.CurrentSelection)) { //load any extension assembly found in the template's root directory //var catalog = new DirectoryCatalog(this.BookSelection.CurrentSelection.FindTemplateBook().FolderPath, "*.dll"); var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); var container = new CompositionContainer(catalog); //inject what we have to offer for the extension to consume container.ComposeExportedValue <string>("PathToBookFolder", BookSelection.CurrentSelection.FolderPath); container.ComposeExportedValue <string>("Language1Iso639Code", _currentlyLoadedBook.BookData.Language1.Iso639Code); container.ComposeExportedValue <Func <IEnumerable <HtmlDom> > >(GetPageDoms); // container.ComposeExportedValue<Func<string>>("pathToPublishedHtmlFile",GetFileForPrinting); //get the original images, not compressed ones (just in case the thumbnails are, like, full-size & they want quality) container.ComposeExportedValue <Action <int, int, HtmlDom, Action <Image>, Action <Exception> > >(GetThumbnailAsync); container.SatisfyImportsOnce(this); return(_getExtensionMenuItems == null ? new List <ToolStripItem>() : _getExtensionMenuItems()); } else { return(new List <ToolStripMenuItem>()); } }
//protected override Type GetControllerType(RequestContext requestContext, string controllerName) //{ // var controllerType = base.GetControllerType(requestContext, controllerName); // if (controllerType == null) // { // var controller = _container.GetExports<IController, IControllerMetaData>().SingleOrDefault(x => x.Metadata.ControllerName == controllerName).Value; // if (controller != null) // { // return controller.GetType(); // } // } // return controllerType; //} protected override IController GetControllerInstance(RequestContext context, Type controllerType) { IController result = null; if (!AzRBootstrap.IsIntialized) { AzRBootstrap.Intialize(); ControllerBuilder.Current.SetControllerFactory(new AzRControllerFactory(AzRBootstrap.Container)); } if (controllerType == null) { return(null); } //if (controllerType == null) //{ // return base.GetControllerInstance(context, controllerType); // // return null; //} var export = _container.GetExports(typeof(IAzRController), null, controllerType.FullName).SingleOrDefault(x => x.Value.GetType() == controllerType); if (null != export) { result = export.Value as IController; } if (null != result) { _container.SatisfyImportsOnce(result); } return(result); }
private void Compose() { AssemblyCatalog catalog = new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly()); CompositionContainer container = new CompositionContainer(catalog); container.SatisfyImportsOnce(this); }
private void Compose() { var catalog = new DirectoryCatalog(".", "*.dll"); var container = new CompositionContainer(catalog); container.SatisfyImportsOnce(this); }
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); }
public ExampleApplication(int width = 512, int height = 512, double updateRate = 60) { var catalog = new AggregateCatalog(); catalog.Catalogs.Add(new AssemblyCatalog(typeof(ExampleApplication).Assembly)); _container = new CompositionContainer(catalog); try { _container.SatisfyImportsOnce(this); } catch (CompositionException e) { Console.WriteLine(e.ToString()); } gameWindow = new GameWindow(width, height); gameWindow.TargetUpdateFrequency = updateRate; gameWindow.TargetRenderFrequency = updateRate; gameWindow.VSync = VSyncMode.On; //register callback for resizing of window gameWindow.Resize += GameWindow_Resize; //register callback for keyboard gameWindow.KeyDown += GameWindow_KeyDown; gameWindow.KeyDown += (sender, e) => { if (Key.Escape == e.Key) { gameWindow.Exit(); } }; ResourceManager = resourceProvider as ResourceManager; }
public static void Init(object attributedPart) { if (mefContainer != null) { return; } AggregateCatalog partsCatalog = new AggregateCatalog(); //TODO: replace the following code to load plugins from a subfolder, remove specific plugin references from application project and set plugin projects to copy their DLL to a "Plugins" subfolder under the folder where the executable of the app is built string[] assemblies = new string[] { "SpeechLib.Synthesis.dll", "SpeechLib.Recognition.dll", "SpeechLib.Recognition.KinectV1.dll" }; foreach (string s in assemblies) { partsCatalog.Catalogs.Add(new AssemblyCatalog(s)); } mefContainer = new CompositionContainer(partsCatalog); mefContainer.SatisfyImportsOnce(attributedPart); //CompositionInitializer.SatisfyImports(attributedPart); }
public void DoLoad() { //Katalógusokat tároló katalógus var catalog = new AggregateCatalog(); //Futtató szerelvényből típusok keresése, amik Export atribútummal meg vannak jelölve catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly())); //Adott mappából szerelvények betöltése és az Export atribútummal megjelölt típusok betöltése catalog.Catalogs.Add(new DirectoryCatalog(Environment.CurrentDirectory)); //Kompozíciós konténer létrehozása. A betöltés itt valósul meg. CompositionContainer container = new CompositionContainer(catalog); //IHost elérhetőségének tesztelése. _host = container.GetExportedValue <IHost>(); if (_host == null) { Console.WriteLine("Nincs host. Valami gond van"); Environment.Exit(-1); } //A modulok betöltése container.ComposeParts(this); //A modulok számára az IHost függőség kielégítése container.SatisfyImportsOnce(this); }
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); }
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); }