Merge pull request #271 from tonyhallett/mef-threading

tonyhallett · web-flow · commit af377ce1dd25 · 2022-06-16T10:45:29.000+01:00
make the MEF parts free-threaded
diff --git a/FineCodeCoverageTests/FineCodeCoverageTests.csproj b/FineCodeCoverageTests/FineCodeCoverageTests.csproj
@@ -16,6 +16,8 @@
     <Deterministic>true</Deterministic>
     <NuGetPackageImportStamp>
     </NuGetPackageImportStamp>
+    <RunSettingsFilePath>
+    </RunSettingsFilePath>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
diff --git a/SharedProject/Core/Model/CoverageProjectFactory.cs b/SharedProject/Core/Model/CoverageProjectFactory.cs
@@ -1,12 +1,13 @@
 ﻿using System;
 using System.ComponentModel.Composition;
-using System.Threading;
+using System.Threading.Tasks;
 using EnvDTE;
 using EnvDTE80;
 using FineCodeCoverage.Engine.FileSynchronization;
 using FineCodeCoverage.Options;
 using Microsoft.Build.Locator;
 using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Threading;
 
 namespace FineCodeCoverage.Engine.Model
 {
@@ -17,8 +18,8 @@ internal class CoverageProjectFactory : ICoverageProjectFactory
         private readonly IFileSynchronizationUtil fileSynchronizationUtil;
         private readonly ILogger logger;
         private readonly ICoverageProjectSettingsManager coverageProjectSettingsManager;
-        private readonly DTE2 dte;
         private bool canUseMsBuildWorkspace = true;
+        private readonly AsyncLazy<DTE2> lazyDTE2;
 
         [ImportingConstructor]
 		public CoverageProjectFactory(
@@ -33,8 +34,12 @@ public CoverageProjectFactory(
             this.fileSynchronizationUtil = fileSynchronizationUtil;
             this.logger = logger;
             this.coverageProjectSettingsManager = coverageProjectSettingsManager;
-            ThreadHelper.ThrowIfNotOnUIThread();
-            dte = (DTE2)serviceProvider.GetService(typeof(DTE));
+
+            lazyDTE2 = new AsyncLazy<DTE2>(async () =>
+            {
+                await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                return (DTE2)serviceProvider.GetService(typeof(DTE));
+            },ThreadHelper.JoinableTaskFactory);
         }
 
         public void Initialize()
@@ -48,13 +53,15 @@ public void Initialize()
                 canUseMsBuildWorkspace = false;
             }
         }
