private static FilteredCatalog BuildLayoutCatalog(ComposablePartCatalog parentCatalog) { Expression <Func <ComposablePartDefinition, bool> > findAllLayoutExtensions = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("LayoutBase"))); FilteredCatalog newFilteredCatalog = new FilteredCatalog(parentCatalog, findAllLayoutExtensions); return(newFilteredCatalog); }
/// <summary> /// Builds and returns a special catalog, based on the application assembly, that /// has been filtered to contain a single preference provider part. /// </summary> /// <param name="parentCatalog"></param> /// <returns>a Berico.LinkAnalysis.SnagL.Modularity.FilteredCatalog containing the /// configured preference provider; otherwise the default perference provider</returns> private static FilteredCatalog BuildPreferenceProviderCatalog(ComposablePartCatalog parentCatalog) { // Retrieve the name of the configrued preference provider string preferencesProvider = ConfigurationManager.Instance.CurrentConfig.PreferencesProvider.Provider; FilteredCatalog newFilteredCatalog = null; Expression <Func <ComposablePartDefinition, bool> > findSpecifiedLogger = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IPreferencesProvider"))) && (def.Metadata.ContainsKey("ID") && def.Metadata["ID"].ToString().ToLower().Equals(preferencesProvider.ToLower())); Expression <Func <ComposablePartDefinition, bool> > findDefaultLogger = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IPreferencesProvider"))) && (def.Metadata.ContainsKey("IsDefault") && bool.Parse(def.Metadata["IsDefault"].ToString()) == true); // We don't want to search for the specified logger provider if // none was specified. if (string.IsNullOrEmpty(preferencesProvider)) { return(new FilteredCatalog(parentCatalog, findDefaultLogger)); } // If we get here, we need to try and find the logger provider specified // by the user newFilteredCatalog = new FilteredCatalog(parentCatalog, findSpecifiedLogger); // If the catalog is empty, fall to the default if ((newFilteredCatalog.Parts == null) || (newFilteredCatalog.Parts.Count() == 0)) { // If we didn't find any parts, we should try again and just get the // default provider return(new FilteredCatalog(parentCatalog, findDefaultLogger)); } return(newFilteredCatalog); }
public void LoadAssemblies(params object[] targets) { foreach (var location in GetAssembliesLocation()) { try { DirectoryCatalog dirCatalog = new DirectoryCatalog(Path.GetDirectoryName(location), Path.GetFileName(location)); var filtCatalog = new FilteredCatalog(dirCatalog, filter => filter.ExportDefinitions.Any( definition => definition.ContractName == typeof(ITrader).AssemblyQualifiedName)); if (filtCatalog.Any()) { _aggregate.Catalogs.Add(filtCatalog); } } catch (Exception e) { Console.WriteLine(e); } } try { _container.ComposeParts(targets); } catch (Exception e) { Console.WriteLine(e); } }
/// <summary> /// Instructs MEF to satisfy all imports, against the current /// collection of catalogs,for the provided part. /// </summary> /// <param name="part">The object (MEF part) that should be composed</param> public static void ComposeParts(Object part) { try { // The logger is used before configruation and initialization // so we want to handle it in a special way. We just want to // compose it using a single filtered catalog to find the default // logger. Everything will be rebuilt and recomposed after // configruation. if (part is Logging.LoggerManager) { // Create a Berico.LinkAnalysis. FilteredCatalog loggerCatalog = BuildLoggerProviderCatalog(new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly())); primaryCatalog.Catalogs.Add(loggerCatalog); CompositionHost.Initialize(new CompositionContainer(primaryCatalog)); } // Now we compose and satisfy the imports for the provided Part CompositionInitializer.SatisfyImports(part); } catch (Exception ex) { if (logger != null) { logger.WriteLogEntry(Logging.LogLevel.ERROR, "An error occurred trying to compose the parts for the provided object.", ex, null); } else { // This is only for testing. We don't really want to // do this in the long run. MessageBox.Show(ex.Message); } } }
private ChorusFileTypeHandlerCollection( Expression <Func <ComposablePartDefinition, bool> > filter = null, string[] additionalAssemblies = null) { using (var aggregateCatalog = new AggregateCatalog()) { aggregateCatalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly())); aggregateCatalog.Catalogs.Add(new DirectoryCatalog(".", "*-ChorusPlugin.dll")); if (additionalAssemblies != null) { foreach (var assemblyPath in additionalAssemblies) { if (System.IO.File.Exists(assemblyPath)) { aggregateCatalog.Catalogs.Add(new AssemblyCatalog(assemblyPath)); } } } ComposablePartCatalog catalog; if (filter != null) { catalog = new FilteredCatalog(aggregateCatalog, filter); } else { catalog = aggregateCatalog; } using (var container = new CompositionContainer(catalog)) { container.ComposeParts(this); } } }
public void Mef_can_use_container_hierarchy_to_have_scoped_composable_parts() { var rootContainer = Mef; var rootCatalog = rootContainer.Catalog; var nonSharedPartsCatalog = new FilteredCatalog(rootCatalog, def => IsNonSharedOrAny(def)); IDisposableScopedService scoped1, scoped2; IDisposableSingletonService singleton1, singleton2; using (var scope1 = new CompositionContainer(nonSharedPartsCatalog, rootContainer)) { scoped1 = scope1.GetExport <IDisposableScopedService>().Value; singleton1 = scope1.GetExport <IDisposableSingletonService>().Value; Assert.IsFalse(scoped1.IsDisposed); Assert.IsFalse(singleton1.IsDisposed); using (var scope2 = new CompositionContainer(nonSharedPartsCatalog, rootContainer)) { scoped2 = scope2.GetExport <IDisposableScopedService>().Value; singleton2 = scope2.GetExport <IDisposableSingletonService>().Value; Assert.AreNotSame(scoped1, scoped2); Assert.AreSame(singleton1, singleton2); } Assert.IsTrue(scoped2.IsDisposed); Assert.IsFalse(scoped1.IsDisposed); Assert.IsFalse(singleton2.IsDisposed); } Assert.IsTrue(scoped1.IsDisposed); Assert.IsFalse(singleton1.IsDisposed); rootContainer.Dispose(); Assert.IsTrue(singleton1.IsDisposed); }
/// <summary> /// </summary> /// <param name="parentCatalog"></param> /// <returns></returns> private static FilteredCatalog BuildRankingCatalog(ComposablePartCatalog parentCatalog) { FilteredCatalog newFilteredCatalog = null; Expression <Func <ComposablePartDefinition, bool> > findAllRankingExtensions = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IRanker"))); newFilteredCatalog = new FilteredCatalog(parentCatalog, findAllRankingExtensions); return(newFilteredCatalog); }
/// <summary> /// Completes initialization of the ExtensionManager class. This will be called after /// all DeploymentCatalogs have finished downloading parts. /// </summary> /// <param name="catalogs">The external deployment catalogs to load</param> private static void CompleteInitialization(IEnumerable <DeploymentCatalog> catalogs) { lock (syncRoot) { AggregateCatalog tempCatalog = new AggregateCatalog(); // Clear the primary catalog primaryCatalog.Catalogs.Clear(); // Build a catalog containing all Parts in the entire assembly AssemblyCatalog assemblyCatalog = new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly()); foreach (DeploymentCatalog catalog in catalogs) { tempCatalog.Catalogs.Add(catalog); } tempCatalog.Catalogs.Add(assemblyCatalog); // Create the two special catalogs for the logger and preference providers FilteredCatalog loggerProviderCatalog = BuildLoggerProviderCatalog(tempCatalog); FilteredCatalog preferencesProviderCatalog = BuildPreferenceProviderCatalog(tempCatalog); FilteredCatalog toolbarExtensionsCatalog = BuildToolbarExtensionsCatalog(tempCatalog); FilteredCatalog toolPanelExtensionsCatalog = BuildToolPanelExtensionsCatalog(tempCatalog); FilteredCatalog similarityMeasureExtensionsCatalog = BuildSimilarityMeasureExtensionsCatalog(tempCatalog); FilteredCatalog rankingCatalog = BuildRankingCatalog(tempCatalog); FilteredCatalog graphDataFormatExtensionsCatalog = BuildGraphDataFormatExtensionsCatalog(tempCatalog); FilteredCatalog actionCatalog = BuildActionCatalog(tempCatalog); FilteredCatalog layoutCatalog = BuildLayoutCatalog(tempCatalog); // Add the two filtered catalogs to the master catalog primaryCatalog.Catalogs.Add(loggerProviderCatalog); primaryCatalog.Catalogs.Add(preferencesProviderCatalog); primaryCatalog.Catalogs.Add(toolbarExtensionsCatalog); primaryCatalog.Catalogs.Add(toolPanelExtensionsCatalog); primaryCatalog.Catalogs.Add(similarityMeasureExtensionsCatalog); primaryCatalog.Catalogs.Add(graphDataFormatExtensionsCatalog); primaryCatalog.Catalogs.Add(actionCatalog); primaryCatalog.Catalogs.Add(layoutCatalog); primaryCatalog.Catalogs.Add(rankingCatalog); } // Reset the flags IsBusy = false; initialized = true; // Satisfy the imports for the logger manager CompositionInitializer.SatisfyImports(Logging.LoggerManager.Instance); //Logging.LoggerManager.Instance.Level = ConfigurationManager.GetValue(ConfigurationManager.PARAMETER_LOGGER_LEVEL); }
/// <summary> /// Builds and returns a special catalog, based on the application assembly, that /// has been filtered to contain all tool panel extensions /// </summary> /// <param name="parentCatalog"></param> /// <returns>a Berico.LinkAnalysis.SnagL.Modularity.FilteredCatalog containing all /// Tool Panel extensions</returns> private static FilteredCatalog BuildToolPanelExtensionsCatalog(ComposablePartCatalog parentCatalog) { // Retrieve the name of the configrued preference provider //string preferencesProvider = ConfigurationManager.GetValue(ConfigurationManager.PARAMETER_PREFERENCES_PROVIDER); FilteredCatalog newFilteredCatalog = null; Expression <Func <ComposablePartDefinition, bool> > findAllToolPanelItemExtensions = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IToolPanelItemViewExtension")) || (def.Metadata.ContainsKey("ID") && def.Metadata["ID"].ToString().ToLower().Equals("toolpanelitemviewmodelextension"))); // If we get here, we need to try and find the logger provider specified // by the user newFilteredCatalog = new FilteredCatalog(parentCatalog, findAllToolPanelItemExtensions); return(newFilteredCatalog); }
/// <summary> /// Disposes of the instance. /// </summary> /// <param name="disposing"></param> protected override void Dispose(bool disposing) { base.Dispose(disposing); if (filter != null) { filter.Dispose(); filter = null; } if (aggregate != null) { aggregate.Dispose(); aggregate = null; } }
/// <summary> /// Builds and returns a special catalog, based on the application assembly, that /// has been filtered to contain all graph data format classes /// </summary> /// <param name="parentCatalog"></param> /// <returns>a Berico.LinkAnalysis.SnagL.Modularity.FilteredCatalog containing the /// configured preference provider; otherwise the default perference provider</returns> private static FilteredCatalog BuildGraphDataFormatExtensionsCatalog(ComposablePartCatalog parentCatalog) { // Retrieve the name of the configrued preference provider //string preferencesProvider = ConfigurationManager.GetValue(ConfigurationManager.PARAMETER_PREFERENCES_PROVIDER); FilteredCatalog newFilteredCatalog = null; Expression <Func <ComposablePartDefinition, bool> > findAllSimilarityMeasureExtensions = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IGraphDataFormat"))); //Expression<Func<ComposablePartDefinition, bool>> findDefaultLogger = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IPreferencesProvider"))) && (def.Metadata.ContainsKey("IsDefault") && bool.Parse(def.Metadata["IsDefault"].ToString()) == true); // If we get here, we need to try and find the logger provider specified // by the user newFilteredCatalog = new FilteredCatalog(parentCatalog, findAllSimilarityMeasureExtensions); return(newFilteredCatalog); }
private void Initialize() { var aggregateCatalog = new AggregateCatalog(); this.InstancesToDispose.Add(aggregateCatalog); foreach (var assembly in this.AssembliesToInclude.Distinct()) { var assemblyCatalog = new AssemblyCatalog(assembly); aggregateCatalog.Catalogs.Add(assemblyCatalog); this.InstancesToDispose.Add(assemblyCatalog); } foreach (var type in this.TypesToInclude.Distinct()) { var typeCatalog = new TypeCatalog(type); aggregateCatalog.Catalogs.Add(typeCatalog); this.InstancesToDispose.Add(typeCatalog); } // Add a filter removing types from the test. Func <ComposablePartDefinition, bool> filter = (definition) => this.TypesToRemove.All(type => definition.ExportDefinitions.All(e => e.ContractName != type.FullName)); var filteredCatalog = new FilteredCatalog(aggregateCatalog, filter); this.InstancesToDispose.Add(filteredCatalog); this.Container = new CompositionContainer( filteredCatalog, CompositionOptions.DisableSilentRejection | CompositionOptions.ExportCompositionService | CompositionOptions.IsThreadSafe); this.Container.ComposeExportedValue(this.Container); foreach (var stub in this.StubsToCompose) { this.ComposeStub(stub.Type, stub.Instance); } this.OnInitialized(); }
public static IFormattingEngine Create(ImmutableArray <string> ruleTypes) { var catalog = new AssemblyCatalog(typeof(FormattingEngine).Assembly); var ruleTypesHash = new HashSet <string>(ruleTypes, StringComparer.InvariantCultureIgnoreCase); var notFoundRuleTypes = new HashSet <string>(ruleTypes, StringComparer.InvariantCultureIgnoreCase); var filteredCatalog = new FilteredCatalog(catalog, cpd => { if (cpd.ExportDefinitions.Any(em => em.ContractName == AttributedModelServices.GetContractName(typeof(ISyntaxFormattingRule)) || em.ContractName == AttributedModelServices.GetContractName(typeof(ILocalSemanticFormattingRule)) || em.ContractName == AttributedModelServices.GetContractName(typeof(IGlobalSemanticFormattingRule)) || em.ContractName == AttributedModelServices.GetContractName(typeof(IFormattingFilter)))) { object ruleType; if (cpd.Metadata.TryGetValue(RuleTypeConstants.PartMetadataKey, out ruleType)) { if (ruleType is string) { notFoundRuleTypes.Remove((string)ruleType); if (!ruleTypesHash.Contains((string)ruleType)) { return(false); } } } } return(true); }); var container = new CompositionContainer(filteredCatalog); var engine = container.GetExportedValue <IFormattingEngine>(); var consoleFormatLogger = new ConsoleFormatLogger(); // Need to do this after the catalog is queried, otherwise the lambda won't have been run foreach (var notFoundRuleType in notFoundRuleTypes) { consoleFormatLogger.WriteErrorLine("The specified rule type was not found: {0}", notFoundRuleType); } return(engine); }
private ChorusFileTypeHandlerCollection( Expression <Func <ComposablePartDefinition, bool> > filter = null, string[] additionalAssemblies = null) { using (var aggregateCatalog = new AggregateCatalog()) { aggregateCatalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly())); aggregateCatalog.Catalogs.Add(new DirectoryCatalog(".", "*-ChorusPlugin.dll")); if (additionalAssemblies != null) { foreach (var assemblyPath in additionalAssemblies) { aggregateCatalog.Catalogs.Add(new AssemblyCatalog(assemblyPath)); } } ComposablePartCatalog catalog; if (filter != null) { catalog = new FilteredCatalog(aggregateCatalog, filter); } else { catalog = aggregateCatalog; } using (var container = new CompositionContainer(catalog)) { try { container.ComposeParts(this); } catch (ReflectionTypeLoadException ex) { var loaderExceptions = ex.LoaderExceptions; System.Diagnostics.Debug.Fail("Loading exception!"); throw new AggregateException(ex.Message, loaderExceptions); } } } }
public void MefExportFactoryDoesntThrow() { var rootCatalog = new TypeCatalog(typeof(SessionManager), typeof(Helper)); var nonSharedPartsCatalog = new FilteredCatalog(rootCatalog, def => { var md = def.Metadata; var key = CompositionConstants.PartCreationPolicyMetadataName; return(!md.ContainsKey(key) || (CreationPolicy)md[key] == CreationPolicy.Any || (CreationPolicy)md[key] == CreationPolicy.NonShared); }); var rootContainer = new CompositionContainer(rootCatalog); Helper.flag = false; Assert.DoesNotThrow(() => { // first request using (var requestScope = new CompositionContainer(nonSharedPartsCatalog, rootContainer)) { var sessionManager = requestScope.GetExport <ISessionManager>(); var sessionId = sessionManager.Value.CreateSession(); Assert.AreEqual("123", sessionId); } }, "First request has thrown an exception"); Assert.DoesNotThrow(() => { // second request using (var requestScope = new CompositionContainer(nonSharedPartsCatalog, rootContainer)) { var sessionManager = requestScope.GetExport <ISessionManager>(); var sessionId = sessionManager.Value.CreateSession(); Assert.AreEqual("321", sessionId); } }, "Second request has thrown an exception"); }
public Bootstrapper() { var catalog = new AggregateCatalog(new AssemblyCatalog(typeof(App).Assembly)); if (ViewModelLocator.Container.Catalog != null) { catalog.Catalogs.Add(ViewModelLocator.Container.Catalog); } Expression<Func<ComposablePartDefinition, bool>> expression = definition => !definition.Metadata.ContainsKey("IsDesignService") || definition.Metadata.ContainsKey("IsDesignService") && (bool) definition.Metadata["IsDesignService"] == Designer.IsInDesignMode; var filteredCatalog = new FilteredCatalog(catalog, expression); var providers = new List<ExportProvider>(ViewModelLocator.Container.Providers); var container = new CompositionContainer(filteredCatalog, providers.ToArray()); var batch = new CompositionBatch(); batch.AddExportedValue(container); ViewModelLocator.Container = container; container.Compose(batch); }
public EmbeddedMessageContentHandlerRepository() { var libChorusAssembly = Assembly.GetExecutingAssembly(); //Set the codebase variable appropriately depending on the OS var codeBase = libChorusAssembly.CodeBase.Substring(Platform.IsUnix ? 7 : 8); var baseDir = Path.GetDirectoryName(codeBase); // REVIEW: for some reason using *.* or *.dll didn't work - creating the catalogs in // unit tests (on Linux) failed with FileNotFoundException - don't know why. using (var aggregateCatalog = new AggregateCatalog(new DirectoryCatalog(baseDir, "Chorus.exe"), new AssemblyCatalog(libChorusAssembly))) using (var catalog = new FilteredCatalog(aggregateCatalog, def => !def.Metadata.ContainsKey("IsDefault"))) using (var defaultExportProvider = new CatalogExportProvider(new TypeCatalog(typeof(IEmbeddedMessageContentHandler)))) { using (var container = new CompositionContainer(catalog, defaultExportProvider)) { defaultExportProvider.SourceProvider = container; container.ComposeParts(this); } } }
private void Compose(PluginContainer pluginContainer, IPluginHost host) { var catalog = new AggregateCatalog(); var count = 0; foreach (var directory in Directory.GetDirectories(Repository)) { Logger.DebugFormat("Found plugin in '{0}'", directory); catalog.Catalogs.Add(new DirectoryCatalog(directory)); count++; } Logger.InfoFormat("Found {0} plugin(s) in the repository. (Validation not done)", count); var filteredCatatog = new FilteredCatalog(catalog, def => this.FilterPlugin(def)); var container = new CompositionContainer(filteredCatatog); var composition = new CompositionBatch(); composition.AddPart(pluginContainer); container.Compose(composition); }
private static FilteredCatalog BuildLayoutCatalog(ComposablePartCatalog parentCatalog) { Expression<Func<ComposablePartDefinition, bool>> findAllLayoutExtensions = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("LayoutBase"))); FilteredCatalog newFilteredCatalog = new FilteredCatalog(parentCatalog, findAllLayoutExtensions); return newFilteredCatalog; }
/// <summary> /// Builds and returns a special catalog, based on the application assembly, that /// has been filtered to contain a single preference provider part. /// </summary> /// <param name="parentCatalog"></param> /// <returns>a Berico.LinkAnalysis.SnagL.Modularity.FilteredCatalog containing the /// configured preference provider; otherwise the default perference provider</returns> private static FilteredCatalog BuildPreferenceProviderCatalog(ComposablePartCatalog parentCatalog) { // Retrieve the name of the configrued preference provider string preferencesProvider = ConfigurationManager.Instance.CurrentConfig.PreferencesProvider.Provider; FilteredCatalog newFilteredCatalog = null; Expression<Func<ComposablePartDefinition, bool>> findSpecifiedLogger = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IPreferencesProvider"))) && (def.Metadata.ContainsKey("ID") && def.Metadata["ID"].ToString().ToLower().Equals(preferencesProvider.ToLower())); Expression<Func<ComposablePartDefinition, bool>> findDefaultLogger = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IPreferencesProvider"))) && (def.Metadata.ContainsKey("IsDefault") && bool.Parse(def.Metadata["IsDefault"].ToString()) == true); // We don't want to search for the specified logger provider if // none was specified. if (string.IsNullOrEmpty(preferencesProvider)) { return new FilteredCatalog(parentCatalog, findDefaultLogger); } // If we get here, we need to try and find the logger provider specified // by the user newFilteredCatalog = new FilteredCatalog(parentCatalog, findSpecifiedLogger); // If the catalog is empty, fall to the default if ((newFilteredCatalog.Parts == null) || (newFilteredCatalog.Parts.Count() == 0)) { // If we didn't find any parts, we should try again and just get the // default provider return new FilteredCatalog(parentCatalog, findDefaultLogger); } return newFilteredCatalog; }
/// <summary> /// Builds and returns a special catalog, based on the application assembly, that /// has been filtered to contain all tool panel extensions /// </summary> /// <param name="parentCatalog"></param> /// <returns>a Berico.LinkAnalysis.SnagL.Modularity.FilteredCatalog containing all /// Tool Panel extensions</returns> private static FilteredCatalog BuildToolPanelExtensionsCatalog(ComposablePartCatalog parentCatalog) { // Retrieve the name of the configrued preference provider //string preferencesProvider = ConfigurationManager.GetValue(ConfigurationManager.PARAMETER_PREFERENCES_PROVIDER); FilteredCatalog newFilteredCatalog = null; Expression<Func<ComposablePartDefinition, bool>> findAllToolPanelItemExtensions = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IToolPanelItemViewExtension")) || (def.Metadata.ContainsKey("ID") && def.Metadata["ID"].ToString().ToLower().Equals("toolpanelitemviewmodelextension"))); // If we get here, we need to try and find the logger provider specified // by the user newFilteredCatalog = new FilteredCatalog(parentCatalog, findAllToolPanelItemExtensions); return newFilteredCatalog; }
/// <summary> /// </summary> /// <param name="parentCatalog"></param> /// <returns></returns> private static FilteredCatalog BuildRankingCatalog(ComposablePartCatalog parentCatalog) { FilteredCatalog newFilteredCatalog = null; Expression<Func<ComposablePartDefinition, bool>> findAllRankingExtensions = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IRanker"))); newFilteredCatalog = new FilteredCatalog(parentCatalog, findAllRankingExtensions); return newFilteredCatalog; }
/// <summary> /// Adds a predicate condition that exposes additional instances from the source. /// </summary> /// <param name="predicate"></param> public void Or(Func <ComposablePartDefinition, bool> predicate) { // filter remainder of previous filter aggregate.Catalogs.Add(filter = filter.Complement.Filter(i => predicate(i))); }
/// <summary> /// Initializes a new instance. By default no instances from <paramref name="source"/> are exposed. /// </summary> /// <param name="source"></param> public DynamicFilteredCatalog(ComposablePartCatalog source) { aggregate = new AggregateCatalog(filter = source.Filter(i => false)); }
public void ResolveSaucesByFilteredCatalog() { var representative = typeof(Ploeh.Samples.Menu.Mef.Attributed.Unmodified.Abstract.SauceBéarnaise); var assemblyCatalog = new AssemblyCatalog(representative.Assembly); var catalog = new FilteredCatalog(assemblyCatalog, def => def.ExportDefinitions.Any(x => x.ContractName.Contains("Sauce"))); var container = new CompositionContainer(catalog); var sauces = container.GetExportedValues<IIngredient>(); Assert.True(sauces.OfType<SauceBéarnaise>().Any()); Assert.True(sauces.OfType<SauceHollandaise>().Any()); Assert.True(sauces.OfType<SauceMousseline>().Any()); Assert.False(sauces.OfType<Steak>().Any()); }
/// <summary> /// Builds and returns a special catalog, based on the application assembly, that /// has been filtered to contain all similarity measure classes /// </summary> /// <param name="parentCatalog"></param> /// <returns>a Berico.LinkAnalysis.SnagL.Modularity.FilteredCatalog containing the /// configured preference provider; otherwise the default perference provider</returns> private static FilteredCatalog BuildSimilarityMeasureExtensionsCatalog(ComposablePartCatalog parentCatalog) { // Retrieve the name of the configrued preference provider //string preferencesProvider = ConfigurationManager.GetValue(ConfigurationManager.PARAMETER_PREFERENCES_PROVIDER); FilteredCatalog newFilteredCatalog = null; Expression<Func<ComposablePartDefinition, bool>> findAllSimilarityMeasureExtensions = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("ISimilarityMeasure")) || (def.Metadata.ContainsKey("ID") && def.Metadata["ID"].ToString().ToLower().Equals("SimilarityMeasureExtension"))); //Expression<Func<ComposablePartDefinition, bool>> findDefaultLogger = (def) => (def.ExportDefinitions.Any(exportDef => exportDef.ContractName.EndsWith("IPreferencesProvider"))) && (def.Metadata.ContainsKey("IsDefault") && bool.Parse(def.Metadata["IsDefault"].ToString()) == true); // If we get here, we need to try and find the logger provider specified // by the user newFilteredCatalog = new FilteredCatalog(parentCatalog, findAllSimilarityMeasureExtensions); return newFilteredCatalog; }