Pass the MSBuild default assemblies

Author: GrahamTheCoder

CodeConverter/Shared/ThreadSafeWorkspaceHelper.cs

@@ -1,10 +1,13 @@
 using System;
+using System.Collections.Immutable;
+using System.Reflection;
 using System.Threading.Tasks;
 using ICSharpCode.CodeConverter.Util.FromRoslynSdk;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.VisualStudio.Composition;
+using Microsoft.VisualStudio.Threading;
 
 namespace ICSharpCode.CodeConverter.Shared
 {
@@ -15,43 +18,38 @@ namespace ICSharpCode.CodeConverter.Shared
     public static class ThreadSafeWorkspaceHelper
     {
         /// <summary>
-        /// Use this in all workspace creation
+        /// Empty solution in an adhoc workspace
         /// </summary>
-        public static HostServices HostServices {
-            get {
-                var exportProvider = ExportProviderFactory.Value.CreateExportProvider();
-                return MefHostServices.Create(exportProvider.AsCompositionContext());
-            }
-        }
+        public static Solution EmptyAdhocSolution => _emptyAdhocSolution.GetAwaiter().GetResult();
 
         /// <summary>
-        /// Empty solution in an adhoc workspace
+        /// Use this in all workspace creation
         /// </summary>
-        public static Solution EmptyAdhocSolution => LazyAdhocSolution.Value;
-
-        private static readonly Lazy<IExportProviderFactory> ExportProviderFactory = new Lazy<IExportProviderFactory>(CreateExportProviderFactory);
-
-        private static IExportProviderFactory CreateExportProviderFactory()
+        public static async Task<HostServices> CreateHostServicesAsync(ImmutableArray<Assembly> assemblies)
         {
-#pragma warning disable VSTHRD002 // Avoid problematic synchronous waits - Consider making a joinable task factory available so we can use AsyncLazy
-            return Task.Run(async () => await CreateExportProviderFactoryAsync()).GetAwaiter().GetResult();
-#pragma warning restore VSTHRD002 // Avoid problematic synchronous waits
+            var exportProvider = await CreateExportProviderFactoryAsync(assemblies);
+            return MefHostServices.Create(exportProvider.CreateExportProvider().AsCompositionContext());
         }
 
-        private static async Task<IExportProviderFactory> CreateExportProviderFactoryAsync()
+        private static async Task<IExportProviderFactory> CreateExportProviderFactoryAsync(ImmutableArray<Assembly> assemblies)
         {
             var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true);
-            var parts = await discovery.CreatePartsAsync(MefHostServices.DefaultAssemblies);
+            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 Lazy<Solution> LazyAdhocSolution = new Lazy<Solution>(() => {
-            return new AdhocWorkspace(HostServices).CurrentSolution;
-        });
+        /// <summary>
+        /// Empty solution in an adhoc workspace
+        /// </summary>
+        private static Task<Solution> _emptyAdhocSolution =
+            Task.Run(async () => {
+                var hostServices = await CreateHostServicesAsync(MefHostServices.DefaultAssemblies);
+                return new AdhocWorkspace(hostServices).CurrentSolution;
+            });
 
     }
 }

CommandLine/CodeConv.Shared/MSBuildWorkspaceConverter.cs

@@ -18,6 +18,7 @@
 using Microsoft.VisualStudio.Threading;
 using CodeConv.Shared.Util;
 using System.ComponentModel.DataAnnotations;