-        public ICoverageProject Create()
+        public async Task<ICoverageProject> CreateAsync()
         {
-			return new CoverageProject(
+            var dte2 = await lazyDTE2.GetValueAsync();
+
+            return new CoverageProject(
                 appOptionsProvider,
                 fileSynchronizationUtil, 
                 logger, 
-                dte, 
+                dte2, 
                 coverageProjectSettingsManager,
                 canUseMsBuildWorkspace);
         }
diff --git a/SharedProject/Core/Model/ICoverageProjectFactory.cs b/SharedProject/Core/Model/ICoverageProjectFactory.cs
@@ -1,8 +1,10 @@
-﻿namespace FineCodeCoverage.Engine.Model
+﻿using System.Threading.Tasks;
+
+namespace FineCodeCoverage.Engine.Model
 {
     internal interface ICoverageProjectFactory
     {
-		ICoverageProject Create();
+		Task<ICoverageProject> CreateAsync();
         void Initialize();
     }
 }
diff --git a/SharedProject/Core/SourceFileOpener.cs b/SharedProject/Core/SourceFileOpener.cs
@@ -4,8 +4,8 @@
 using EnvDTE;
 using EnvDTE80;
 using FineCodeCoverage.Engine.Cobertura;
-using Microsoft;
 using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Threading;
 
 namespace FineCodeCoverage.Engine
 {
@@ -15,7 +15,7 @@ internal class SourceFileOpener : ISourceFileOpener
         private readonly ICoberturaUtil coberturaUtil;
         private readonly IMessageBox messageBox;
         private readonly ILogger logger;
-        private readonly DTE2 dte;
+        private readonly AsyncLazy<DTE2> lazyDTE2;
 
         [ImportingConstructor]
         public SourceFileOpener(
@@ -27,9 +27,11 @@ public SourceFileOpener(
             this.coberturaUtil = coberturaUtil;
             this.messageBox = messageBox;
             this.logger = logger;
-            ThreadHelper.ThrowIfNotOnUIThread();
-            dte = (DTE2)serviceProvider.GetService(typeof(DTE));
-            Assumes.Present(dte);
+            lazyDTE2 = new AsyncLazy<DTE2>(async () =>
+            {
+                await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                return (DTE2)serviceProvider.GetService(typeof(DTE));
+            }, ThreadHelper.JoinableTaskFactory);
         }
         public async System.Threading.Tasks.Task OpenFileAsync(string assemblyName, string qualifiedClassName, int file, int line)
         {
@@ -46,6 +48,7 @@ public async System.Threading.Tasks.Task OpenFileAsync(string assemblyName, stri
             }
 
             await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+            var dte = await lazyDTE2.GetValueAsync();
             dte.MainWindow.Activate();
 
             foreach (var sourceFile in sourceFiles)
diff --git a/SharedProject/Core/Utilities/SolutionEvents.cs b/SharedProject/Core/Utilities/SolutionEvents.cs
@@ -19,10 +19,13 @@ public SolutionEvents(
             IServiceProvider serviceProvider
             )
         {
-            ThreadHelper.ThrowIfNotOnUIThread();
-            var vsSolution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution));
-            Assumes.Present(vsSolution);
-            vsSolution.AdviseSolutionEvents(this, out uint _);
+            ThreadHelper.JoinableTaskFactory.Run(async () =>
+            {
+                await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                var vsSolution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution));
+                Assumes.Present(vsSolution);
+                vsSolution.AdviseSolutionEvents(this, out uint _);
+            });
         }
 
         public int OnAfterOpenProject(IVsHierarchy pHierarchy, int fAdded)
diff --git a/SharedProject/Impl/CoverageColour/Provider/CoverageColorProvider.cs b/SharedProject/Impl/CoverageColour/Provider/CoverageColorProvider.cs
@@ -5,6 +5,7 @@
 using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Threading;
 using Task = System.Threading.Tasks.Task;
 
 namespace FineCodeCoverage.Impl
