public static async Task TouchCatalog(ComposablePartCatalog composablePartCatalog) { var aggregate = composablePartCatalog as AggregateCatalog; if (aggregate != null) { //foreach (var catalog in aggregate.Catalogs) //{ // TouchCatalog(catalog); //} var actionList = new List<Task>(); foreach (var item in aggregate.Catalogs) { actionList.Add(TouchCatalog(item)); } await Task.WhenAll(actionList.ToArray()); } else { var metadataAssemblyCatalog = composablePartCatalog as MetadataAssemblyCatalog; if (metadataAssemblyCatalog != null) { await metadataAssemblyCatalog.Realize(); } foreach (var part in composablePartCatalog.Parts) { TouchPart(part); } } }
public MEFedMVVMExportProvider(ComposablePartCatalog catalog) { _exportProvider = new CatalogExportProvider(catalog); //support recomposition _exportProvider.ExportsChanged += (s, e) => OnExportsChanged(e); _exportProvider.ExportsChanging += (s, e) => OnExportsChanging(e); }
public GenericCatalog(ComposablePartCatalog catalog) { _decoratedCatalog = catalog; _catalog.Catalogs.Add(_decoratedCatalog); _catalog.Changing += (s, e) => { OnChanging(e); }; LoadTypeLocators(_genericTypes); }
public MefUnityContainerExtension(ComposablePartCatalog catalog, bool register, params ExportProvider[] providers) { Debug.Assert(catalog != null); m_Catalog = catalog; m_Register = register; m_Providers = providers; }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="parent"></param> /// <param name="scope"></param> public ScopeCatalog(ComposablePartCatalog parent, Scope scope) : base(parent, GetFilter(scope)) { Contract.Requires<ArgumentNullException>(parent != null); this.scope = scope; }
/// <summary> /// Initializes a new instance of the <see cref="WebPartsCatalog" /> class. Overloaded constructor allows caller to specify one or more assemblies and /// optionally MEF conventions for finding parts. /// </summary> /// <param name="assemblies">The assemblies.</param> /// <param name="reflectionContext">The reflection context.</param> public WebPartsCatalog(Assembly[] assemblies, ReflectionContext reflectionContext = null) { if (reflectionContext == null) reflectionContext = GetWebPartConventions(); catalog = new AggregateCatalog(assemblies.Select(a => new AssemblyCatalog(a, reflectionContext))); }
/// <summary> /// Initializes a new instance of the <see cref="CompositionScopeDefinition"/> class. /// </summary> /// <param name="catalog">The catalog.</param> /// <param name="children">The children.</param> public CompositionScopeDefinition(ComposablePartCatalog catalog, IEnumerable<CompositionScopeDefinition> children) { Requires.NotNull(catalog, "catalog"); Requires.NullOrNotNullElements(children, "children"); InitializeCompositionScopeDefinition(catalog, children, null); }
public FilteredCatalog(ComposablePartCatalog inner, Func<ComposablePartDefinition, bool> filter) { _inner = inner; _innerNotifyChange = inner as INotifyComposablePartCatalogChanged; _partsQuery = inner.Parts.Where(filter).AsQueryable(); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="xml"></param> /// <param name="catalog"></param> /// <param name="exports"></param> Document( Func<Document, XDocument> xml, ComposablePartCatalog catalog, ExportProvider exports) { Contract.Requires<ArgumentNullException>(xml != null); // configure composition this.configuration = GetConfiguration(catalog, exports); this.container = new CompositionContainer(configuration.HostCatalog, true, new CompositionContainer(configuration.GlobalCatalog, true, configuration.Exports)); this.container.GetExportedValue<DocumentEnvironment>().SetHost(this); // required services this.invoker = container.GetExportedValue<IInvoker>(); this.trace = container.GetExportedValue<ITraceService>(); // initialize xml this.xml = xml(this); this.xml.AddAnnotation(this); // parallel initialization of common interfaces Parallel.ForEach(this.xml.DescendantNodesAndSelf(), i => { Enumerable.Empty<object>() .Concat(i.Interfaces<IOnInit>()) .Concat(i.Interfaces<IOnLoad>()) .ToLinkedList(); }); // initial invocation entry this.invoker.Invoke(() => { }); }
public IQueryable<ComposablePart> SelectParts(ComposablePartCatalog catalog) { var parts = from part in catalog.Parts where part.ExportDefinitions.Any(d => d.ContractName == typeof(IOperatorsPackage).FullName) select part.CreatePart(); return parts; }
/// <summary> /// Initializes a new instance of the FilteredCatalog class with the specified underlying /// catalog and filter. /// </summary> public FilteredCatalog(ComposablePartCatalog inner, Expression<Func<ComposablePartDefinition, bool>> expression) { _inner = inner; _innerNotifyChange = inner as INotifyComposablePartCatalogChanged; _partsQuery = inner.Parts.Where(expression); }
public NetworkAwareCatalog(ComposablePartCatalog filteredCatalog) { _networkStatus = (NetworkInterface.GetIsNetworkAvailable()) ? "Online" : "Offline"; NetworkChange.NetworkAvailabilityChanged += new NetworkAvailabilityChangedEventHandler(NetworkAvailabilityChanged); _filteredCatalog = filteredCatalog; }
internal CompositionService(ComposablePartCatalog composablePartCatalog) { Assumes.NotNull(composablePartCatalog); this._notifyCatalog = composablePartCatalog as INotifyComposablePartCatalogChanged; try { if(this._notifyCatalog != null) { this._notifyCatalog.Changing += this.OnCatalogChanging; } var compositionOptions = CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe | CompositionOptions.ExportCompositionService; var compositionContainer = new CompositionContainer(composablePartCatalog, compositionOptions); this._compositionContainer = compositionContainer; } catch { if(this._notifyCatalog != null) { this._notifyCatalog.Changing -= this.OnCatalogChanging; } throw; } }
/// <summary> /// Registers a MEF catalog within Unity container. /// </summary> /// <param name="unityContainer">Unity container instance.</param> /// <param name="catalog">MEF catalog to be registered.</param> /// <param name="isThreadSafe">Indicates if MEF should be thread safe.</param> public static void RegisterCatalog(this IUnityContainer unityContainer, ComposablePartCatalog catalog, bool isThreadSafe = false) { lock (unityContainer) { var compositionIntegration = EnableCompositionIntegration(unityContainer, isThreadSafe); compositionIntegration.Catalogs.Add(catalog); } }
/// <summary> /// Initializes a new instance of the <see cref="CompositionScopeDefinition"/> class. /// </summary> /// <param name="catalog">The catalog.</param> /// <param name="children">The children.</param> /// <param name="publicSurface">The exports that can be used to create new scopes.</param> public CompositionScopeDefinition(ComposablePartCatalog catalog, IEnumerable<CompositionScopeDefinition> children, IEnumerable<ExportDefinition> publicSurface) { Requires.NotNull(catalog, "catalog"); Requires.NullOrNotNullElements(children, "children"); Requires.NullOrNotNullElements(publicSurface, "publicSurface"); InitializeCompositionScopeDefinition(catalog, children, publicSurface); }
public ScopedContainerManager(ComposablePartCatalog rootCatalog) { if (rootCatalog == null) throw new ArgumentNullException("rootCatalog"); _rootCatalog = rootCatalog; _container = new CompositionContainer(new FilteredCatalog(rootCatalog, def => GetAllWithinAppScope(def)), true); }
public CatalogChangeProxy(ComposablePartCatalog originalCatalog, IEnumerable<ComposablePartDefinition> addedParts, IEnumerable<ComposablePartDefinition> removedParts) { this._originalCatalog = originalCatalog; this._addedParts = new List<ComposablePartDefinition>(addedParts); this._removedParts = new HashSet<ComposablePartDefinition>(removedParts); }
public ForceFieldContainer(ComposablePartCatalog catalog, Configuration config) : base(catalog) { Guard.ArgumentIsNotNull(() => catalog, () => config); _config = config; _config.SetInnerContainer(this); }
public void Constructor3_ArrayWithNullAsCatalogsArgument_ShouldThrowArgument() { var catalogs = new ComposablePartCatalog[] { null }; ExceptionAssert.ThrowsArgument<ArgumentException>("catalogs", () => { new AggregateCatalog(catalogs); }); }
public InterceptingCatalog(ComposablePartCatalog interceptedCatalog, IExportedValueInterceptor valueInterceptor, IList<IExportHandler> handlers) { interceptedCatalog.ShouldNotBeNull("interceptedCatalog"); valueInterceptor.ShouldNotBeNull("valueInterceptor)"); _interceptedCatalog = interceptedCatalog; _valueInterceptor = valueInterceptor; _handlers = handlers; InitializeHandlers(); }
public static CompositionContainer Create(ComposablePartCatalog catalog) { var container = new CompositionContainer(new AggregateCatalog(catalog, new TypeCatalog(typeof(CompositionContainer)))); container.ComposeExportedValue<CompositionContainer>(container); return container; }
public CatalogContractInformationProvider(ComposablePartCatalog catalog) { _catalog = catalog; var changeableCatalog = _catalog as INotifyComposablePartCatalogChanged; if (changeableCatalog != null) { changeableCatalog.Changed +=new EventHandler<ComposablePartCatalogChangeEventArgs>(catalog_Changed); } }
/// <summary> /// Initializes a new instance of the <see cref="ProxyCatalog"/> class. /// </summary> /// <param name="innerCatalog">The inner catalog.</param> public ProxyCatalog(ComposablePartCatalog innerCatalog) { this.innerCatalog = innerCatalog; parts = CreateFrom(this.innerCatalog); var notifyingCatalog = this.innerCatalog as INotifyComposablePartCatalogChanged; if(notifyingCatalog != null) notifyingCatalog.Changing += NotifyingCatalog_Changing; }
/// <summary> /// Creates a new instance of the <see cref="ComponentCatalog"/> class. /// </summary> /// <param name="innerCatalog"></param> public ComponentCatalog(ComposablePartCatalog innerCatalog) : base(new FilteringReflectionCatalog(innerCatalog) { PartFilter = part => part.PartType.AsComponent() != null, ExportFilter = export => export.ExportingType.AsComponent() != null }) { base.PartMetadataDecorator = PartDecorator; base.ExportMetadataDecorator = ExportDecorator; }
public DynamicProxyValueInterceptorContext() { var innerCatalog = new TypeCatalog(typeof(Customer)); var interceptor = new FreezableInterceptor(); interceptor.Freeze(); var valueInterceptor = new DynamicProxyInterceptor(interceptor); Catalog = new InterceptingCatalog(innerCatalog, valueInterceptor); Container = new CompositionContainer(Catalog); Context(); }
/// <summary> /// Initializes a new instance of the <see cref="WebApplicationCatalog"/> class. /// </summary> /// <param name="assemblies">The assemblies.</param> /// <param name="reflectionContext">The reflection context.</param> protected WebApplicationCatalog(IEnumerable<Assembly> assemblies, ReflectionContext reflectionContext = null) { if (!IsInitialized) { if (reflectionContext == null) reflectionContext = DefineConventions(); applicationCatalog = new AggregateCatalog(assemblies.Select(a => new AssemblyCatalog(a, reflectionContext))); } }
public IntegrationTests() { _catalog = new TypeCatalog( typeof(Foo), typeof(Bar), typeof(Biff), typeof(MissingMeta), typeof(WrongCreationPolicy), typeof(WrongTypeIdentity)); _container = new CompositionContainer(_catalog); _analysis = new CompositionInfo(_catalog, _container); }
/// <summary> /// Initializes a new instance of the <see cref="AggregateCatalog"/> class. /// </summary> /// <param name="backend">The backend.</param> /// <param name="environments">The environments.</param> public EnvironmentCatalog(ComposablePartCatalog backend, IEnumerable<string> environments) { if (environments == null) throw new ArgumentNullException("environment"); if (backend == null) throw new ArgumentNullException("backend"); _environments = new HashSet<string>(environments, StringComparer.Ordinal); _catalog = backend; this._partsQuery = this._catalog.Parts.AsQueryable(); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="catalog"></param> /// <param name="exports"></param> public CompositionConfiguration( ComposablePartCatalog catalog, ExportProvider exports) : this(new ScopeCatalog(catalog, Scope.Global), new ScopeCatalog(catalog, Scope.Host), new ScopeCatalog(catalog, Scope.Object), exports) { Contract.Requires<ArgumentNullException>(catalog != null); Contract.Requires<ArgumentNullException>(exports != null); }
public EmbeddableDocumentStore NewDocumentStore( bool deleteDirectory = true, string requestedStorage = null, ComposablePartCatalog catalog = null, bool deleteDirectoryOnDispose = true) { path = Path.GetDirectoryName(Assembly.GetAssembly(typeof(DocumentStoreServerTests)).CodeBase); path = Path.Combine(path, "TestDb").Substring(6); string defaultStorageType = GetDefaultStorageType(requestedStorage); var documentStore = new EmbeddableDocumentStore { Configuration = { DefaultStorageTypeName = defaultStorageType, DataDirectory = path, RunInUnreliableYetFastModeThatIsNotSuitableForProduction = true, RunInMemory = false, Port = 8079 } }; if (catalog != null) documentStore.Configuration.Catalog.Catalogs.Add(catalog); try { ModifyStore(documentStore); ModifyConfiguration(documentStore.Configuration); if (deleteDirectory) IOExtensions.DeleteDirectory(path); documentStore.Initialize(); CreateDefaultIndexes(documentStore); if (deleteDirectoryOnDispose) documentStore.Disposed += ClearDatabaseDirectory; return documentStore; } catch { // We must dispose of this object in exceptional cases, otherwise this test will break all the following tests. documentStore.Dispose(); throw; } finally { stores.Add(documentStore); } }
public FilteredCatalog(ComposablePartCatalog sourceCatalog, Func <ComposablePartDefinition, bool> inclusiveFilter) { this.inclusiveFilter = inclusiveFilter; this.sourceCatalog = sourceCatalog; }
private static CatalogExportProvider CreateCatalogExportProvider(ComposablePartCatalog catalog) { return(new CatalogExportProvider(catalog)); }
public void AddCatalog(ComposablePartCatalog catalog) { this._catalog.Catalogs.Add(catalog); }
public MefDependencySolver(ComposablePartCatalog catalog) { _catalog = catalog; }
/// <summary> /// Initialise une nouvelle instance de la classe <see cref="TransientCompositionContainer"/>. /// </summary> /// <param name="catalog">Un catalogue fournissant des objets <see cref="System.ComponentModel.Composition.Primitives.Export"/> au conteneur.</param> /// <param name="providers">Un tableur de fournisseur d'exports.</param> public TransientCompositionContainer(ComposablePartCatalog catalog, params ExportProvider[] providers) : base(catalog, providers) { }
public BuiltinFilteringCatalog(ComposablePartCatalog catalogToFilter) : base(catalogToFilter) { }
/// <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 ViewModulesCatalog(ComposablePartCatalog inner, IPermissionsProvider permissionsProvider) : base(inner, part => part.ExportDefinitions.All(def => permissionsProvider.IsAllowed(def)))
/// <summary> /// Registers a MEF catalog within Unity container. /// </summary> /// <param name="unityContainer">Unity container instance.</param> /// <param name="catalog">MEF catalog to be registered.</param> public static void RegisterCatalog(this IUnityContainer unityContainer, ComposablePartCatalog catalog) { EnsureUnityHasHolder(unityContainer); ExtensionHolders[unityContainer].Catalog.Catalogs.Add(catalog); }
public DesignTimeCatalog(ComposablePartCatalog inner) { _inner = inner; _innerNotifyChange = inner as INotifyComposablePartCatalogChanged; }
public SelectionPriorityContainer(ComposablePartCatalog catalog) : base(catalog) { }
/// <summary> /// Creates a new Embeddable document store. /// </summary> /// <param name="runInMemory">Whatever the database should run purely in memory. When running in memory, nothing is written to disk and if the server is restarted all data will be lost.<br/>Default: <b>true</b></param> /// <param name="requestedStorage">What storage type to use (see: RavenDB Storage engines).<br/>Allowed values: <b>vornon</b>, <b>esent</b>.<br/>Default: <b>voron</b></param> /// <param name="catalog">Custom bundles that are not provided by RavenDb.</param> /// <param name="dataDir">The path for the database directory. Can use ~\ as the root, in which case the path will start from the server base directory. <br/>Default: <b>~\Data</b></param> /// <param name="enableAuthentication"></param> /// <param name="activeBundles">Semicolon separated list of bundles names, such as: 'Replication;Versioning'.<br/>Default: no bundles turned on.</param> /// <param name="port">The port to use when creating the http listener. Allowed: 1 - 65,536 or * (find first available port from 8079 and upward).<br/>Default: <b>8079</b></param> /// <param name="anonymousUserAccessMode">Determines what actions an anonymous user can do. Get - read only, All - read & write, None - allows access to only authenticated users, Admin - all (including administrative actions).<br/>Default: <b>Get</b></param> /// <param name="configureStore">An action delegate which allows you to configure the document store instance that is returned. eg. <code>configureStore: store => store.DefaultDatabase = "MasterDb"</code></param> /// <param name="databaseName">Name of the server that will show up on /admin/stats endpoint.</param> /// <param name="indexes">A collection of indexes to execute.</param> /// <param name="transformers">A collection of transformers to execute.</param> /// <param name="seedData">A collection of some fake data that will be automatically stored into the document store.</param> /// <remarks>Besides the document store being instantiated, it is also Initialized.<br/>Also, any indexes or transfomers that are provided, the process will not wait for them to be completed/not stale. You need to explicity call the <code>WaitForIndexing(..)</code> method.<br/>For further info, please goto: http://ravendb.net/docs/article-page/2.5/csharp/server/administration/configuration</remarks> /// <returns>A new instance of an EmbeddableDocumentStore.</returns> public EmbeddableDocumentStore NewDocumentStore( bool runInMemory = true, string requestedStorage = null, ComposablePartCatalog catalog = null, string dataDir = null, bool enableAuthentication = false, string activeBundles = null, int?port = null, AnonymousUserAccessMode anonymousUserAccessMode = AnonymousUserAccessMode.Admin, Action <EmbeddableDocumentStore> configureStore = null, [CallerMemberName] string databaseName = null, IEnumerable <AbstractIndexCreationTask> indexes = null, IEnumerable <AbstractTransformerCreationTask> transformers = null, IEnumerable <IEnumerable> seedData = null) { databaseName = NormalizeDatabaseName(databaseName); var storageType = GetDefaultStorageType(requestedStorage); var dataDirectory = dataDir ?? NewDataPath(databaseName); var documentStore = new EmbeddableDocumentStore { UseEmbeddedHttpServer = port.HasValue, Configuration = { DefaultStorageTypeName = storageType, DataDirectory = Path.Combine(dataDirectory, "System"), RunInUnreliableYetFastModeThatIsNotSuitableForProduction = true, RunInMemory = storageType.Equals("esent", StringComparison.OrdinalIgnoreCase) == false && runInMemory, Port = port ?? 8079, AnonymousUserAccessMode = anonymousUserAccessMode, } }; documentStore.Configuration.FileSystem.DataDirectory = Path.Combine(dataDirectory, "FileSystem"); documentStore.Configuration.Encryption.UseFips = SettingsHelper.UseFipsEncryptionAlgorithms; if (activeBundles != null) { documentStore.Configuration.Settings["Raven/ActiveBundles"] = activeBundles; } if (catalog != null) { documentStore.Configuration.Catalog.Catalogs.Add(catalog); } try { if (configureStore != null) { configureStore(documentStore); } ModifyStore(documentStore); ModifyConfiguration(documentStore.Configuration); documentStore.Configuration.PostInit(); documentStore.Initialize(); if (enableAuthentication) { EnableAuthentication(documentStore.SystemDatabase); } CreateDefaultIndexes(documentStore); if (indexes != null) { ExecuteIndexes(indexes, documentStore); } if (transformers != null) { ExecuteTransformers(transformers, documentStore); } if (seedData != null) { StoreSeedData(seedData, documentStore); } return(documentStore); } catch { // We must dispose of this object in exceptional cases, otherwise this test will break all the following tests. documentStore.Dispose(); throw; } finally { stores.Add(documentStore); } }
public static void AddCatalog(ComposablePartCatalog item) { catalogs.Add(item); }
public static ComposablePartCatalog CreateFiltered(ComposablePartCatalog catalog, Func <ComposablePartDefinition, bool> filter) { return(new FilteredCatalog(catalog, filter)); }
protected IEnumerable <ITechnology> InitializeMEF( ComposablePartCatalog catalog) { using (CompositionContainer compositionContainer = new CompositionContainer(catalog, Array.Empty <ExportProvider>())) return((IEnumerable <ITechnology>)compositionContainer.GetExports <ITechnology>().Select <Lazy <ITechnology>, ITechnology>((Func <Lazy <ITechnology>, ITechnology>)(n => n.Value)).ToList <ITechnology>()); }
/// <summary> /// Initializes the catalog. /// </summary> public FilteringReflectionCatalog(ComposablePartCatalog innerCatalog) { this.innerCatalog = innerCatalog; this.PartFilter = context => true; this.ExportFilter = context => true; }
public CustomCatalog(ComposablePartCatalog catalog) { _innerCatalog = catalog; _partDefinitions = new Dictionary <ComposablePartDefinition, CustomComposablePartDefinition>(); }
public MefUnityContainerExtension(ComposablePartCatalog catalog, params ExportProvider[] providers) : this(catalog, true, providers) { }
public TestComposition() { PartCatalog = GetAssemblyCatalog(GetTypes()); ExportProvider = new CompositionContainer(PartCatalog, isThreadSafe: true); MinimumCatalog = new AggregateCatalog(new TypeCatalog(GetRoslynTypes()), GetAssemblyCatalog(GetVisualStudioTypes())); }
public static string GetDisplayName(this ComposablePartCatalog catalog) { return(GetDisplayNameCore(catalog)); }
public PlugInContainer(ComposablePartCatalog catalog) : this() { AddCatalog(catalog); }
/// <summary> /// 初始化 <see cref="SingleCompositionContainer"/> 类的新实例。 /// </summary> /// <param name="catalog">对象的组合目录。</param> /// <param name="providers">附加一组 <see cref="ExportProvider"/> 对象。</param> public SingleCompositionContainer(ComposablePartCatalog catalog, params ExportProvider[] providers) : base(catalog, exports => exports.FirstOrDefault(), providers) { }
private ComposablePartCatalog ScopeCatalog(ComposablePartCatalog catalog, string scope) { return(CatalogFactory.CreateFiltered(catalog, partDef => partDef.Metadata.ContainsKey("Scope") && partDef.Metadata["Scope"].ToString() == scope)); }