static VisualStudioTestExportProvider() { Factory = ExportProviderCache.GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic .WithParts(ExportProviderCache.GetOrCreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly)) .WithPart(typeof(LanguageServices.UnitTests.VisualStudioTestExportProvider.MockWorkspaceEventListenerProvider))); }
public SingleExportProviderFactory(Scope scope, ComposableCatalog catalog, CompositionConfiguration configuration, IExportProviderFactory exportProviderFactory) { _scope = scope; _catalog = catalog; _configuration = configuration; _exportProviderFactory = exportProviderFactory; }
/// <summary> /// Creates a factory for <see cref="ExportProvider"/> containers with a /// backing catalog that contains all the parts being tested. /// </summary> /// <returns>A task whose result is the <see cref="IExportProviderFactory"/>.</returns> private async Task <IExportProviderFactory> CreateExportProviderFactoryAsync() { ComposableCatalog catalog = await this.CreateProductCatalogAsync().ConfigureAwait(false); var configuration = CompositionConfiguration.Create(catalog); IExportProviderFactory exportProviderFactory = configuration.CreateExportProviderFactory(); return(exportProviderFactory); }
private static async Task InitializeMef() { // Cannot show MessageBox here, because WPF would crash with a XamlParseException // Remember and show exceptions in text output, once MainWindow is properly initialized try { // Set up VS MEF. For now, only do MEF1 part discovery, since that was in use before. // To support both MEF1 and MEF2 parts, just change this to: // var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(Resolver.DefaultInstance), // new AttributedPartDiscovery(Resolver.DefaultInstance)); var discovery = new AttributedPartDiscoveryV1(Resolver.DefaultInstance); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance); var pluginDir = Path.GetDirectoryName(typeof(App).Module.FullyQualifiedName); if (pluginDir != null) { foreach (var plugin in Directory.GetFiles(pluginDir, "*.Plugin.dll")) { var name = Path.GetFileNameWithoutExtension(plugin); try { var asm = Assembly.Load(name); var parts = await discovery.CreatePartsAsync(asm); catalog = catalog.AddParts(parts); } catch (Exception ex) { StartupExceptions.Add(new ExceptionData { Exception = ex, PluginName = name }); } } } // Add the built-in parts var createdParts = await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly()); catalog = catalog.AddParts(createdParts); // If/When the project switches to .NET Standard/Core, this will be needed to allow metadata interfaces (as opposed // to metadata classes). When running on .NET Framework, it's automatic. // catalog.WithDesktopSupport(); // If/When any part needs to import ICompositionService, this will be needed: // catalog.WithCompositionService(); var config = CompositionConfiguration.Create(catalog); ExportProviderFactory = config.CreateExportProviderFactory(); ExportProvider = ExportProviderFactory.CreateExportProvider(); // This throws exceptions for composition failures. Alternatively, the configuration's CompositionErrors property // could be used to log the errors directly. Used at the end so that it does not prevent the export provider setup. config.ThrowOnErrors(); } catch (Exception ex) { StartupExceptions.Add(new ExceptionData { Exception = ex }); } }
public ExportJob(IDataExporter dataExporter, IPushNotificationManager pushNotificationManager, IExportProviderFactory exportProviderFactory, IModuleInitializerOptions moduleInitializerOptions, ISettingsManager settingsManager) { _dataExporter = dataExporter; _pushNotificationManager = pushNotificationManager; _exportProviderFactory = exportProviderFactory; _settingsManager = settingsManager; _defaultExportFolder = moduleInitializerOptions.VirtualRoot + "/App_Data/Export/"; }
public ExportJob(IDataExporter dataExporter, IPushNotificationManager pushNotificationManager, IOptions <PlatformOptions> platformOptions, IExportProviderFactory exportProviderFactory, ISettingsManager settingsManager, IBlobStorageProvider blobStorageProvider, IBlobUrlResolver blobUrlResolver) { _dataExporter = dataExporter; _pushNotificationManager = pushNotificationManager; _platformOptions = platformOptions.Value; _exportProviderFactory = exportProviderFactory; _settingsManager = settingsManager; _blobStorageProvider = blobStorageProvider; _blobUrlResolver = blobUrlResolver; }
private async Task <ExportProvider> Compose(object parentInstance) { ExportProvider exportProvider = null; PartDiscovery discovery = PartDiscovery.Combine( new AttributedPartDiscovery(Resolver.DefaultInstance), new AttributedPartDiscoveryV1(Resolver.DefaultInstance)); // ".NET MEF" attributes (System.ComponentModel.Composition) Assembly parentAssembly = parentInstance.GetType().Assembly; string parentLocation = parentAssembly.Location; string assemblyPath = parentLocation; assemblyPath = assemblyPath.Substring(0, assemblyPath.LastIndexOf('\\')); Helpers desktopBridgeHelper = new Helpers(); List <string> assemblies = new[] { parentLocation } .Concat( Directory.EnumerateFiles(assemblyPath, "*.dll", SearchOption.TopDirectoryOnly) .Where(_ => _.Contains("NUnit3GUI"))) .ToList(); DiscoveredParts discoveredParts = await discovery.CreatePartsAsync(assemblies); discoveredParts.ThrowOnErrors(); ComposableCatalog catalog = ComposableCatalog.Create(Resolver.DefaultInstance) .AddParts(discoveredParts) .WithCompositionService(); CompositionConfiguration config = CompositionConfiguration.Create(catalog); config.ThrowOnErrors(); IExportProviderFactory epf = config.CreateExportProviderFactory(); exportProvider = epf.CreateExportProvider(); ICompositionService service = exportProvider.GetExportedValue <ICompositionService>(); service.SatisfyImportsOnce(parentInstance); return(exportProvider); }
public App() { var cmdArgs = Environment.GetCommandLineArgs().Skip(1); App.CommandLineArguments = new CommandLineArguments(cmdArgs); if ((App.CommandLineArguments.SingleInstance ?? true) && !MiscSettingsPanel.CurrentMiscSettings.AllowMultipleInstances) { cmdArgs = cmdArgs.Select(FullyQualifyPath); string message = string.Join(Environment.NewLine, cmdArgs); if (SendToPreviousInstance("ILSpy:\r\n" + message, !App.CommandLineArguments.NoActivate)) { Environment.Exit(0); } } InitializeComponent(); if (!System.Diagnostics.Debugger.IsAttached) { AppDomain.CurrentDomain.UnhandledException += ShowErrorBox; Dispatcher.CurrentDispatcher.UnhandledException += Dispatcher_UnhandledException; } TaskScheduler.UnobservedTaskException += DotNet40_UnobservedTaskException; // Cannot show MessageBox here, because WPF would crash with a XamlParseException // Remember and show exceptions in text output, once MainWindow is properly initialized try { // Set up VS MEF. For now, only do MEF1 part discovery, since that was in use before. // To support both MEF1 and MEF2 parts, just change this to: // var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(Resolver.DefaultInstance), // new AttributedPartDiscovery(Resolver.DefaultInstance)); var discovery = new AttributedPartDiscoveryV1(Resolver.DefaultInstance); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance); var pluginDir = Path.GetDirectoryName(typeof(App).Module.FullyQualifiedName); if (pluginDir != null) { foreach (var plugin in Directory.GetFiles(pluginDir, "*.Plugin.dll")) { var name = Path.GetFileNameWithoutExtension(plugin); try { var asm = Assembly.Load(name); var parts = discovery.CreatePartsAsync(asm).Result; catalog = catalog.AddParts(parts); } catch (Exception ex) { StartupExceptions.Add(new ExceptionData { Exception = ex, PluginName = name }); } } } // Add the built-in parts catalog = catalog.AddParts(discovery.CreatePartsAsync(Assembly.GetExecutingAssembly()).Result); // If/When the project switches to .NET Standard/Core, this will be needed to allow metadata interfaces (as opposed // to metadata classes). When running on .NET Framework, it's automatic. // catalog.WithDesktopSupport(); // If/When any part needs to import ICompositionService, this will be needed: // catalog.WithCompositionService(); var config = CompositionConfiguration.Create(catalog); exportProviderFactory = config.CreateExportProviderFactory(); exportProvider = exportProviderFactory.CreateExportProvider(); // This throws exceptions for composition failures. Alternatively, the configuration's CompositionErrors property // could be used to log the errors directly. Used at the end so that it does not prevent the export provider setup. config.ThrowOnErrors(); } catch (Exception ex) { StartupExceptions.Add(new ExceptionData { Exception = ex }); } Languages.Initialize(exportProvider); EventManager.RegisterClassHandler(typeof(Window), Hyperlink.RequestNavigateEvent, new RequestNavigateEventHandler(Window_RequestNavigate)); ILSpyTraceListener.Install(); }
public DataExporter(IKnownExportTypesResolver exportTypesResolver, IExportProviderFactory exportProviderFactory) { _exportTypesResolver = exportTypesResolver; _exportProviderFactory = exportProviderFactory; }
protected TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters, IExportProviderFactory exportProviderFactory) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions, exportProvider: exportProviderFactory.CreateExportProvider());
public SingleExportProviderFactory(ComposableCatalog catalog, IExportProviderFactory exportProviderFactory) { _catalog = catalog; _exportProviderFactory = exportProviderFactory; }
/// <summary> /// Creates a new MEF container, initialized with all the assemblies /// specified in the constructor. /// </summary> /// <returns>A task whose result is the <see cref="ExportProvider"/>.</returns> public async Task <ExportProvider> CreateExportProviderAsync() { IExportProviderFactory exportProviderFactory = await this.exportProviderFactory.GetValueAsync().ConfigureAwait(false); return(exportProviderFactory.CreateExportProvider()); }
/// <summary> /// Creates an export provider which represents a unique container of values. /// You can create as many of these as you want, /// typicall each test has its own Host, and an application has a single Host. /// </summary> internal Host(IExportProviderFactory epf) { _exportProvider = epf.CreateExportProvider(); }
// --- private constructor and public static initialization methods: --- /// <summary> /// Creates a reusable environment with a specified composition graph. /// </summary> private EditorEnvironment(IExportProviderFactory epf, ImmutableArray <string> compositionErrors) { _epf = epf; CompositionErrors = compositionErrors; }
static VisualStudioTestExportProvider() { Factory = ExportProviderCache.GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts( ExportProviderCache.GetOrCreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly))); }