/// <summary> /// Resolves an collection of objects wrapped inside <see cref="Lazy{T}"/> /// from an <see cref="ExportProvider"/>. /// </summary> /// <param name="exportProvider">Export provider.</param> /// <param name="type">Type to be resolved.</param> /// <param name="name">Optional name.</param> /// <returns>Resolved collection of lazy instances or null, if no instance has been found.</returns> /// <remarks> /// Does not resolve instances which are provided by means of /// <see cref="FactoryExportProvider"/>. /// </remarks> public static IEnumerable<Lazy<object>> ResolveAll(ExportProvider exportProvider, Type type, string name) { if (exportProvider == null) { throw new ArgumentNullException("exportProvider"); } if (type == null) { throw new ArgumentNullException("type"); } var exports = exportProvider.GetExports(type, null, name); if (exports.Count() == 0) return Enumerable.Empty<Lazy<object>>(); var list = new List<Lazy<object>>(); foreach (var export in exports) { var lazyExportMetadata = export.Metadata as IDictionary<string, object>; if (lazyExportMetadata != null && lazyExportMetadata.ContainsKey(FactoryExportDefinition.IsFactoryExportMetadataName) && true.Equals(lazyExportMetadata[FactoryExportDefinition.IsFactoryExportMetadataName])) { continue; } list.Add(export); } return list; }
/// <summary> /// Configurates the specified export provider. /// </summary> /// <param name="exportProvider">The export provider.</param> /// <param name="loggerFactoryName">Name of the logger factory.</param> /// <exception cref="System.ArgumentNullException">exportProvider</exception> public static void Configurate(ExportProvider exportProvider, string loggerFactoryName = null) { if (exportProvider == null) throw new ArgumentNullException("exportProvider"); var lazyLogFactory = exportProvider.GetExports<ILoggerFactory, ILoggerFactoryMetadata>() .Where(f => string.IsNullOrEmpty(loggerFactoryName) || f.Metadata.Name.Equals(loggerFactoryName, StringComparison.OrdinalIgnoreCase)) .OrderBy(f => f.Metadata.Priority) .FirstOrDefault(); if (lazyLogFactory == null) return; var metadata = lazyLogFactory.Metadata; var configFiles = new List<string>(); if (!string.IsNullOrEmpty(metadata.ConfigFileName)) { configFiles.Add(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, metadata.ConfigFileName)); configFiles.Add(Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Config"), metadata.ConfigFileName)); } var facotry = lazyLogFactory.Value; if (!facotry.Initialize(configFiles.ToArray())) return; m_Current = facotry; }
/// <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(() => { }); }
/// <summary> /// Initializes a new instance of the <see cref="AggregateExportProvider"/> class. /// </summary> /// <param name="providers">The prioritized list of export providers.</param> /// <exception cref="ArgumentException"> /// <paramref name="providers"/> contains an element that is <see langword="null"/>. /// </exception> /// <remarks> /// <para> /// The <see cref="AggregateExportProvider"/> will consult the providers in the order they have been specfied when /// executing <see cref="ExportProvider.GetExports(ImportDefinition,AtomicComposition)"/>. /// </para> /// <para> /// The <see cref="AggregateExportProvider"/> does not take ownership of the specified providers. /// That is, it will not try to dispose of any of them when it gets disposed. /// </para> /// </remarks> public AggregateExportProvider(params ExportProvider[] providers) { // NOTE : we optimize for the array case here, because the collection of providers is typically tiny // Arrays are much more compact to store and much faster to create and enumerate ExportProvider[] copiedProviders = null; if (providers != null) { copiedProviders = new ExportProvider[providers.Length]; for (int i = 0; i < providers.Length; i++) { ExportProvider provider = providers[i]; if (provider == null) { throw ExceptionBuilder.CreateContainsNullElement("providers"); } copiedProviders[i] = provider; provider.ExportsChanged += this.OnExportChangedInternal; provider.ExportsChanging += this.OnExportChangingInternal; } } else { copiedProviders = new ExportProvider[] { }; } this._providers = copiedProviders; this._readOnlyProviders = new ReadOnlyCollection<ExportProvider>(this._providers); }
static CompositionContainer CreateCompositionContainer(ExportProvider defaultExportProvider) { var catalog = new LoggingCatalog( GetCatalog(typeof(DialogService).Assembly), // GitHub.App GetCatalog(typeof(GraphQLClientFactory).Assembly), // GitHub.Api GetCatalog(typeof(RepositoryCloneView).Assembly), // GitHub.VisualStudio.UI GetCatalog(typeof(GitHubPackage).Assembly), // GitHub.VisualStudio GetCatalog(typeof(VSGitServices).Assembly), // GitHub.TeamFoundation.16 GetCatalog(typeof(GitService).Assembly), // GitHub.Exports GetCatalog(typeof(NotificationDispatcher).Assembly), // GitHub.Exports.Reactive GetCatalog(typeof(IOperatingSystem).Assembly) // Rothko ); var compositionContainer = new CompositionContainer(catalog, defaultExportProvider); var gitHubServiceProvider = new MyGitHubServiceProvider(compositionContainer); compositionContainer.ComposeExportedValue <IGitHubServiceProvider>(gitHubServiceProvider); Services.UnitTestServiceProvider = gitHubServiceProvider; // Use gitHubServiceProvider as global provider var loginManager = LoginManagerFactory.CreateLoginManager(compositionContainer); compositionContainer.ComposeExportedValue(loginManager); // Ensure GitHub.Resources.dll has been loaded and it visible to XAML EnsureLoaded(typeof(GitHub.Resources)); return(compositionContainer); }
/// <summary> /// Resolves an object wrapped inside <see cref="Lazy{T}"/> from an <see cref="ExportProvider"/>. /// </summary> /// <param name="exportProvider">Export provider.</param> /// <param name="type">Type to be resolved.</param> /// <param name="name">Optional name.</param> /// <returns>Resolved instance or null, if no instance has been found.</returns> /// <remarks> /// Does not resolve instances which are provided by means of /// <see cref="FactoryExportProvider"/>. /// </remarks> public static Lazy<object> Resolve(ExportProvider exportProvider, Type type, string name) { if (exportProvider == null) { throw new ArgumentNullException("exportProvider"); } if (type == null) { throw new ArgumentNullException("type"); } var exports = exportProvider.GetExports(type, null, name); if (exports.Count() == 0) return null; if (exports.Count() > 1) throw new ImportCardinalityMismatchException(Resources.TooManyInstances); var lazyExport = exports.First(); var lazyExportMetadata = lazyExport.Metadata as IDictionary<string, object>; if (lazyExportMetadata != null && lazyExportMetadata.ContainsKey(FactoryExportDefinition.IsFactoryExportMetadataName) && true.Equals(lazyExportMetadata[FactoryExportDefinition.IsFactoryExportMetadataName])) { return null; } return lazyExport; }
/// <summary> /// Initialises a new instance of <see cref="GlimpseExportProvider"/>. /// </summary> /// <param name="provider">The inner export provider.</param> internal GlimpseExportProvider(ExportProvider provider) { if (provider == null) throw new ArgumentNullException("provider"); _provider = provider; }
public ImportEngine(ExportProvider sourceProvider, bool isThreadSafe) { Requires.NotNull(sourceProvider, "sourceProvider"); this._sourceProvider = sourceProvider; this._sourceProvider.ExportsChanging += this.OnExportsChanging; this._lock = new CompositionLock(isThreadSafe); }
public static void CreateIndexes(ExportProvider catalogToGetnIndexingTasksFrom, IDocumentStore documentStore) { var tasks = catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>(); foreach (var task in tasks) { task.Execute(documentStore); } }
/// <summary> /// Creates the indexes found in the specified catalog /// </summary> /// <param name="catalogToGetnIndexingTasksFrom">The catalog to get indexing tasks from.</param> public static void CreateIndexes(ExportProvider catalogToGetnIndexingTasksFrom, IDatabaseCommands databaseCommands, DocumentConvention conventions) { var tasks = catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>(); foreach (var task in tasks) { task.Execute(databaseCommands, conventions); } }
public RazorVersionDetectorOverridingExportProvider(ExportProvider exportProvider) { _inner = exportProvider; _razorVersionDetectorExports = new[] { new Export(IRazorVersionDetectorName, DecorateRazorVersionDetector) }; }
protected override void Initialize() { base.Initialize(); _componentModel = (IComponentModel)GetService(typeof(SComponentModel)); _exportProvider = _componentModel.DefaultExportProvider; _vim = _exportProvider.GetExportedValue<IVim>(); }
static CompositionContainer CreateVisualStudioCompositionContainer(ExportProvider defaultExportProvider) { var compositionContainer = CreateCompositionContainer(defaultExportProvider); var usageTracker = CreateUsageTracker(compositionContainer); compositionContainer.ComposeExportedValue(usageTracker); return(compositionContainer); }
public void Constructor3_ArrayAsProvidersArgument_ShouldNotAllowModificationAfterConstruction() { var providers = new ExportProvider[] { ExportProviderFactory.Create() }; var container = new CompositionContainer(CatalogFactory.Create(), providers); providers[0] = null; Assert.IsNotNull(container.Providers[0]); }
/// <summary> /// Creates the indexes found in the specified catalog /// </summary> /// <param name="catalogToGetnIndexingTasksFrom">The catalog to getn indexing tasks from.</param> /// <param name="documentStore">The document store.</param> public static Task CreateIndexesAsync(ExportProvider catalogToGetnIndexingTasksFrom, IDocumentStore documentStore) { var tasks = catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>(); Task[] array = tasks.Select(task => task.ExecuteAsync(documentStore)).ToArray(); var indexesAsync = new Task(() => Task.WaitAll(array)); indexesAsync.Start(); return indexesAsync; }
public void Constructor2_ArrayAsProvidersArgument_ShouldNotAllowModificationAfterConstruction() { var providers = new ExportProvider[] { ExportProviderFactory.Create() }; var provider = new AggregateExportProvider((IEnumerable<ExportProvider>)providers); providers[0] = null; Assert.IsNotNull(provider.Providers[0]); }
/// <summary> /// Creates the indexes found in the specified catalog /// </summary> public static Task CreateIndexesAsync(ExportProvider catalogToGetnIndexingTasksFrom, IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention conventions) { var tasks = catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>(); Task[] array = tasks.Select(task => task.ExecuteAsync(asyncDatabaseCommands, conventions)).ToArray(); var indexesAsync = new Task(() => Task.WaitAll(array)); indexesAsync.Start(); return indexesAsync; }
public RHistoryIntegrationTest(RComponentsMefCatalogFixture catalog) { _exportProvider = catalog.CreateExportProvider(); _textBufferFactory = _exportProvider.GetExportedValue<ITextBufferFactoryService>(); _textEditorFactory = _exportProvider.GetExportedValue<ITextEditorFactoryService>(); _workflowProvider = _exportProvider.GetExportedValue<IRInteractiveWorkflowProvider>(); _contentTypeRegistryService = _exportProvider.GetExportedValue<IContentTypeRegistryService>(); _interactiveWindowComponentContainerFactory = _exportProvider.GetExportedValue<IInteractiveWindowComponentContainerFactory>(); _historyVisualComponentContainerFactory = _exportProvider.GetExportedValue<IRHistoryVisualComponentContainerFactory>(); }
public ImportEngine(ExportProvider sourceProvider, CompositionOptions compositionOptions) { Requires.NotNull(sourceProvider, "sourceProvider"); this._compositionOptions = compositionOptions; this._sourceProvider = sourceProvider; this._sourceProvider.ExportsChanging += this.OnExportsChanging; this._lock = new CompositionLock(compositionOptions.HasFlag(CompositionOptions.IsThreadSafe)); }
public CommanderManager(ExportProvider container, AppSettingsSection appSettings, CommanderSection commanderSettings, IEnhancedFileSystemWatcherFactory enhancedFileSystemWatcherFactory) { NLogAppender.Initialize(); _container = container; _appSettings = appSettings; _commanderSettings = commanderSettings; _folderWatcherService = new FolderWatcherService(enhancedFileSystemWatcherFactory); IsRunning = false; }
public void TestSetUp() { var typeCatalog = new TypeCatalog(typeof(CtorOrderProcessor), typeof(OrderProcessor)); var genericCatalog = new GenericCatalog(new TestGenericContractRegistry()); var aggregateCatalog = new AggregateCatalog(typeCatalog, genericCatalog); var provider = new CatalogExportProvider(aggregateCatalog); provider.SourceProvider = provider; ExportProvider = provider; }
public ExampleForm(ExportProvider exportProvider) { _shaderFragments = exportProvider.GetExport<ShaderFragmentArchive.Archive>().Value; _nodeCreator = exportProvider.GetExport<NodeEditorCore.IShaderFragmentNodeCreator>().Value; _modelConversion = exportProvider.GetExport<NodeEditorCore.IModelConversion>().Value; InitializeComponent(); _hyperGraphModel = new HyperGraph.GraphModel(); _hyperGraphModel.CompatibilityStrategy = _nodeCreator.CreateCompatibilityStrategy(); _graphAdapter = new HyperGraph.GraphControl(); _graphAdapter.Attach(graphControl); _graphAdapter.HighlightCompatible = true; _graphAdapter.LargeGridStep = 160F; _graphAdapter.LargeStepGridColor = System.Drawing.Color.FromArgb(((int)(((byte)(90)))), ((int)(((byte)(90)))), ((int)(((byte)(90))))); _graphAdapter.ShowLabels = false; _graphAdapter.SmallGridStep = 20F; _graphAdapter.SmallStepGridColor = System.Drawing.Color.FromArgb(((int)(((byte)(80)))), ((int)(((byte)(80)))), ((int)(((byte)(80))))); _graphAdapter.Model = _hyperGraphModel; _graphAdapter.Selection = new GraphSelection(); _graphAdapter.Selection.SelectionChanged += OnFocusChanged; graphControl.MouseEnter += OnGraphMouseEnter; graphControl.Paint += graphControl_Paint; _tabGroupTextureNode = new RibbonTabGroup(_ribbon, (uint)RibbonMarkupCommands.cmdTabGroupTextureNode); _showLabels = new RibbonLib.Controls.RibbonCheckBox(_ribbon, (uint)RibbonMarkupCommands.cmdShowLabels); _showLabels.ExecuteEvent += new EventHandler<ExecuteEventArgs>(OnShowLabelsChanged); _generateTestScript = new RibbonLib.Controls.RibbonButton(_ribbon, (uint)RibbonMarkupCommands.cmdButtonTestScript); _generateTestScript.ExecuteEvent += new EventHandler<ExecuteEventArgs>(OnGenerateTestScript); _saveAsButton = new RibbonLib.Controls.RibbonButton(_ribbon, (uint)RibbonMarkupCommands.cmdSaveAs); _saveAsButton.ExecuteEvent += new EventHandler<ExecuteEventArgs>(OnSaveAs); _loadButton = new RibbonLib.Controls.RibbonButton(_ribbon, (uint)RibbonMarkupCommands.cmdLoad); _loadButton.ExecuteEvent += new EventHandler<ExecuteEventArgs>(OnLoad); var fragmentTreeModel = exportProvider.GetExport<NodeEditorCore.ShaderFragmentArchiveModel>().Value; _fragmentTree.Model = new Aga.Controls.Tree.SortedTreeModel(fragmentTreeModel); _fragmentTree.ItemDrag += new ItemDragEventHandler(OnFragmentTreeItemDrag); _fragmentTree.NodeMouseDoubleClick += new EventHandler<Aga.Controls.Tree.TreeNodeAdvMouseEventArgs>(OnFragmentTreeItemDoubleClick); // _materialParametersGrid.SelectedObject = new DictionaryPropertyGridAdapter(_document.PreviewMaterialState); try { LoadFile("defaultload.sh"); } catch(System.Exception) {} }
public void TestSetUp() { var typeCatalog = new TypeCatalog(typeof(CtorOrderProcessor), typeof(OrderProcessor), typeof(TestGenericContractRegistry)); var cfg = new InterceptionConfiguration().AddHandler(new GenericExportHandler()); var catalog = new InterceptingCatalog(typeCatalog, cfg); var provider = new CatalogExportProvider(catalog); provider.SourceProvider = provider; ExportProvider = provider; }
/// <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); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="catalog"></param> /// <param name="exports"></param> /// <param name="store"></param> /// <param name="cache"></param> ViewServer( ComposablePartCatalog catalog = null, ExportProvider exports = null, IDocumentStore store = null, IDocumentCache cache = null) { this.catalog = catalog; this.exports = exports; this.store = store ?? new DefaultDocumentStore(); this.cache = cache ?? new DefaultDocumentCache(); }
static CompositionContainer CreateVisualStudioCompositionContainer(ExportProvider defaultExportProvider) { var compositionContainer = CreateCompositionContainer(defaultExportProvider); var gitHubServiceProvider = compositionContainer.GetExportedValue <IGitHubServiceProvider>(); var packageSettings = new PackageSettings(gitHubServiceProvider); var usageTracker = UsageTrackerFactory.CreateUsageTracker(compositionContainer, packageSettings); compositionContainer.ComposeExportedValue(usageTracker); return(compositionContainer); }
private static ExportProvider[] AddSubstituteProvider(ExportProvider[] providers) { if (providers.Length == 0) { return new ExportProvider[] {new NSubstituteExportProvider()}; } ExportProvider[] newProviders = new ExportProvider[providers.Length + 1]; providers.CopyTo(newProviders, 0); newProviders[newProviders.Length - 1] = new NSubstituteExportProvider(); return newProviders; }
/// <summary> /// Creates a <see cref="CompositionContainer"/> with an <see cref="ApplicationCatalog"/> a /// <see cref="ConfigurationExportProvider"/>. The /// <see cref="ConfigurationExportProvider"/> is reads from the application's config file, /// either an App.Config or Web.Config file. /// </summary> /// <param name="additionalProviders"></param> /// <returns></returns> public static CompositionContainer CreateApplicationAndConfigFileContainer(params ExportProvider[] additionalProviders) { var applicationCatalog = new ApplicationCatalog(); var configExportProvider = new ConfigurationExportProvider(new FileConfigurationSource()); var exportProviders = new ExportProvider[1 + additionalProviders.Length]; exportProviders[0] = configExportProvider; Array.Copy(additionalProviders, 0, exportProviders, 1, additionalProviders.Length); var result = new CompositionContainer(applicationCatalog, configExportProvider); return result; }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="globalCatalog"></param> /// <param name="hostCatalog"></param> /// <param name="objectCatalog"></param> /// <param name="exports"></param> public CompositionConfiguration( ScopeCatalog globalCatalog, ScopeCatalog hostCatalog, ScopeCatalog objectCatalog, ExportProvider exports) { Contract.Requires<ArgumentNullException>(globalCatalog != null); Contract.Requires<ArgumentNullException>(hostCatalog != null); Contract.Requires<ArgumentNullException>(objectCatalog != null); Contract.Requires<ArgumentNullException>(exports != null); this.globalCatalog = globalCatalog; this.hostCatalog = hostCatalog; this.objectCatalog = objectCatalog; this.exports = exports; }
/// <summary> /// Creates the indexes found in the specified catalog /// </summary> public static void CreateIndexes(ExportProvider catalogToGetnIndexingTasksFrom, IDatabaseCommands databaseCommands, DocumentConvention conventions) { var indexCompilationExceptions = new List<IndexCompilationException>(); try { var tasks = catalogToGetnIndexingTasksFrom .GetExportedValues<AbstractIndexCreationTask>() .ToList(); var indexesToAdd = tasks .Select(x => new IndexToAdd { Definition = x.CreateIndexDefinition(), Name = x.IndexName, Priority = x.Priority ?? IndexingPriority.Normal }) .ToArray(); databaseCommands.PutIndexes(indexesToAdd); foreach (var task in tasks) task.AfterExecute(databaseCommands, conventions); } // For old servers that don't have the new entrypoint for executing multiple indexes catch (Exception) { foreach (var task in catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>()) { try { task.Execute(databaseCommands, conventions); } catch (IndexCompilationException e) { indexCompilationExceptions.Add(new IndexCompilationException("Failed to compile index name = " + task.IndexName, e)); } } } foreach (var task in catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractTransformerCreationTask>()) { task.Execute(databaseCommands, conventions); } if (indexCompilationExceptions.Any()) throw new AggregateException("Failed to create one or more indexes. Please see inner exceptions for more details.", indexCompilationExceptions); }
protected override void Initialize() { base.Initialize(); _componentModel = (IComponentModel)GetService(typeof(SComponentModel)); _exportProvider = _componentModel.DefaultExportProvider; // Add our command handlers for menu (commands must exist in the .vsct file) OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if ( null != mcs ) { // Create the command for the menu item. CommandID menuCommandID = new CommandID(GuidList.guidEasyMotionCmdSet, (int)PkgCmdIDList.CmdEasyMotionNavigate); MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID ); mcs.AddCommand( menuItem ); } }
protected override void Initialize() { base.Initialize(); _componentModel = (IComponentModel)GetService(typeof(SComponentModel)); _exportProvider = _componentModel.DefaultExportProvider; _vim = _exportProvider.GetExportedValue<IVim>(); // Add our command handlers for menu (commands must exist in the .vsct file) OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (null != mcs) { // Create the command for the menu item. var optionsId = new CommandID(GuidList.VsVimCommandSet, (int)CommandIds.Options); var optionsMenuItem = new MenuCommand(OnOptionsClick, optionsId); mcs.AddCommand(optionsMenuItem); } }
/// <summary> /// Creates the indexes found in the specified catalog /// </summary> public static async Task CreateIndexesAsync(ExportProvider catalogToGetnIndexingTasksFrom, IAsyncDatabaseCommands databaseCommands, DocumentConvention conventions) { var indexCompilationExceptions = new List<IndexCompilationException>(); var failed = false; try { var tasks = catalogToGetnIndexingTasksFrom .GetExportedValues<AbstractIndexCreationTask>() .ToList(); var indexesToAdd = CreateIndexesToAdd(tasks, conventions); await databaseCommands.PutIndexesAsync(indexesToAdd).ConfigureAwait(false); foreach (var task in tasks) await task.AfterExecuteAsync(databaseCommands, conventions).ConfigureAwait(false); } // For old servers that don't have the new endpoint for executing multiple indexes catch (Exception) { failed = true; } if (failed) { foreach (var task in catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>()) { try { await task.ExecuteAsync(databaseCommands, conventions).ConfigureAwait(false); } catch (IndexCompilationException e) { indexCompilationExceptions.Add(new IndexCompilationException("Failed to compile index name = " + task.IndexName, e)); } } } await CreateTransformersAsync(catalogToGetnIndexingTasksFrom, databaseCommands, conventions).ConfigureAwait(false); if (indexCompilationExceptions.Any()) throw new AggregateException("Failed to create one or more indexes. Please see inner exceptions for more details.", indexCompilationExceptions); }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (disposing) { if (!_isDisposed) { ExportProvider rootProvider = null; IDisposable disposableAncestorExportProvider = null; IDisposable disposableLocalExportProvider = null; IDisposable disposableRootProvider = null; ComposablePartExportProvider partExportProvider = null; CatalogExportProvider catalogExportProvider = null; ImportEngine importEngine = null; lock (_lock) { if (!_isDisposed) { rootProvider = _rootProvider; _rootProvider = null; disposableRootProvider = _disposableRootProvider; _disposableRootProvider = null; disposableLocalExportProvider = _disposableLocalExportProvider; _disposableLocalExportProvider = null; _localExportProvider = null; disposableAncestorExportProvider = _disposableAncestorExportProvider; _disposableAncestorExportProvider = null; _ancestorExportProvider = null; partExportProvider = _partExportProvider; _partExportProvider = null; catalogExportProvider = _catalogExportProvider; _catalogExportProvider = null; importEngine = _importEngine; _importEngine = null; _isDisposed = true; } } if (rootProvider != null) { rootProvider.ExportsChanged -= OnExportsChangedInternal; rootProvider.ExportsChanging -= OnExportsChangingInternal; } if (disposableRootProvider != null) { disposableRootProvider.Dispose(); } if (disposableAncestorExportProvider != null) { disposableAncestorExportProvider.Dispose(); } if (disposableLocalExportProvider != null) { disposableLocalExportProvider.Dispose(); } if (catalogExportProvider != null) { catalogExportProvider.Dispose(); } if (partExportProvider != null) { partExportProvider.Dispose(); } if (importEngine != null) { importEngine.Dispose(); } } } }
public ExportProvider GetExportProvider() { return(exportProvider = exportProvider ?? CreateCompositionContainer()); }
public CompositionServices(Microsoft.VisualStudio.Composition.ExportProvider defaultExportProvider) { this.defaultExportProvider = defaultExportProvider.AsExportProvider(); }
public MyGitHubServiceProvider(ExportProvider exportProvider) { ExportProvider = exportProvider; serviceProvider = exportProvider.GetExportedValue <SVsServiceProvider>(); }
/// <summary> /// Initializes a new instance of the <see cref="ImportEngine"/> class. /// </summary> /// <param name="sourceProvider"> /// The <see cref="ExportProvider"/> which provides the /// <see cref="ImportEngine"/> access to <see cref="Export"/>s. /// </param> public ImportEngine(ExportProvider sourceProvider) : this(sourceProvider, CompositionOptions.Default) { }
public ImportEngine(ExportProvider sourceProvider, bool isThreadSafe) : this(sourceProvider, isThreadSafe ? CompositionOptions.IsThreadSafe : CompositionOptions.Default) { }
/// <summary> /// Initializes a new instance of the <see cref="ImportEngine"/> class. /// </summary> /// <param name="sourceProvider"> /// The <see cref="ExportProvider"/> which provides the /// <see cref="ImportEngine"/> access to <see cref="Export"/>s. /// </param> public ImportEngine(ExportProvider sourceProvider) : this(sourceProvider, false) { }
/// <summary> /// Initializes a new instance of the <see cref="CompositionContainer"/> class /// with the specified catalog and export providers. /// </summary> /// <param name="compositionSettings"> /// <see cref="CompositionOptions"/> enumeration with flags controlling the composition. /// </param> /// <param name="providers"> /// A <see cref="Array"/> of <see cref="ExportProvider"/> objects which provide /// the <see cref="CompositionContainer"/> access to <see cref="Export"/> objects, /// or <see langword="null"/> to set <see cref="Providers"/> to an empty /// <see cref="ReadOnlyCollection{T}"/>. /// </param> /// <exception cref="ArgumentException"> /// <paramref name="providers"/> contains an element that is <see langword="null"/>. /// </exception> public CompositionContainer(ComposablePartCatalog catalog, CompositionOptions compositionOptions, params ExportProvider[] providers) { if (compositionOptions > (CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe | CompositionOptions.ExportCompositionService)) { throw new ArgumentOutOfRangeException("compositionOptions"); } _compositionOptions = compositionOptions; // We always create the mutable provider _partExportProvider = new ComposablePartExportProvider(compositionOptions); _partExportProvider.SourceProvider = this; // Create the catalog export provider, only if necessary if (catalog != null) { _catalogExportProvider = new CatalogExportProvider(catalog, compositionOptions); _catalogExportProvider.SourceProvider = this; } // Set the local export provider if (_catalogExportProvider != null) { _localExportProvider = new AggregateExportProvider(_partExportProvider, _catalogExportProvider); _disposableLocalExportProvider = _localExportProvider as IDisposable; } else { _localExportProvider = _partExportProvider; } // Set the ancestor export provider, if ancestors are supplied if ((providers != null) && (providers.Length > 0)) { // Aggregate ancestors if and only if more than one passed if (providers.Length > 1) { _ancestorExportProvider = new AggregateExportProvider(providers); _disposableAncestorExportProvider = _ancestorExportProvider as IDisposable; } else { if (providers[0] == null) { throw ExceptionBuilder.CreateContainsNullElement("providers"); } _ancestorExportProvider = providers[0]; } } // finally set the root provider if (_ancestorExportProvider == null) { // if no ancestors are passed, the local and the root are the same _rootProvider = _localExportProvider; } else { int exportProviderCount = 1 + ((catalog != null) ? 1 : 0) + ((providers != null) ? providers.Length : 0); ExportProvider[] rootProviders = new ExportProvider[exportProviderCount]; rootProviders[0] = _partExportProvider; int customProviderStartIndex = 1; if (catalog != null) { rootProviders[1] = _catalogExportProvider; customProviderStartIndex = 2; } if (providers != null) { for (int i = 0; i < providers.Length; i++) { rootProviders[customProviderStartIndex + i] = providers[i]; } } _rootProvider = new AggregateExportProvider(rootProviders); _disposableRootProvider = _rootProvider as IDisposable; } //Insert Composition Service if (compositionOptions.HasFlag(CompositionOptions.ExportCompositionService)) { this.ComposeExportedValue <ICompositionService>(new CompositionServiceShim(this)); } _rootProvider.ExportsChanged += OnExportsChangedInternal; _rootProvider.ExportsChanging += OnExportsChangingInternal; _providers = (providers != null) ? new ReadOnlyCollection <ExportProvider>((ExportProvider[])providers.Clone()) : EmptyProviders; }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (disposing) { if (!this._isDisposed) { bool disposeLock = false; INotifyComposablePartCatalogChanged catalogToUnsubscribeFrom = null; HashSet <IDisposable> partsToDispose = null; ImportEngine importEngine = null; ExportProvider sourceProvider = null; AggregateExportProvider aggregateExportProvider = null; try { using (this._lock.LockStateForWrite()) { if (!this._isDisposed) { catalogToUnsubscribeFrom = this._catalog as INotifyComposablePartCatalogChanged; this._catalog = null; aggregateExportProvider = this._innerExportProvider as AggregateExportProvider; this._innerExportProvider = null; sourceProvider = this._sourceProvider; this._sourceProvider = null; importEngine = this._importEngine; this._importEngine = null; partsToDispose = this._partsToDispose; this._gcRoots = null; disposeLock = true; this._isDisposed = true; } } } finally { if (catalogToUnsubscribeFrom != null) { catalogToUnsubscribeFrom.Changing -= this.OnCatalogChanging; } if (aggregateExportProvider != null) { aggregateExportProvider.Dispose(); } if (sourceProvider != null) { sourceProvider.ExportsChanging -= this.OnExportsChangingInternal; } if (importEngine != null) { importEngine.Dispose(); } if (partsToDispose != null) { foreach (var part in partsToDispose) { part.Dispose(); } } if (disposeLock) { this._lock.Dispose(); } } } } }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (disposing) { if (!_isDisposed) { //Note: We do not dispose _lock on dispose because DisposePart needs it to check isDisposed state // to eliminate race conditions between it and Dispose INotifyComposablePartCatalogChanged catalogToUnsubscribeFrom = null; HashSet <IDisposable> partsToDispose = null; ImportEngine importEngine = null; ExportProvider sourceProvider = null; AggregateExportProvider aggregateExportProvider = null; try { using (_lock.LockStateForWrite()) { if (!_isDisposed) { catalogToUnsubscribeFrom = _catalog as INotifyComposablePartCatalogChanged; _catalog = null; aggregateExportProvider = _innerExportProvider as AggregateExportProvider; _innerExportProvider = null; sourceProvider = _sourceProvider; _sourceProvider = null; importEngine = _importEngine; _importEngine = null; partsToDispose = _partsToDispose; _gcRoots = null; _isDisposed = true; } } } finally { if (catalogToUnsubscribeFrom != null) { catalogToUnsubscribeFrom.Changing -= OnCatalogChanging; } if (aggregateExportProvider != null) { aggregateExportProvider.Dispose(); } if (sourceProvider != null) { sourceProvider.ExportsChanging -= OnExportsChangingInternal; } if (importEngine != null) { importEngine.Dispose(); } if (partsToDispose != null) { foreach (var part in partsToDispose) { part.Dispose(); } } } } } }