public async Task ComposableAssembliesLazyLoadedWhenQueried() { SkipOnMono(); var catalog = TestUtilities.EmptyCatalog.AddParts( await TestUtilities.V2Discovery.CreatePartsAsync(typeof(ExternalExport), typeof(YetAnotherExport))); var catalogCache = await this.SaveCatalogAsync(catalog); var configuration = CompositionConfiguration.Create(catalog); var compositionCache = await this.SaveConfigurationAsync(configuration); // Use a sub-appdomain so we can monitor which assemblies get loaded by our composition engine. var appDomain = AppDomain.CreateDomain("Composition Test sub-domain", null, AppDomain.CurrentDomain.SetupInformation); try { var driver = (AppDomainTestDriver)appDomain.CreateInstanceAndUnwrap(typeof(AppDomainTestDriver).Assembly.FullName, typeof(AppDomainTestDriver).FullName); driver.Initialize(this.cacheManager.GetType(), compositionCache, catalogCache); driver.TestExternalExport(typeof(ExternalExport).Assembly.Location); driver.TestYetAnotherExport(typeof(YetAnotherExport).Assembly.Location); } finally { AppDomain.Unload(appDomain); } }
private static IExportProviderFactory CreateRemoteHostExportProviderFactory() { var configuration = CompositionConfiguration.Create(ExportProviderCache.GetOrCreateAssemblyCatalog(RoslynServices.RemoteHostAssemblies).WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory()); }
static GenericAnalyzerTest() { string codeAnalysisTestVersion = typeof(Compilation).Assembly.GetName().Version.Major switch { 1 => "1.2.1", 2 => "2.8.2", 3 => "3.3.1", _ => throw new InvalidOperationException("Unknown version."), }; ReferenceAssemblies = ReferenceAssemblies.Default.AddPackages(ImmutableArray.Create( new PackageIdentity("Microsoft.CodeAnalysis.CSharp", codeAnalysisTestVersion), new PackageIdentity("System.ValueTuple", "4.5.0"))); ExportProviderFactory = new Lazy <IExportProviderFactory>( () => { var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true); var parts = Task.Run(() => discovery.CreatePartsAsync(MefHostServices.DefaultAssemblies)).GetAwaiter().GetResult(); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts); var configuration = CompositionConfiguration.Create(catalog); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory()); }, LazyThreadSafetyMode.ExecutionAndPublication); }
private static async Task <IContainer> CreateContainerV3Async(ComposableCatalog catalog, CompositionEngines options, ITestOutputHelper output) { Requires.NotNull(catalog, nameof(catalog)); Requires.NotNull(output, nameof(output)); var catalogWithCompositionService = catalog #if DESKTOP .WithCompositionService() #endif ; var configuration = CompositionConfiguration.Create(catalogWithCompositionService); if (!options.HasFlag(CompositionEngines.V3AllowConfigurationWithErrors)) { configuration.ThrowOnErrors(); } #if DGML string dgmlFile = System.IO.Path.GetTempFileName() + ".dgml"; configuration.CreateDgml().Save(dgmlFile); output.WriteLine("DGML saved to: " + dgmlFile); #endif var container = await configuration.CreateContainerAsync(output); return(new V3ContainerWrapper(container, configuration)); }
static async Task <ExportProvider> CreateExportProviderAsync(CancellationToken cancellationToken = default(CancellationToken)) { var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance); var parts = await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly(), cancellationToken); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance) .AddParts(parts); var composition = CompositionConfiguration.Create(catalog); composition.CreateDgml().Save("mefgraph.dgml"); if (!composition.CompositionErrors.IsEmpty) { foreach (var error in composition.CompositionErrors.Peek()) { Console.Error.WriteLine(error.Message); foreach (var part in error.Parts) { Console.Error.WriteLine(" " + part.Definition.Type.FullName); } } } composition.ThrowOnErrors(); var exportProviderFactory = composition.CreateExportProviderFactory(); return(exportProviderFactory.CreateExportProvider()); }
async Task InitializeInstanceAsync() { ComposableCatalog catalog = ComposableCatalog.Create(StandardResolver) .WithCompositionService() .WithDesktopSupport(); var assemblies = new HashSet <Assembly> (); ReadAssembliesFromAddins(assemblies, "/MonoDevelop/Ide/TypeService/PlatformMefHostServices"); ReadAssembliesFromAddins(assemblies, "/MonoDevelop/Ide/TypeService/MefHostServices"); ReadAssembliesFromAddins(assemblies, "/MonoDevelop/Ide/Composition"); // spawn discovery tasks in parallel for each assembly var tasks = new List <Task <DiscoveredParts> > (assemblies.Count); foreach (var assembly in assemblies) { var task = Task.Run(() => Discovery.CreatePartsAsync(assembly)); tasks.Add(task); } foreach (var task in tasks) { catalog = catalog.AddParts(await task); } var discoveryErrors = catalog.DiscoveredParts.DiscoveryErrors; if (!discoveryErrors.IsEmpty) { foreach (var error in discoveryErrors) { LoggingService.LogInfo("MEF discovery error", error); } // throw new ApplicationException ("MEF discovery errors"); } CompositionConfiguration configuration = CompositionConfiguration.Create(catalog); if (!configuration.CompositionErrors.IsEmpty) { // capture the errors in an array for easier debugging var errors = configuration.CompositionErrors.SelectMany(e => e).ToArray(); foreach (var error in errors) { LoggingService.LogInfo("MEF composition error: " + error.Message); } // For now while we're still transitioning to VSMEF it's useful to work // even if the composition has some errors. TODO: re-enable this. //configuration.ThrowOnErrors (); } RuntimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory(); ExportProvider = ExportProviderFactory.CreateExportProvider(); HostServices = MefV1HostServices.Create(ExportProvider.AsExportProvider()); ExportProviderV1 = NetFxAdapters.AsExportProvider(ExportProvider); }
public async Task CatalogGetInputAssembliesDoesNotLoadLazyExports() { SkipOnMono(); var catalog = TestUtilities.EmptyCatalog.AddParts( await TestUtilities.V2Discovery.CreatePartsAsync(typeof(ExternalExportWithExternalMetadataType), typeof(ExternalExportWithExternalMetadataTypeArray), typeof(ExternalExportWithExternalMetadataEnum32))); var catalogCache = await this.SaveCatalogAsync(catalog); var configuration = CompositionConfiguration.Create(catalog); var compositionCache = await this.SaveConfigurationAsync(configuration); var appDomain = AppDomain.CreateDomain("Composition Test sub-domain", null, AppDomain.CurrentDomain.SetupInformation); try { var driver = (AppDomainTestDriver)appDomain.CreateInstanceAndUnwrap(typeof(AppDomainTestDriver).Assembly.FullName, typeof(AppDomainTestDriver).FullName); driver.Initialize(this.cacheManager.GetType(), compositionCache, catalogCache); // GetInputAssemblies should not load the YetAnotherExport assembly or the CustomEnum assembly (both in AppDomainTests2) driver.TestGetInputAssembliesDoesNotLoadLazyExport(typeof(YetAnotherExport).Assembly.Location); } finally { AppDomain.Unload(appDomain); } }
private static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog) { var configuration = CompositionConfiguration.Create(catalog); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory()); }
public static ExportProvider CreateExportProvider(ComposableCatalog catalog) { var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory().CreateExportProvider()); }
public void ExceptionIsSerializable() { var discovery = TestUtilities.V2Discovery; var catalog = TestUtilities.EmptyCatalog.AddParts(new[] { discovery.CreatePart(typeof(Tree)) }); var configuration = CompositionConfiguration.Create(catalog); CompositionFailedException exception = null; try { configuration.ThrowOnErrors(); Assert.True(false, "Expected exception not thrown."); } catch (CompositionFailedException ex) { exception = ex; } var formatter = new BinaryFormatter(); var ms = new MemoryStream(); formatter.Serialize(ms, exception); ms.Position = 0; var actual = (CompositionFailedException)formatter.Deserialize(ms); Assert.Equal(exception.Message, actual.Message); Assert.NotNull(actual.Errors); Assert.False(actual.Errors.IsEmpty); Assert.Equal(1, actual.Errors.Peek().Count); Assert.Equal(exception.Errors.Peek().Single().Message, actual.Errors.Peek().Single().Message); }
public void MissingRequiredImport() { var catalog = TestUtilities.EmptyCatalog.AddParts(new[] { TestUtilities.V2Discovery.CreatePart(typeof(RequiredImportMissing)) }); var configuration = CompositionConfiguration.Create(catalog); Assert.Throws <CompositionFailedException>(() => configuration.ThrowOnErrors()); }
public void TestEmptyPartsThrowsException() { var configuration = CompositionConfiguration.Create(TestUtilities.EmptyCatalog); var validComposition = RuntimeComposition.CreateRuntimeComposition(configuration); Assert.Throws <ArgumentException>(() => RuntimeComposition.CreateRuntimeComposition(Enumerable.Empty <RuntimeComposition.RuntimePart>(), validComposition.MetadataViewsAndProviders, Resolver.DefaultInstance)); }
public async Task Initialize() { if (_initialized) { return; } var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(Resolver.DefaultInstance)); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance) .AddParts(await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly())) .AddParts(await discovery.CreatePartsAsync(Assembly.GetCallingAssembly())) .AddParts(await discovery.CreatePartsAsync(Assembly.GetEntryAssembly())) .AddParts(await discovery.CreatePartsAsync(_directoryCatalog.Assemblies)) .WithCompositionService(); // Makes an ICompositionService export available to MEF parts to import // Assemble the parts into a valid graph. var config = CompositionConfiguration.Create(catalog); // Prepare an ExportProvider factory based on this graph. Factory = config.CreateExportProviderFactory(); // Create an export provider, which represents a unique container of values. ExportProvider = Factory.CreateExportProvider(); CompositionService = ExportProvider.GetExportedValue <ICompositionService>(); _initialized = true; }
public void TestEmptyMetadataViewProviderThrowsException() { var configuration = CompositionConfiguration.Create(TestUtilities.EmptyCatalog); var validComposition = RuntimeComposition.CreateRuntimeComposition(configuration); Assert.Throws <ArgumentException>(() => RuntimeComposition.CreateRuntimeComposition(validComposition.Parts, ImmutableDictionary <TypeRef, RuntimeComposition.RuntimeExport> .Empty, Resolver.DefaultInstance)); }
internal static async Task <ExportProvider> CreateContainerAsync(ITestOutputHelper output, params Type[] parts) { var catalog = EmptyCatalog.AddParts(await V2Discovery.CreatePartsAsync(parts)); var configuration = await CompositionConfiguration.Create(catalog) .CreateContainerAsync(output); return(configuration); }
private static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog) { var configuration = CompositionConfiguration.Create(catalog.WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); var exportProviderFactory = runtimeComposition.CreateExportProviderFactory(); return(new SingleExportProviderFactory(catalog, exportProviderFactory)); }
public override void PrepareBasic() { var catalog = RegisterBasicAsync().GetAwaiter().GetResult(); this.container = CompositionConfiguration.Create(catalog) .CreateExportProviderFactory() .CreateExportProvider(); }
private static IFaultReportingExportProviderFactory CreateExportProviderFactory(IEnumerable <ComposablePartDefinition> parts) { var catalog = TestUtilities.EmptyCatalog.AddParts(parts); var configuration = CompositionConfiguration.Create(catalog); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory() as IFaultReportingExportProviderFactory); }
/// <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); }
internal static async Task <CompositionConfiguration> CreateConfigurationAsync(CompositionEngines attributesDiscovery, params Type[] parts) { PartDiscovery discovery = GetDiscoveryService(attributesDiscovery); var assemblyParts = await discovery.CreatePartsAsync(parts); var catalog = EmptyCatalog.AddParts(assemblyParts); return(CompositionConfiguration.Create(catalog)); }
public static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog, bool isRemoteHostComposition) { var scope = isRemoteHostComposition ? _remoteCompositionScope : _localCompositionScope; var configuration = CompositionConfiguration.Create(catalog.WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); var exportProviderFactory = runtimeComposition.CreateExportProviderFactory(); return(new SingleExportProviderFactory(scope, catalog, configuration, 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 }); } }
private ExportProvider CreateCompositionContainer() { var catalog = CachedInfo.Catalog.AddInstance(() => this); var configuration = CompositionConfiguration.Create(catalog); var runtimeConfiguration = RuntimeComposition.CreateRuntimeComposition(configuration); var exportProviderFactory = runtimeConfiguration.CreateExportProviderFactory(); return(exportProviderFactory.CreateExportProvider()); }
public void TestEmptyCatalogTest() { var configuration = CompositionConfiguration.Create(TestUtilities.EmptyCatalog); var composition = RuntimeComposition.CreateRuntimeComposition(configuration); var factory = composition.CreateExportProviderFactory(); var provider = factory.CreateExportProvider(); var exports = provider.GetExports <IDisposable>(); Assert.Empty(exports); }
public static ExportProvider CreateExportProvider(ComposableCatalog catalog) { // make sure we enable this for all unit tests AsynchronousOperationListenerProvider.Enable(true); var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory().CreateExportProvider()); }
public async Task ValidMultiplePaths() { var catalog = TestUtilities.EmptyCatalog.AddParts(await TestUtilities.V2Discovery.CreatePartsAsync( typeof(ValidMultiplePathRoot), typeof(ValidMultiplePathTrail1), typeof(ValidMultiplePathTrail2), typeof(ValidMultiplePathCommonImport))); CompositionConfiguration.Create(catalog); }
private static async Task <IExportProviderFactory> CreateExportProviderFactoryAsync(ImmutableArray <Assembly> assemblies) { var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true); var parts = await discovery.CreatePartsAsync(assemblies); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts); var configuration = CompositionConfiguration.Create(catalog); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory()); }
public override bool Execute() { var resolver = Resolver.DefaultInstance; var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(resolver), new AttributedPartDiscovery(resolver, isNonPublicSupported: true)); this.CancellationToken.ThrowIfCancellationRequested(); var parts = discovery.CreatePartsAsync(this.CatalogAssemblies.Select(item => item.ItemSpec)).GetAwaiter().GetResult(); foreach (var error in parts.DiscoveryErrors) { this.Log.LogWarningFromException(error); } this.CancellationToken.ThrowIfCancellationRequested(); var catalog = ComposableCatalog.Create(resolver) .AddParts(parts.Parts); this.CancellationToken.ThrowIfCancellationRequested(); var configuration = CompositionConfiguration.Create(catalog); if (!string.IsNullOrEmpty(this.DgmlOutputPath)) { configuration.CreateDgml().Save(this.DgmlOutputPath); } this.CancellationToken.ThrowIfCancellationRequested(); if (!configuration.CompositionErrors.IsEmpty) { foreach (var error in configuration.CompositionErrors.Peek()) { this.Log.LogError(error.Message); } return(false); } this.CancellationToken.ThrowIfCancellationRequested(); string cachePath = Path.GetFullPath(this.CompositionCacheFile); this.Log.LogMessage("Producing IoC container \"{0}\"", cachePath); using (var cacheStream = File.Open(cachePath, FileMode.Create)) { this.CancellationToken.ThrowIfCancellationRequested(); var runtime = RuntimeComposition.CreateRuntimeComposition(configuration); this.CancellationToken.ThrowIfCancellationRequested(); var runtimeCache = new CachedComposition(); runtimeCache.SaveAsync(runtime, cacheStream, this.CancellationToken).GetAwaiter().GetResult(); } return(!this.Log.HasLoggedErrors); }
public override void Prepare() { var simpleCatalogTask = RegisterBasicAsync(); var expandedParts = Task.WhenAll( RegisterPropertyInjectionAsync(), RegisterMultipleAsync()).GetAwaiter().GetResult(); var catalog = expandedParts.Aggregate(simpleCatalogTask.GetAwaiter().GetResult(), (cat, discoveredParts) => cat.AddParts(discoveredParts)); this.container = CompositionConfiguration.Create(catalog) .CreateExportProviderFactory() .CreateExportProvider(); }
private static ExportProvider CreateExportProvider(string applicationDataFolder) { var stopwatch = Stopwatch.StartNew(); var file = new FileInfo(Application.ExecutablePath); FileInfo[] plugins = Directory.Exists(Path.Combine(file.Directory.FullName, "Plugins")) ? new DirectoryInfo(Path.Combine(file.Directory.FullName, "Plugins")).GetFiles("*.dll") : new FileInfo[] { }; var pluginFiles = plugins; var cacheFile = Path.Combine(applicationDataFolder ?? "ignored", "Plugins", "composition.cache"); IExportProviderFactory exportProviderFactory; if (applicationDataFolder != null && File.Exists(cacheFile)) { using (var cacheStream = File.OpenRead(cacheFile)) { exportProviderFactory = ThreadHelper.JoinableTaskFactory.Run(() => new CachedComposition().LoadExportProviderFactoryAsync(cacheStream, Resolver.DefaultInstance)); } } else { var assemblies = pluginFiles.Select(assemblyFile => TryLoadAssembly(assemblyFile)).Where(assembly => assembly != null).ToArray(); var discovery = PartDiscovery.Combine( new AttributedPartDiscoveryV1(Resolver.DefaultInstance), new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true)); var parts = ThreadHelper.JoinableTaskFactory.Run(() => discovery.CreatePartsAsync(assemblies)); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts); var configuration = CompositionConfiguration.Create(catalog.WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); if (applicationDataFolder != null) { #if false // Composition caching currently disabled Directory.CreateDirectory(Path.Combine(applicationDataFolder, "Plugins")); using (var cacheStream = File.OpenWrite(cacheFile)) { ThreadHelper.JoinableTaskFactory.Run(() => new CachedComposition().SaveAsync(runtimeComposition, cacheStream)); } #endif } exportProviderFactory = runtimeComposition.CreateExportProviderFactory(); } return(exportProviderFactory.CreateExportProvider()); }