public static ExportProvider CreateExportProvider(ComposableCatalog catalog) { var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory().CreateExportProvider()); }
async Task InitializeInstanceAsync() { var assemblies = ReadAssembliesFromAddins(); var caching = new Caching(assemblies); // Try to use cached MEF data if (cacheEnabled && caching.CanUse()) { RuntimeComposition = await TryCreateRuntimeCompositionFromCache(caching); } // Otherwise fallback to runtime discovery. if (RuntimeComposition == null) { RuntimeComposition = await CreateRuntimeCompositionFromDiscovery(caching); CachedComposition cacheManager = new CachedComposition(); caching.Write(RuntimeComposition, cacheManager).Ignore(); } ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory(); ExportProvider = ExportProviderFactory.CreateExportProvider(); HostServices = MefV1HostServices.Create(ExportProvider.AsExportProvider()); ExportProviderV1 = NetFxAdapters.AsExportProvider(ExportProvider); }
private static IExportProviderFactory CreateRemoteHostExportProviderFactory() { var configuration = CompositionConfiguration.Create(ExportProviderCache.GetOrCreateAssemblyCatalog(RoslynServices.RemoteHostAssemblies).WithCompositionService()); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory()); }
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)); }
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); }
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)); }
private static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog) { var configuration = CompositionConfiguration.Create(catalog); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory()); }
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); }
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); }
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 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)); }
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()); }
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()); }
async Task WriteMefCache(RuntimeComposition runtimeComposition, CachedComposition cacheManager) { using (var timer = Counters.CompositionSave.BeginTiming()) { WriteMefCacheControl(timer); // Serialize the MEF cache. using (var stream = File.Open(MefCacheFile, FileMode.Create)) { await cacheManager.SaveAsync(runtimeComposition, stream); } } }
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); }
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()); }
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()); }
async Task InitializeInstanceAsync() { var timings = new Dictionary <string, long> (); var metadata = new CompositionLoadMetadata(timings); using (var timer = Counters.CompositionLoad.BeginTiming(metadata)) { var fullTimer = System.Diagnostics.Stopwatch.StartNew(); var stepTimer = System.Diagnostics.Stopwatch.StartNew(); var mefAssemblies = ReadAssembliesFromAddins(timer); timings ["ReadFromAddins"] = stepTimer.ElapsedMilliseconds; stepTimer.Restart(); var caching = new Caching(mefAssemblies); // Try to use cached MEF data var canUse = metadata.ValidCache = caching.CanUse(); if (canUse) { LoggingService.LogInfo("Creating MEF composition from cache"); RuntimeComposition = await TryCreateRuntimeCompositionFromCache(caching); } timings ["LoadFromCache"] = stepTimer.ElapsedMilliseconds; stepTimer.Restart(); // Otherwise fallback to runtime discovery. if (RuntimeComposition == null) { LoggingService.LogInfo("Creating MEF composition from runtime"); var(runtimeComposition, catalog) = await CreateRuntimeCompositionFromDiscovery(caching, timer); RuntimeComposition = runtimeComposition; CachedComposition cacheManager = new CachedComposition(); caching.Write(RuntimeComposition, catalog, cacheManager).Ignore(); } timings ["LoadRuntimeComposition"] = stepTimer.ElapsedMilliseconds; stepTimer.Restart(); ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory(); ExportProvider = ExportProviderFactory.CreateExportProvider(); HostServices = MefV1HostServices.Create(ExportProvider.AsExportProvider()); ExportProviderV1 = NetFxAdapters.AsExportProvider(ExportProvider); timings ["CreateServices"] = stepTimer.ElapsedMilliseconds; metadata.Duration = fullTimer.ElapsedMilliseconds; } }
static CodeFixProviderDiscovery() { _exportProviderFactory = new Lazy <IExportProviderFactory>( () => { var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true); var parts = Task.Run(() => discovery.CreatePartsAsync(typeof(SystemConsoleToAnsiConsoleFix).Assembly)).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); }
static AbstractFormatterTest() { 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); }
internal static async Task <(RuntimeComposition, ComposableCatalog)> CreateRuntimeCompositionFromDiscovery(Caching caching, ITimeTracker timer = null) { var parts = await Discovery.CreatePartsAsync(caching.MefAssemblies); timer?.Trace("Composition parts discovered"); ComposableCatalog catalog = ComposableCatalog.Create(StandardResolver) .WithCompositionService() .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); timer?.Trace("Composition created"); return(runtimeComposition, catalog); }
/// <inheritdoc cref="Microsoft.CodeAnalysis.Testing.AnalyzerTest{IVerifier}"/>> static DiagnosticAnalyzerRunner() { ExportProviderFactory = new Lazy <IExportProviderFactory>( () => { var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, true); var parts = Task.Run(() => discovery.CreatePartsAsync(MefHostServices.DefaultAssemblies)) .GetAwaiter().GetResult(); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts) .WithDocumentTextDifferencingService(); var configuration = CompositionConfiguration.Create(catalog); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeComposition.CreateExportProviderFactory()); }, LazyThreadSafetyMode.ExecutionAndPublication ); }
internal Task Write(RuntimeComposition runtimeComposition, CachedComposition cacheManager) { return(Runtime.RunInMainThread(async() => { IdeApp.Exiting += IdeApp_Exiting; saveTask = Task.Run(async() => { try { await WriteMefCache(runtimeComposition, cacheManager); } catch (Exception ex) { LoggingService.LogError("Failed to write MEF cache", ex); } }); await saveTask; IdeApp.Exiting -= IdeApp_Exiting; saveTask = null; })); }
internal Task Write(RuntimeComposition runtimeComposition, ComposableCatalog catalog, CachedComposition cacheManager) { return(Runtime.RunInMainThread(async() => { IdeApp.Exiting += IdeApp_Exiting; saveTask = Task.Run(async() => { try { await WriteMefCache(runtimeComposition, catalog, cacheManager); } catch (Exception ex) { exceptionHandler.HandleException("Failed to write MEF cache", ex); } }); await saveTask; IdeApp.Exiting -= IdeApp_Exiting; saveTask = null; })); }
internal static async Task <ExportProvider> CreateContainerAsync(this CompositionConfiguration configuration, ITestOutputHelper output) { Requires.NotNull(configuration, nameof(configuration)); Requires.NotNull(output, nameof(output)); var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration); // Round-trip serialization to make sure the result is equivalent. var cacheManager = new CachedComposition(); var ms = new MemoryStream(); await cacheManager.SaveAsync(runtimeComposition, ms); output.WriteLine("Cache file size: {0}", ms.Length); ms.Position = 0; var deserializedRuntimeComposition = await cacheManager.LoadRuntimeCompositionAsync(ms, Resolver); Assert.Equal(runtimeComposition, deserializedRuntimeComposition); return(runtimeComposition.CreateExportProviderFactory().CreateExportProvider()); }
async Task InitializeInstanceAsync(ITimeTracker <CompositionLoadMetadata> timer, HashSet <Assembly> mefAssemblies) { var metadata = timer.Metadata; var fullTimer = System.Diagnostics.Stopwatch.StartNew(); var stepTimer = System.Diagnostics.Stopwatch.StartNew(); var caching = new Caching(mefAssemblies, new IdeRuntimeCompositionExceptionHandler()); // Try to use cached MEF data using (timer) { var canUse = metadata.ValidCache = caching.CanUse(); if (canUse) { LoggingService.LogInfo("Creating MEF composition from cache"); RuntimeComposition = await TryCreateRuntimeCompositionFromCache(caching); } metadata.Timings ["LoadFromCache"] = stepTimer.ElapsedMilliseconds; stepTimer.Restart(); // Otherwise fallback to runtime discovery. if (RuntimeComposition == null) { LoggingService.LogInfo("Creating MEF composition from runtime"); var(runtimeComposition, catalog) = await CreateRuntimeCompositionFromDiscovery(caching, timer); RuntimeComposition = runtimeComposition; CachedComposition cacheManager = new CachedComposition(); caching.Write(RuntimeComposition, catalog, cacheManager).Ignore(); } metadata.Timings ["LoadRuntimeComposition"] = stepTimer.ElapsedMilliseconds; stepTimer.Restart(); ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory(); ExportProvider = ExportProviderFactory.CreateExportProvider(); HostServices = Microsoft.VisualStudio.LanguageServices.VisualStudioMefHostServices.Create(ExportProvider); metadata.Timings ["CreateServices"] = stepTimer.ElapsedMilliseconds; metadata.Duration = fullTimer.ElapsedMilliseconds; } }
internal Task Write(RuntimeComposition runtimeComposition, ComposableCatalog catalog, CachedComposition cacheManager) { return(Runtime.RunInMainThread(async() => { IdeApp.Exiting += IdeApp_Exiting; saveTask = Task.Run(async() => { try { cachingFaultInjector?.FaultWritingComposition(); await WriteMefCache(runtimeComposition, catalog, cacheManager); } catch (Exception ex) { DeleteFiles(); Runtime.RunInMainThread(() => { exceptionHandler.HandleException("Failed to write MEF cache", ex); }).Ignore(); } }); await saveTask; IdeApp.Exiting -= IdeApp_Exiting; saveTask = Task.CompletedTask; })); }
private static IExportProviderFactory CreateEditorExportProviderFactory() { AssemblyLoader.EnsureLoaded( "Microsoft.VisualStudio.VsInteractiveWindow", "Microsoft.VisualStudio.Editor.Implementation", "Microsoft.VisualStudio.Platform.VSEditor", "Microsoft.PythonTools.VSInterpreters"); var catalog = MefCatalogFactory.CreateAssembliesCatalog( "Microsoft.VisualStudio.CoreUtility", "Microsoft.VisualStudio.Text.Data", "Microsoft.VisualStudio.Text.Logic", "Microsoft.VisualStudio.Text.UI", "Microsoft.VisualStudio.Text.UI.Wpf", "Microsoft.VisualStudio.InteractiveWindow", "Microsoft.VisualStudio.VsInteractiveWindow", "Microsoft.VisualStudio.Editor", "Microsoft.VisualStudio.Language.Intellisense", "Microsoft.VisualStudio.Platform.VSEditor", "Microsoft.PythonTools", "Microsoft.PythonTools.VSInterpreters") .WithCompositionService() .WithServiceProvider() .AddJoinableTaskContext() .AddType <MockTextUndoHistoryRegistry>() .AddTypesFromAssembly("Microsoft.VisualStudio.Editor.Implementation", "Microsoft.VisualStudio.Editor.Implementation.LoggingServiceInternal", "Microsoft.VisualStudio.Editor.Implementation.PeekResultFactory", "Microsoft.VisualStudio.Editor.Implementation.TipManager", "Microsoft.VisualStudio.Editor.Implementation.VisualStudioWaitIndicator", "Microsoft.VisualStudio.Editor.Implementation.VsEditorAdaptersFactoryService"); var configuration = CompositionConfiguration.Create(catalog); var runtimeConfiguration = RuntimeComposition.CreateRuntimeComposition(configuration); return(runtimeConfiguration.CreateExportProviderFactory()); }
public override bool Execute() { if (Environment.GetEnvironmentVariable("CreateCompositionTaskDebug") == "1") { Debugger.Launch(); } this.catalogAssemblyPaths.AddRange(this.CatalogAssemblies.Select(this.GetMEFAssemblyFullPath)); AppDomain.CurrentDomain.AssemblyResolve += this.CurrentDomain_AssemblyResolve; try { var loadableAssemblies = this.catalogAssemblyPaths .Concat(this.ReferenceAssemblies.Select(i => i.GetMetadata("FullPath")) ?? Enumerable.Empty <string>()); var resolver = new Resolver(new AssemblyLoader(loadableAssemblies)); var discovery = PartDiscovery.Combine( new AttributedPartDiscoveryV1(resolver), new AttributedPartDiscovery(resolver, isNonPublicSupported: true)); this.CancellationToken.ThrowIfCancellationRequested(); var parts = discovery.CreatePartsAsync(this.catalogAssemblyPaths).GetAwaiter().GetResult(); var catalog = ComposableCatalog.Create(resolver) .AddParts(parts); this.LogLines(this.GetLogFilePath("CatalogAssemblies"), this.GetCatalogAssembliesLines(catalog), this.CancellationToken); string catalogErrorFilePath = this.GetLogFilePath("CatalogErrors"); if (catalog.DiscoveredParts.DiscoveryErrors.IsEmpty) { File.Delete(catalogErrorFilePath); } else { this.LogLines(catalogErrorFilePath, GetCatalogErrorLines(catalog), this.CancellationToken); foreach (var error in catalog.DiscoveredParts.DiscoveryErrors) { string message = error.GetUserMessage(); if (this.ContinueOnDiscoveryErrors) { this.LogWarning(DiscoveryErrorCode, message); } else { this.Log.LogError(null, DiscoveryErrorCode, null, null, 0, 0, 0, 0, message); } } if (!this.ContinueOnDiscoveryErrors) { return(false); } } this.CancellationToken.ThrowIfCancellationRequested(); var configuration = CompositionConfiguration.Create(catalog); if (!string.IsNullOrEmpty(this.DgmlOutputPath)) { configuration.CreateDgml().Save(this.DgmlOutputPath); this.writtenFiles.Add(this.DgmlOutputPath); } this.CancellationToken.ThrowIfCancellationRequested(); string compositionLogPath = this.GetLogFilePath("CompositionErrors"); if (configuration.CompositionErrors.IsEmpty) { File.Delete(compositionLogPath); } else { this.LogLines(compositionLogPath, GetCompositionErrorLines(configuration), this.CancellationToken); foreach (var error in configuration.CompositionErrors.Peek()) { if (this.ContinueOnCompositionErrors) { this.LogWarning(CompositionErrorCode, error.Message); } else { this.Log.LogError(null, CompositionErrorCode, null, null, 0, 0, 0, 0, error.Message); } } if (!this.ContinueOnCompositionErrors) { 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(); } this.writtenFiles.Add(cachePath); return(!this.Log.HasLoggedErrors); } finally { AppDomain.CurrentDomain.AssemblyResolve -= this.CurrentDomain_AssemblyResolve; this.FileWrites = this.writtenFiles.Select(f => new TaskItem(f)).ToArray(); } }