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)); }
private static Task <DiscoveredParts> RegisterMultipleAsync() { return(partDiscovery.CreatePartsAsync( typeof(SimpleAdapterOne), typeof(SimpleAdapterTwo), typeof(SimpleAdapterThree), typeof(SimpleAdapterFour), typeof(SimpleAdapterFive), typeof(ImportMultiple1), typeof(ImportMultiple2), typeof(ImportMultiple3))); }
internal static async Task <IContainer> CreateContainerV3Async(IReadOnlyList <Assembly> assemblies, CompositionEngines attributesDiscovery, ITestOutputHelper output, Type[] parts = null) { PartDiscovery discovery = GetDiscoveryService(attributesDiscovery); var assemblyParts = await discovery.CreatePartsAsync(assemblies); var catalog = EmptyCatalog.AddParts(assemblyParts); if (parts != null && parts.Length != 0) { var typeCatalog = EmptyCatalog.AddParts(await discovery.CreatePartsAsync(parts)); catalog = EmptyCatalog.AddParts(catalog.Parts.Concat(typeCatalog.Parts)); } return(await CreateContainerV3Async(catalog, attributesDiscovery, output)); }
public async Task GetAssemblyInputs_SucceedesWithGenericType(PartDiscovery discovery) { var catalog = TestUtilities.EmptyCatalog.AddParts( await discovery.CreatePartsAsync(typeof(ExportingWithGenerics <string>))); catalog.GetInputAssemblies(); }
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 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); }
public async Task GetAssemblyInputs_WithImports(PartDiscovery discovery) { var catalog = TestUtilities.EmptyCatalog.AddParts( await discovery.CreatePartsAsync( typeof(ExportingType), typeof(ImportingType))); catalog.GetInputAssemblies(); }
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 async Task GetAssemblyInputs_ContainsDefiningAttributeAssemblyForMetadata(PartDiscovery discovery) { var catalog = TestUtilities.EmptyCatalog.AddParts( await discovery.CreatePartsAsync(typeof(ExportingTypeWithMetadataWhoseDefiningAttributeIsInAnotherAssembly))); var inputAssemblies = catalog.GetInputAssemblies(); Assert.Contains(typeof(SomeMetadataAttributeFromAnotherAssemblyAttribute).GetTypeInfo().Assembly.GetName(), inputAssemblies, AssemblyNameComparer.Default); }
public async Task DiscoveriesCombinedWithResolver() { LoggingAssemblyLoader assemblyLoader = new(); Resolver assemblyResolver = new(assemblyLoader); PartDiscovery combined = PartDiscovery.Combine(assemblyResolver, TestUtilities.V2Discovery, TestUtilities.V1Discovery); Assert.Same(assemblyResolver, combined.Resolver); string testAssemblyPath = typeof(PartDiscoveryTests).Assembly.Location; await combined.CreatePartsAsync(new string[] { testAssemblyPath }); Assert.Equal(new[] { testAssemblyPath }, assemblyLoader.AttemptedAssemblyPaths); }
public async Task GetAssemblyInputs_IdentifiesAssembliesDefiningParts(PartDiscovery discovery) { var catalog = TestUtilities.EmptyCatalog.AddParts( await discovery.CreatePartsAsync(typeof(NonExportingType), typeof(ExportingType))); var expected = new HashSet <AssemblyName>(AssemblyNameComparer.Default) { typeof(NonExportingType).GetTypeInfo().Assembly.GetName(), typeof(object).GetTypeInfo().Assembly.GetName(), }; var actual = catalog.GetInputAssemblies(); this.AssertExpectedInputAssemblies(expected, actual); }
public async Task GetAssemblyInputs_FunctionsCorrectlyWithNullMetadata(PartDiscovery discovery) { var catalog = TestUtilities.EmptyCatalog.AddParts( await discovery.CreatePartsAsync(typeof(ExportingTypeWithNullExportMetadata))); var expected = new HashSet <AssemblyName>(AssemblyNameComparer.Default) { typeof(AssemblyDiscoveryTests.ISomeInterface).GetTypeInfo().Assembly.GetName(), typeof(ExportingTypeWithNullExportMetadata).GetTypeInfo().Assembly.GetName(), typeof(object).GetTypeInfo().Assembly.GetName() }; var actual = catalog.GetInputAssemblies(); this.AssertExpectedInputAssemblies(expected, actual); }
public async Task GetAssemblyInputs_IdentifiesAssembliesDefiningExportingMembersWithTypeMetadata(PartDiscovery discovery) { var catalog = TestUtilities.EmptyCatalog.AddParts( await discovery.CreatePartsAsync(typeof(ExportingWithExportingMembers))); var expected = new HashSet <AssemblyName>(AssemblyNameComparer.Default) { typeof(AssemblyDiscoveryTests.ISomeInterface).GetTypeInfo().Assembly.GetName(), typeof(ExportingWithExportingMembers).GetTypeInfo().Assembly.GetName(), typeof(object).GetTypeInfo().Assembly.GetName() }; var actual = catalog.GetInputAssemblies(); this.AssertExpectedInputAssemblies(expected, actual); }
public static async Task <ComposableCatalog> CreateCatalog(HashSet <Assembly> assemblies = null) { Resolver StandardResolver = Resolver.DefaultInstance; PartDiscovery Discovery = PartDiscovery.Combine( new AttributedPartDiscoveryV1(StandardResolver), new AttributedPartDiscovery(StandardResolver, true)); var parts = await Discovery.CreatePartsAsync(assemblies ?? ReadAssembliesFromAddins()); ComposableCatalog catalog = ComposableCatalog.Create(StandardResolver) .WithCompositionService() .WithDesktopSupport() .AddParts(parts); return(catalog); }
public async Task GetAssemblyInputs_IdentifiesAssembliesDefiningMultipleDifferentEnumMetadata(PartDiscovery discovery) { var catalog = TestUtilities.EmptyCatalog.AddParts( await discovery.CreatePartsAsync(typeof(ExportingWithMultipleDifferentEnumMetadata))); var expected = new HashSet <AssemblyName>(AssemblyNameComparer.Default) { typeof(AssemblyDiscoveryTests.SomeEnum).GetTypeInfo().Assembly.GetName(), typeof(AssemblyDiscoveryTests2.SomeOtherEnum).GetTypeInfo().Assembly.GetName(), typeof(ExportingWithMultipleDifferentEnumMetadata).GetTypeInfo().Assembly.GetName(), typeof(object).GetTypeInfo().Assembly.GetName() }; var actual = catalog.GetInputAssemblies(); this.AssertExpectedInputAssemblies(expected, actual); }
public async Task GetAssemblyInputs_RecursesThroughInterfaceTreeInMetadata(PartDiscovery discovery) { var catalog = TestUtilities.EmptyCatalog.AddParts( await discovery.CreatePartsAsync(typeof(ExportingTypeWithExportMetadataWithExternalDependenciesAndInterfaceTree))); var expected = new HashSet <AssemblyName>(AssemblyNameComparer.Default) { typeof(AssemblyDiscoveryTests.ISomeInterfaceWithBaseInterface).GetTypeInfo().Assembly.GetName(), typeof(AssemblyDiscoveryTests2.IBlankInterface).GetTypeInfo().Assembly.GetName(), typeof(ExportingTypeWithExportMetadataWithExternalDependenciesAndInterfaceTree).GetTypeInfo().Assembly.GetName(), typeof(object).GetTypeInfo().Assembly.GetName() }; var actual = catalog.GetInputAssemblies(); this.AssertExpectedInputAssemblies(expected, actual); }
internal static async Task <RuntimeComposition> CreateRuntimeCompositionFromDiscovery(Caching caching) { using (var timer = Counters.CompositionDiscovery.BeginTiming()) { var parts = await Discovery.CreatePartsAsync(caching.Assemblies); timer.Trace("Composition parts discovered"); ComposableCatalog catalog = ComposableCatalog.Create(StandardResolver) .WithCompositionService() .WithDesktopSupport() .AddParts(parts); 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 (); } timer.Trace("Composition configured"); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition); } }
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); }