public AbstractCommandHandlerTestState( XElement workspaceElement, ComposableCatalog extraParts = null, bool useMinimumCatalog = false, string workspaceKind = null) : this(workspaceElement, GetExportProvider(useMinimumCatalog, extraParts), workspaceKind) { }
public async Task CreateFromTypesOmitsNonParts(PartDiscovery discovery) { var catalog = ComposableCatalog.Create(discovery.Resolver).AddParts( await discovery.CreatePartsAsync(typeof(NonExportingType), typeof(ExportingType))); Assert.Equal(1, catalog.Parts.Count); Assert.Equal(typeof(ExportingType), catalog.Parts.Single().Type); }
private static ComposableCatalog CreateCatalog(ImmutableArray <Assembly> assemblies) { var resolver = new Resolver(SimpleAssemblyLoader.Instance); var discovery = new AttributedPartDiscovery(resolver, isNonPublicSupported: true); var parts = Task.Run(async() => await discovery.CreatePartsAsync(assemblies).ConfigureAwait(false)).GetAwaiter().GetResult(); return(ComposableCatalog.Create(resolver).AddParts(parts)); }
public static ComposableCatalog CreateTypeCatalog(IEnumerable <Type> types) { // If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back // on the thread. var parts = Task.Run(async() => await s_partDiscovery.CreatePartsAsync(types).ConfigureAwait(false)).Result; return(ComposableCatalog.Create(parts)); }
static VisualStudioTestExportProvider() { PartCatalog = TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts( MinimalTestExportProvider.CreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly)); ExportProvider = MinimalTestExportProvider.CreateExportProvider(PartCatalog); }
public AbstractCommandHandlerTestState( XElement workspaceElement, IList <Type> excludedTypes = null, ComposableCatalog extraParts = null, string workspaceKind = null) : this(workspaceElement, GetExportProvider(excludedTypes, extraParts), workspaceKind) { }
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 static ComposableCatalog CreateAssemblyCatalog(IEnumerable <Assembly> assemblies) { // If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back // on the thread. var parts = Task.Run(async() => await s_partDiscovery.CreatePartsAsync(assemblies).ConfigureAwait(false)).Result; return(ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts)); }
static VisualStudioTestExportProvider() { PartCatalog = TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts( MinimalTestExportProvider.CreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly)); ExportProvider = MinimalTestExportProvider.CreateExportProvider(PartCatalog); }
private static async Task <ComposableCatalog> RegisterBasicAsync() { var parts = await Task.WhenAll( RegisterDummiesAsync(), RegisterStandardAsync(), RegisterComplexObjectAsync()); return(parts.Aggregate(ComposableCatalog.Create(Resolver.DefaultInstance), (catalog, discoveredParts) => catalog.AddParts(discoveredParts))); }
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)); }
/// <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 }); } }
/// <summary> /// Scrambles the MVID and metadata tokens in the catalog to simulate a cache that was /// created then invalidated due to an assembly that was recompiled, such that its MVID and metadata tokens changed. /// This should effectively force "slow reflection" to be used automatically, and verify metadata tokens are ignored. /// </summary> /// <param name="catalog">The catalog to scramble.</param> /// <returns>The scrambled catalog.</returns> internal static ComposableCatalog SimulateRecompiledAssembly(ComposableCatalog catalog) { Requires.NotNull(catalog, nameof(catalog)); var scrambler = new CatalogScrambler(TestUtilities.Resolver); var scrambledCatalog = ComposableCatalog.Create(scrambler.resolver) .AddParts(new DiscoveredParts(catalog.Parts.Select(scrambler.Scramble), catalog.DiscoveredParts.DiscoveryErrors)); return(scrambledCatalog); }
public static ComposableCatalog CreateTypeCatalog(IEnumerable <Type> types, Resolver resolver = null) { var discovery = resolver == null ? s_partDiscovery : CreatePartDiscovery(resolver); // If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back // on the thread. var parts = Task.Run(async() => await discovery.CreatePartsAsync(types).ConfigureAwait(false)).Result; return(ComposableCatalog.Create(resolver ?? Resolver.DefaultInstance).AddParts(parts)); }
private async Task <Stream> SaveCatalogAsync(ComposableCatalog catalog) { Requires.NotNull(catalog, nameof(catalog)); var ms = new MemoryStream(); await new CachedCatalog().SaveAsync(catalog, ms); ms.Position = 0; return(ms); }
internal static void SetEnabled_OnlyUseExportProviderAttributeCanCall(bool value) { _enabled = value; if (!_enabled) { _currentExportProvider = null; _expectedCatalog = null; _expectedProviderForCatalog = null; } }
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()); }
/// <summary> /// Creates a catalog with all the assemblies from the application .exe's directory. /// </summary> /// <returns>A task whose result is the <see cref="ComposableCatalog"/>.</returns> private async Task <ComposableCatalog> CreateProductCatalogAsync() { var assemblyNames = GetAssemblyNames(); var assemblies = assemblyNames.Select(Assembly.LoadFrom); var discoveredParts = await this.discoverer.CreatePartsAsync(assemblies); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance) .AddParts(discoveredParts); return(catalog); }
async Task WriteMefCache(RuntimeComposition runtimeComposition, ComposableCatalog catalog, CachedComposition cacheManager) { using (var timer = Counters.CompositionSave.BeginTiming()) { WriteMefCacheControl(catalog, timer); // Serialize the MEF cache. using (var stream = File.Open(MefCacheFile, FileMode.Create)) { await cacheManager.SaveAsync(runtimeComposition, stream); } } }
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) { throw new ApplicationException($"MEF catalog scanning errors encountered.\n{string.Join ("\n", discoveryErrors)}"); } CompositionConfiguration configuration = CompositionConfiguration.Create(catalog); if (!configuration.CompositionErrors.IsEmpty) { // capture the errors in an array for easier debugging var errors = configuration.CompositionErrors.ToArray(); // 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. //var messages = errors.SelectMany (e => e).Select (e => e.Message); //var text = string.Join (Environment.NewLine, messages); //Xwt.Clipboard.SetText (text); //configuration.ThrowOnErrors (); } RuntimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory(); ExportProvider = ExportProviderFactory.CreateExportProvider(); HostServices = MefV1HostServices.Create(ExportProvider.AsExportProvider()); ExportProviderV1 = NetFxAdapters.AsExportProvider(ExportProvider); }
public static ComposableCatalog AddTypesFromAssembly(this ComposableCatalog composableCatalog, string assemblyName, params string[] typeNames) { var assembly = GetLoadedAssembly(assemblyName, AppDomain.CurrentDomain.GetAssemblies()); foreach (var typeName in typeNames) { var type = assembly.GetType(typeName) ?? throw new AssertFailedException($@"Type {typeName} can't be found in assembly {assemblyName}."); composableCatalog = composableCatalog.AddType(type); } return(composableCatalog); }
/// <summary> /// Creates a <see cref="ComposableCatalog"/> derived from <paramref name="catalog"/>, but with all exported /// parts assignable to any type in <paramref name="types"/> removed from the catalog. /// </summary> public static ComposableCatalog WithoutPartsOfTypes(this ComposableCatalog catalog, IEnumerable <Type> types) { var parts = catalog.Parts.Where(composablePartDefinition => !IsExcludedPart(composablePartDefinition)); return(ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts)); bool IsExcludedPart(ComposablePartDefinition part) { return(types.Any(excludedType => excludedType.IsAssignableFrom(part.Type))); } }
/// <summary> /// Creates a catalog containing the MEF parts we want to test. /// </summary> /// <returns>A task whose result is the <see cref="ComposableCatalog"/>.</returns> private async Task <ComposableCatalog> CreateProductCatalogAsync() { IEnumerable <Assembly> assemblies = this.catalogAssemblyNames.Select(Assembly.Load); DiscoveredParts discoveredParts = await this.discoverer.CreatePartsAsync(assemblies).ConfigureAwait(false); ComposableCatalog catalog = ComposableCatalog.Create(Resolver.DefaultInstance) .AddParts(discoveredParts) .WithCompositionService(); return(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 async Task AddCatalog_MergesErrors() { var discovery = TestUtilities.V2Discovery; var emptyCatalog = ComposableCatalog.Create(discovery.Resolver); var result1 = emptyCatalog.AddParts(await discovery.CreatePartsAsync(new[] { "Foo\\DoesNotExist.dll" })); var result2 = emptyCatalog.AddParts(await discovery.CreatePartsAsync(new[] { "Foo\\DoesNotExist2.dll" })); var mergedCatalog = result1.AddCatalog(result2); Assert.Equal(result1.DiscoveredParts.DiscoveryErrors.Count + result2.DiscoveredParts.DiscoveryErrors.Count, mergedCatalog.DiscoveredParts.DiscoveryErrors.Count); Assert.NotEqual(0, mergedCatalog.DiscoveredParts.DiscoveryErrors.Count); // the test is ineffective otherwise. }
public static ComposableCatalog CreateTypeCatalog(IEnumerable <Type> types, Resolver?resolver = null) { var discovery = resolver == null ? _partDiscovery : CreatePartDiscovery(resolver); // If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back // on the thread. #pragma warning disable VSTHRD002 // Avoid problematic synchronous waits var parts = Task.Run(async() => await discovery.CreatePartsAsync(types).ConfigureAwait(false)).Result; #pragma warning restore VSTHRD002 // Avoid problematic synchronous waits return(ComposableCatalog.Create(resolver ?? Resolver.DefaultInstance).AddParts(parts)); }
public SingleExportProviderFactory( Scope scope, ComposableCatalog catalog, CompositionConfiguration configuration, IExportProviderFactory exportProviderFactory ) { _scope = scope; _catalog = catalog; _configuration = configuration; _exportProviderFactory = exportProviderFactory; }
public static IExportProviderFactory GetOrCreateExportProviderFactory(ComposableCatalog catalog) { if (catalog == s_defaultHostCatalog) { return(s_defaultHostExportProviderFactory); } else if (catalog == s_remoteHostCatalog) { return(s_remoteHostExportProviderFactory); } return(CreateExportProviderFactory(catalog)); }
private static ExportProvider GetExportProvider(bool useMinimumCatalog, ComposableCatalog extraParts) { var baseCatalog = useMinimumCatalog ? TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic : TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic; if (extraParts == null) { return(MinimalTestExportProvider.CreateExportProvider(baseCatalog)); } return(MinimalTestExportProvider.CreateExportProvider(baseCatalog.WithParts(extraParts))); }
public static ComposableCatalog WithParts(this ComposableCatalog @this, ComposableCatalog catalog) { return @this.AddParts(catalog.DiscoveredParts); }
public static ExportProvider CreateExportProvider(ComposableCatalog catalog) { var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return runtimeComposition.CreateExportProviderFactory().CreateExportProvider(); }