@@ -13,13 +14,13 @@ namespace FineCodeCoverage.Impl
     [Export(typeof(ICoverageColours))]
     internal class CoverageColorProvider : ICoverageColoursProvider, ICoverageColours
     {
-        private readonly IVsFontAndColorStorage fontAndColorStorage;
         private readonly ILogger logger;
         private readonly uint storeFlags = (uint)(__FCSTORAGEFLAGS.FCSF_READONLY | __FCSTORAGEFLAGS.FCSF_LOADDEFAULTS | __FCSTORAGEFLAGS.FCSF_NOAUTOCOLORS | __FCSTORAGEFLAGS.FCSF_PROPAGATECHANGES);
         private readonly System.Windows.Media.Color defaultCoverageTouchedArea = System.Windows.Media.Colors.Green;
         private readonly System.Windows.Media.Color defaultCoverageNotTouchedArea = System.Windows.Media.Colors.Red;
         private readonly System.Windows.Media.Color defaultCoveragePartiallyTouchedArea = System.Windows.Media.Color.FromRgb(255, 165, 0);
         private Guid categoryWithCoverage = Guid.Parse("ff349800-ea43-46c1-8c98-878e78f46501");
+        private AsyncLazy<IVsFontAndColorStorage> lazyIVsFontAndColorStorage;
         private bool coverageColoursFromFontsAndColours;
         private bool canUseFontsAndColours = true;
         public System.Windows.Media.Color CoverageTouchedArea { get; set; }
@@ -37,9 +38,12 @@ public CoverageColorProvider(
             ILogger logger
         )
         {
-            ThreadHelper.ThrowIfNotOnUIThread();
-            fontAndColorStorage = (IVsFontAndColorStorage)serviceProvider.GetService(typeof(IVsFontAndColorStorage));
-            Assumes.Present(fontAndColorStorage);
+            lazyIVsFontAndColorStorage = new AsyncLazy<IVsFontAndColorStorage>(async () =>
+            {
+                await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                return (IVsFontAndColorStorage)serviceProvider.GetService(typeof(IVsFontAndColorStorage));
+            }, ThreadHelper.JoinableTaskFactory);
+
             coverageColoursFromFontsAndColours = appOptionsProvider.Get().CoverageColoursFromFontsAndColours;
             appOptionsProvider.OptionsChanged += AppOptionsProvider_OptionsChanged;
             this.logger = logger;
@@ -81,6 +85,7 @@ public async Task PrepareAsync()
 
         private async Task UpdateColoursFromFontsAndColorsAsync()
         {
+            var fontAndColorStorage = await lazyIVsFontAndColorStorage.GetValueAsync();
             await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
             var success = fontAndColorStorage.OpenCategory(ref categoryWithCoverage, storeFlags);
             var usedFontsAndColors = false;
diff --git a/SharedProject/Impl/TestContainerDiscovery/TestOperation.cs b/SharedProject/Impl/TestContainerDiscovery/TestOperation.cs
@@ -34,7 +34,7 @@ private async Task<List<ICoverageProject>> GetCoverageProjectsAsync(TestConfigur
             List<ICoverageProject> coverageProjects = new List<ICoverageProject>();
             foreach (var container in testContainers)
             {
-                var project = coverageProjectFactory.Create();
+                var project = await coverageProjectFactory.CreateAsync();
                 coverageProjects.Add(project);
                 project.ProjectName = container.ProjectName;
                 project.TestDllFile = container.Source;

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,10 @@`
`1`		`-namespace FineCodeCoverage.Engine.Model`
	`1`	`+using System.Threading.Tasks;`
	`2`	`+`
	`3`	`+namespace FineCodeCoverage.Engine.Model`
`2`	`4`	`{`
`3`	`5`	`internal interface ICoverageProjectFactory`
`4`	`6`	`{`
`5`		`- ICoverageProject Create();`
	`7`	`+ Task<ICoverageProject> CreateAsync();`
`6`	`8`	`void Initialize();`
`7`	`9`	`}`
`8`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,10 +19,13 @@ public SolutionEvents(`
`19`	`19`	`IServiceProvider serviceProvider`
`20`	`20`	`)`
`21`	`21`	`{`
`22`		`- ThreadHelper.ThrowIfNotOnUIThread();`
`23`		`- var vsSolution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution));`
`24`		`- Assumes.Present(vsSolution);`
`25`		`- vsSolution.AdviseSolutionEvents(this, out uint _);`
	`22`	`+ ThreadHelper.JoinableTaskFactory.Run(async () =>`
	`23`	`+ {`
	`24`	`+ await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();`
	`25`	`+ var vsSolution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution));`
	`26`	`+ Assumes.Present(vsSolution);`
	`27`	`+ vsSolution.AdviseSolutionEvents(this, out uint _);`
	`28`	`+ });`
`26`	`29`	`}`
`27`	`30`
`28`	`31`	`public int OnAfterOpenProject(IVsHierarchy pHierarchy, int fAdded)`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ private async Task<List<ICoverageProject>> GetCoverageProjectsAsync(TestConfigur`
`34`	`34`	`List<ICoverageProject> coverageProjects = new List<ICoverageProject>();`
`35`	`35`	`foreach (var container in testContainers)`
`36`	`36`	`{`
`37`		`- var project = coverageProjectFactory.Create();`
	`37`	`+ var project = await coverageProjectFactory.CreateAsync();`
`38`	`38`	`coverageProjects.Add(project);`
`39`	`39`	`project.ProjectName = container.ProjectName;`
`40`	`40`	`project.TestDllFile = container.Source;`