+using Microsoft.CodeAnalysis.Host.Mef;
 
 namespace ICSharpCode.CodeConverter.CommandLine
 {
@@ -26,7 +27,7 @@ public sealed class MSBuildWorkspaceConverter : IDisposable
         private readonly bool _bestEffortConversion;
         private readonly string _solutionFilePath;
         private readonly Dictionary<string, string> _buildProps;
-        private readonly Lazy<MSBuildWorkspace> _workspace; //Cached to avoid NullRef from OptionsService when initialized concurrently (e.g. in our tests)
+        private readonly AsyncLazy<MSBuildWorkspace> _workspace; //Cached to avoid NullRef from OptionsService when initialized concurrently (e.g. in our tests)
         private AsyncLazy<Solution>? _cachedSolution; //Cached for performance of tests
         private readonly bool _isNetCore;
 
@@ -38,7 +39,7 @@ public MSBuildWorkspaceConverter(string solutionFilePath, bool isNetCore, bool b
             _buildProps.TryAdd("Platform", "AnyCPU");
             _solutionFilePath = solutionFilePath;
             _isNetCore = isNetCore;
-            _workspace = new Lazy<MSBuildWorkspace>(() => CreateWorkspace(_buildProps));
+            _workspace = new AsyncLazy<MSBuildWorkspace>(() => CreateWorkspaceAsync(_buildProps));
         }
 
         public async IAsyncEnumerable<ConversionResult> ConvertProjectsWhereAsync(Func<Project, bool> shouldConvertProject, Language? targetLanguage, IProgress<ConversionProgress> progress, [EnumeratorCancellation] CancellationToken token)
@@ -70,7 +71,7 @@ private async Task<Solution> GetSolutionAsync(string projectOrSolutionFile, IPro
             progress.Report($"Running dotnet restore on {projectOrSolutionFile}");
             await RestorePackagesForSolutionAsync(projectOrSolutionFile);
 
-            var workspace = _workspace.Value;
+            var workspace = await _workspace.GetValueAsync();
             var solution = string.Equals(Path.GetExtension(projectOrSolutionFile), ".sln", StringComparison.OrdinalIgnoreCase) ? await workspace.OpenSolutionAsync(projectOrSolutionFile)
                 : (await workspace.OpenProjectAsync(projectOrSolutionFile)).Solution;
 
@@ -95,7 +96,7 @@ private async Task<Solution> GetSolutionAsync(string projectOrSolutionFile, IPro
         private async Task<string> GetCompilationErrorsAsync(
             IEnumerable<Project> projectsToConvert)
         {
-            var workspaceErrors = _workspace.Value.Diagnostics.GetErrorString();
+            var workspaceErrors = (await _workspace.GetValueAsync()).Diagnostics.GetErrorString();
             var errors = await projectsToConvert.ParallelSelectAwait(async x => {
                 var c = await x.GetCompilationAsync() ?? throw new InvalidOperationException($"Compilation could not be created for {x.Language}");
                 return new[] { CompilationWarnings.WarningsForCompilation(c, c.AssemblyName) };
@@ -110,7 +111,7 @@ private static async Task RestorePackagesForSolutionAsync(string solutionFile)
             if (restoreExitCode != 0) throw new ValidationException("dotnet restore had a non-zero exit code.");
         }
 
-        private static MSBuildWorkspace CreateWorkspace(Dictionary<string, string> buildProps)
+        private static async Task<MSBuildWorkspace> CreateWorkspaceAsync(Dictionary<string, string> buildProps)
         {
             if (MSBuildLocator.CanRegister) {
                 var instances = MSBuildLocator.QueryVisualStudioInstances().ToArray();
@@ -119,12 +120,14 @@ private static MSBuildWorkspace CreateWorkspace(Dictionary<string, string> build
                 MSBuildLocator.RegisterInstance(instance);
                 AppDomain.CurrentDomain.UseVersionAgnosticAssemblyResolution();
             }
-            return MSBuildWorkspace.Create(buildProps, ThreadSafeWorkspaceHelper.HostServices);
+
+            var hostServices = await ThreadSafeWorkspaceHelper.CreateHostServicesAsync(MSBuildMefHostServices.DefaultAssemblies);
+            return MSBuildWorkspace.Create(buildProps, hostServices);
         }
 
         public void Dispose()
         {
-            if (_workspace.IsValueCreated) _workspace.Value.Dispose();
+            if (_workspace.IsValueCreated) _workspace.GetValueAsync().Dispose();
         }
     }
 }