Move InvokeScript SwitchToMainThreadAsync to OutputToolWindowControl

tonyhallett · tonyhallett · commit f28d69685687 · 2022-03-02T14:20:55.000Z
diff --git a/SharedProject/Core/FCCEngine.cs b/SharedProject/Core/FCCEngine.cs
@@ -146,27 +146,27 @@ private async System.Threading.Tasks.Task<string[]> RunCoverageAsync(List<ICover
                 var coverageProjectHasFailed = coverageProject.HasFailed;
                 if (coverageProjectHasFailed) // todo remove step
                 {
-                    await reportGeneratorUtil.LogCoverageProcessAsync($"{coverageProject.ProjectName} failed : {coverageProject.FailureDescription}");
+                    reportGeneratorUtil.LogCoverageProcess($"{coverageProject.ProjectName} failed : {coverageProject.FailureDescription}");
                 }
                 await coverageProject.StepAsync("Run Coverage Tool", async (project) =>
                 {
                     var start = DateTime.Now;
                     try
                     {
                         var coverageTool = coverageUtilManager.CoverageToolName(project);
-                        await reportGeneratorUtil.LogCoverageProcessAsync($"Starting {coverageTool} coverage for {project.ProjectName}");
+                        reportGeneratorUtil.LogCoverageProcess($"Starting {coverageTool} coverage for {project.ProjectName}");
                         await coverageUtilManager.RunCoverageAsync(project, true);
                     }catch(Exception exc)
                     {
-                        await reportGeneratorUtil.LogCoverageProcessAsync($"{coverageProject.ProjectName} failed : {exc}");
+                        reportGeneratorUtil.LogCoverageProcess($"{coverageProject.ProjectName} failed : {exc}");
                         throw exc;
                     }
                     if (!cancellationToken.IsCancellationRequested)
                     {
                         var duration = DateTime.Now - start;
                         var durationMessage = $"Completed coverage for {coverageProject.ProjectName} : {duration}";
                         logger.Log(durationMessage);
-                        await reportGeneratorUtil.LogCoverageProcessAsync(durationMessage);
+                        reportGeneratorUtil.LogCoverageProcess(durationMessage);
                     }
                 });
             }
@@ -243,32 +243,32 @@ private async System.Threading.Tasks.Task PrepareCoverageProjectsAsync(List<ICov
                     }
                     logger.Log($"File synchronization duration : {fileSynchronizationDetails.Duration}");
                     var itemOrItems = logs.Count == 1 ? "item" : "items";
-                    await reportGeneratorUtil.LogCoverageProcessAsync($"File synchronization {logs.Count} {itemOrItems}, duration : {fileSynchronizationDetails.Duration}");
+                    reportGeneratorUtil.LogCoverageProcess($"File synchronization {logs.Count} {itemOrItems}, duration : {fileSynchronizationDetails.Duration}");
                 }
             }
         }
 
-        private async System.Threading.Tasks.Task DisplayCoverageResultAsync(System.Threading.Tasks.Task<(List<CoverageLine> coverageLines, string reportHtml)> t)
+        private void DisplayCoverageResult(System.Threading.Tasks.Task<(List<CoverageLine> coverageLines, string reportHtml)> t)
         {
             switch (t.Status)
             {
                 case System.Threading.Tasks.TaskStatus.Canceled:
                     LogReloadCoverageStatus(ReloadCoverageStatus.Cancelled);
-                    await reportGeneratorUtil.LogCoverageProcessAsync("Coverage cancelled");
+                    reportGeneratorUtil.LogCoverageProcess("Coverage cancelled");
                     break;
                 case System.Threading.Tasks.TaskStatus.Faulted:
                     LogReloadCoverageStatus(ReloadCoverageStatus.Error);
                     logger.Log(t.Exception.InnerExceptions[0]);
-                    await reportGeneratorUtil.LogCoverageProcessAsync(t.Exception.ToString());
+                    reportGeneratorUtil.LogCoverageProcess(t.Exception.ToString());
                     break;
                 case System.Threading.Tasks.TaskStatus.RanToCompletion:
                     LogReloadCoverageStatus(ReloadCoverageStatus.Done);
-#pragma warning disable VSTHRD103 // Call async methods when in an async method
+#pragma warning disable VSTHRD002 // Avoid problematic synchronous waits
                     UpdateUI(t.Result.coverageLines, t.Result.reportHtml);
-#pragma warning restore VSTHRD103 // Call async methods when in an async method
+#pragma warning restore VSTHRD002 // Avoid problematic synchronous waits
                     break;
             }
-            await reportGeneratorUtil.EndOfCoverageRunAsync();
+            reportGeneratorUtil.EndOfCoverageRun();
 
         }
 
@@ -284,7 +284,7 @@ private async System.Threading.Tasks.Task PollInitializedStatusAsync(Cancellatio
                         return;
                     
                     case InitializeStatus.Initializing:
-                        await reportGeneratorUtil.LogCoverageProcessAsync("Initializing");
+                        reportGeneratorUtil.LogCoverageProcess("Initializing");
                         LogReloadCoverageStatus(ReloadCoverageStatus.Initializing);
                         await System.Threading.Tasks.Task.Delay(InitializeWait);
                         break;
@@ -305,7 +305,7 @@ public void ReloadCoverage(Func<System.Threading.Tasks.Task<List<ICoverageProjec
 
                 await PollInitializedStatusAsync(cancellationToken);
 
-                await reportGeneratorUtil.LogCoverageProcessAsync("Starting coverage - full details in FCC Output Pane");
+                reportGeneratorUtil.LogCoverageProcess("Starting coverage - full details in FCC Output Pane");
                 LogReloadCoverageStatus(ReloadCoverageStatus.Start);
 
                 var coverageProjects = await coverageRequestCallback();
@@ -325,7 +325,7 @@ public void ReloadCoverage(Func<System.Threading.Tasks.Task<List<ICoverageProjec
                 return (coverageLines, reportHtml);
 
             }, cancellationToken)
-            .ContinueWith(DisplayCoverageResultAsync, System.Threading.Tasks.TaskScheduler.Default); 
+            .ContinueWith(DisplayCoverageResult, System.Threading.Tasks.TaskScheduler.Default); 
 
         }
     }
diff --git a/SharedProject/Core/ReportGenerator/ReportGeneratorUtil.cs b/SharedProject/Core/ReportGenerator/ReportGeneratorUtil.cs
@@ -26,8 +26,8 @@ interface IReportGeneratorUtil
 		string ProcessUnifiedHtml(string htmlForProcessing,string reportOutputFolder);
 		Task<ReportGeneratorResult> GenerateAsync(IEnumerable<string> coverOutputFiles,string reportOutputFolder, bool throwError = false);
         string BlankReport(bool withHistory);
-        Task LogCoverageProcessAsync(string message);
-		Task EndOfCoverageRunAsync();
+        void LogCoverageProcess(string message);
+		void EndOfCoverageRun();
     }
 
     internal class ReportGeneratorResult
@@ -216,23 +216,23 @@ async Task<bool> run(string outputReportType, string inputReports)
 			var reportGeneratorResult = new ReportGeneratorResult { Success = false, UnifiedHtml = null, UnifiedXmlFile = unifiedXmlFile };
 
 			var startTime = DateTime.Now;
-			await LogCoverageProcessAsync("Generating cobertura report");
+			LogCoverageProcess("Generating cobertura report");
 			var coberturaResult = await run("Cobertura", string.Join(";", coverOutputFiles));
 			var duration = DateTime.Now - startTime;
 
 			if (coberturaResult)
 			{
 				var coberturaDurationMesage = $"Cobertura report generation duration - {duration}";
-				await LogCoverageProcessAsync(coberturaDurationMesage); // result output includes duration for normal log
+				LogCoverageProcess(coberturaDurationMesage); // result output includes duration for normal log
 
 				startTime = DateTime.Now;
-				await LogCoverageProcessAsync("Generating html report");
+				LogCoverageProcess("Generating html report");
 				var htmlResult = await run("HtmlInline_AzurePipelines", unifiedXmlFile);
 				duration = DateTime.Now - startTime;
 				if (htmlResult)
 				{
 					var htmlReportDurationMessage = $"Html report generation duration - {duration}";
-					await LogCoverageProcessAsync(htmlReportDurationMessage); // result output includes duration for normal log
+					LogCoverageProcess(htmlReportDurationMessage); // result output includes duration for normal log
 					reportGeneratorResult.UnifiedHtml = fileUtil.ReadAllText(unifiedHtmlFile);
 					reportGeneratorResult.Success = true;
 				}
@@ -1687,16 +1687,14 @@ public string BlankReport(bool withHistory)
 			return ProcessUnifiedHtml(resourceProvider.ReadResource("dummyReportToProcess.html"),null);
         }
 
-        public async Task LogCoverageProcessAsync(string message)
+        public void LogCoverageProcess(string message)
         {
-			await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
 			eventAggregator.SendMessage(new InvokeScriptMessage(CoverageLogJSFunctionName, message));
 			logs.Add(message);
 		}
 
-        public async Task EndOfCoverageRunAsync()
+        public void EndOfCoverageRun()
         {
-			await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
 			eventAggregator.SendMessage(new InvokeScriptMessage(ShowFCCWorkingJSFunctionName, false));
 		}
 		
diff --git a/SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs b/SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs
@@ -70,15 +70,15 @@ IReportGeneratorUtil reportGeneratorUtil
             _ = ThreadHelper.JoinableTaskFactory.RunAsync(taskProvider);
         };
 
-        private async System.Threading.Tasks.Task TestExecutionStartingAsync(IOperation operation)
+        private void TestExecutionStarting(IOperation operation)
         {
             fccEngine.StopCoverage();
 
             var settings = appOptionsProvider.Get();
             if (!settings.Enabled)
             {
-                await CombinedLogAsync("Coverage not collected as FCC disabled.");
-                await reportGeneratorUtil.EndOfCoverageRunAsync();
+                CombinedLog("Coverage not collected as FCC disabled.");
+                reportGeneratorUtil.EndOfCoverageRun();
                 return;
             }
             if (settings.RunInParallel)
@@ -92,17 +92,17 @@ private async System.Threading.Tasks.Task TestExecutionStartingAsync(IOperation
             }
             else
             {
-                await CombinedLogAsync("Coverage collected when tests finish. RunInParallel option true for immediate");
+                CombinedLog("Coverage collected when tests finish. RunInParallel option true for immediate");
             }
         }
 
-        private async System.Threading.Tasks.Task CombinedLogAsync(string message)
+        private void CombinedLog(string message)
         {
-            await reportGeneratorUtil.LogCoverageProcessAsync(message);
+            reportGeneratorUtil.LogCoverageProcess(message);
             logger.Log(message);
         }
 
-        private async System.Threading.Tasks.Task TestExecutionFinishedAsync(IOperation operation)
+        private void TestExecutionFinished(IOperation operation)
         {
             var settings = appOptionsProvider.Get();
             if (!settings.Enabled || settings.RunInParallel)
@@ -112,8 +112,8 @@ private async System.Threading.Tasks.Task TestExecutionFinishedAsync(IOperation
             var testOperation = testOperationFactory.Create(operation);
             if (!settings.RunWhenTestsFail && testOperation.FailedTests > 0)
             {
-                await CombinedLogAsync($"Skipping coverage due to failed tests.  Option {nameof(AppOptions.RunWhenTestsFail)} is false");
-                await reportGeneratorUtil.EndOfCoverageRunAsync();
+                CombinedLog($"Skipping coverage due to failed tests.  Option {nameof(AppOptions.RunWhenTestsFail)} is false");
+                reportGeneratorUtil.EndOfCoverageRun();
                 return;
             }
 
@@ -123,8 +123,8 @@ private async System.Threading.Tasks.Task TestExecutionFinishedAsync(IOperation
             {
                 if (totalTests <= runWhenTestsExceed)
                 {
-                    await CombinedLogAsync($"Skipping coverage as total tests ({totalTests}) <= {nameof(AppOptions.RunWhenTestsExceed)} ({runWhenTestsExceed})");
-                    await reportGeneratorUtil.EndOfCoverageRunAsync();
+                    CombinedLog($"Skipping coverage as total tests ({totalTests}) <= {nameof(AppOptions.RunWhenTestsExceed)} ({runWhenTestsExceed})");
+                    reportGeneratorUtil.EndOfCoverageRun();
                     return;
                 }
             }
@@ -133,43 +133,40 @@ private async System.Threading.Tasks.Task TestExecutionFinishedAsync(IOperation
         private bool cancelling;
         private void OperationState_StateChanged(object sender, OperationStateChangedEventArgs e)
         {
-            RunAsync(async () =>
+            try
             {
-                try
+                if (e.State == TestOperationStates.TestExecutionCanceling)
                 {
-                    if (e.State == TestOperationStates.TestExecutionCanceling)
-                    {
-                        cancelling = true;
-                        await CombinedLogAsync("Test execution cancelling - running coverage will be cancelled.");
-                        await reportGeneratorUtil.EndOfCoverageRunAsync(); // not necessarily true but get desired result
-                        fccEngine.StopCoverage();
-                    }
-
-
-                    if (e.State == TestOperationStates.TestExecutionStarting)
-                    {
-                        await TestExecutionStartingAsync(e.Operation);
-                        cancelling = false;
-                    }
-
-                    if (e.State == TestOperationStates.TestExecutionFinished)
-                    {
-                        await TestExecutionFinishedAsync(e.Operation);
-                    }
-
-                    if (e.State == TestOperationStates.TestExecutionCancelAndFinished && !cancelling)
-                    {
-                        await CombinedLogAsync("There has been an issue running tests. See the Tests output window pane.");
-                        await reportGeneratorUtil.EndOfCoverageRunAsync(); // not necessarily true but get desired result
-                        fccEngine.StopCoverage();
-                    }
-                    
+                    cancelling = true;
+                    CombinedLog("Test execution cancelling - running coverage will be cancelled.");
+                    reportGeneratorUtil.EndOfCoverageRun(); // not necessarily true but get desired result
+                    fccEngine.StopCoverage();
                 }
-                catch (Exception exception)
+
+
+                if (e.State == TestOperationStates.TestExecutionStarting)
                 {
-                    logger.Log("Error processing unit test events", exception);
+                    TestExecutionStarting(e.Operation);
+                    cancelling = false;
                 }
-            });
+
+                if (e.State == TestOperationStates.TestExecutionFinished)
+                {
+                    TestExecutionFinished(e.Operation);
+                }
+
+                if (e.State == TestOperationStates.TestExecutionCancelAndFinished && !cancelling)
+                {
+                    CombinedLog("There has been an issue running tests. See the Tests output window pane.");
+                    reportGeneratorUtil.EndOfCoverageRun(); // not necessarily true but get desired result
+                    fccEngine.StopCoverage();
+                }
+                    
+            }
+            catch (Exception exception)
+            {
+                logger.Log("Error processing unit test events", exception);
+            }
             
         }
     }
diff --git a/SharedProject/Output/OutputToolWindowControl.xaml.cs b/SharedProject/Output/OutputToolWindowControl.xaml.cs
@@ -73,8 +73,13 @@ public void Handle(NewReportMessage message)
 
         public void Handle(InvokeScriptMessage message)
         {
-            InvokeScript(message.ScriptName, message.Arguments);
-        }
+			ThreadHelper.JoinableTaskFactory.Run(async () =>
+			{
+				await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+
+				InvokeScript(message.ScriptName, message.Arguments);
+			});
+		}
 
         public void Handle(ObjectForScriptingMessage message)
         {

Original file line number	Diff line number	Diff line change
`@@ -146,27 +146,27 @@ private async System.Threading.Tasks.Task<string[]> RunCoverageAsync(List<ICover`
`146`	`146`	`var coverageProjectHasFailed = coverageProject.HasFailed;`
`147`	`147`	`if (coverageProjectHasFailed) // todo remove step`
`148`	`148`	`{`
`149`		`- await reportGeneratorUtil.LogCoverageProcessAsync($"{coverageProject.ProjectName} failed : {coverageProject.FailureDescription}");`
	`149`	`+ reportGeneratorUtil.LogCoverageProcess($"{coverageProject.ProjectName} failed : {coverageProject.FailureDescription}");`
`150`	`150`	`}`
`151`	`151`	`await coverageProject.StepAsync("Run Coverage Tool", async (project) =>`
`152`	`152`	`{`
`153`	`153`	`var start = DateTime.Now;`
`154`	`154`	`try`
`155`	`155`	`{`
`156`	`156`	`var coverageTool = coverageUtilManager.CoverageToolName(project);`
`157`		`- await reportGeneratorUtil.LogCoverageProcessAsync($"Starting {coverageTool} coverage for {project.ProjectName}");`
	`157`	`+ reportGeneratorUtil.LogCoverageProcess($"Starting {coverageTool} coverage for {project.ProjectName}");`
`158`	`158`	`await coverageUtilManager.RunCoverageAsync(project, true);`
`159`	`159`	`}catch(Exception exc)`
`160`	`160`	`{`
`161`		`- await reportGeneratorUtil.LogCoverageProcessAsync($"{coverageProject.ProjectName} failed : {exc}");`
	`161`	`+ reportGeneratorUtil.LogCoverageProcess($"{coverageProject.ProjectName} failed : {exc}");`
`162`	`162`	`throw exc;`
`163`	`163`	`}`
`164`	`164`	`if (!cancellationToken.IsCancellationRequested)`
`165`	`165`	`{`
`166`	`166`	`var duration = DateTime.Now - start;`
`167`	`167`	`var durationMessage = $"Completed coverage for {coverageProject.ProjectName} : {duration}";`
`168`	`168`	`logger.Log(durationMessage);`
`169`		`- await reportGeneratorUtil.LogCoverageProcessAsync(durationMessage);`
	`169`	`+ reportGeneratorUtil.LogCoverageProcess(durationMessage);`
`170`	`170`	`}`
`171`	`171`	`});`
`172`	`172`	`}`
`@@ -243,32 +243,32 @@ private async System.Threading.Tasks.Task PrepareCoverageProjectsAsync(List<ICov`
`243`	`243`	`}`
`244`	`244`	`logger.Log($"File synchronization duration : {fileSynchronizationDetails.Duration}");`
`245`	`245`	`var itemOrItems = logs.Count == 1 ? "item" : "items";`
`246`		`- await reportGeneratorUtil.LogCoverageProcessAsync($"File synchronization {logs.Count} {itemOrItems}, duration : {fileSynchronizationDetails.Duration}");`
	`246`	`+ reportGeneratorUtil.LogCoverageProcess($"File synchronization {logs.Count} {itemOrItems}, duration : {fileSynchronizationDetails.Duration}");`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`
`251`		`- private async System.Threading.Tasks.Task DisplayCoverageResultAsync(System.Threading.Tasks.Task<(List<CoverageLine> coverageLines, string reportHtml)> t)`
	`251`	`+ private void DisplayCoverageResult(System.Threading.Tasks.Task<(List<CoverageLine> coverageLines, string reportHtml)> t)`
`252`	`252`	`{`
`253`	`253`	`switch (t.Status)`
`254`	`254`	`{`
`255`	`255`	`case System.Threading.Tasks.TaskStatus.Canceled:`
`256`	`256`	`LogReloadCoverageStatus(ReloadCoverageStatus.Cancelled);`
`257`		`- await reportGeneratorUtil.LogCoverageProcessAsync("Coverage cancelled");`
	`257`	`+ reportGeneratorUtil.LogCoverageProcess("Coverage cancelled");`
`258`	`258`	`break;`
`259`	`259`	`case System.Threading.Tasks.TaskStatus.Faulted:`
`260`	`260`	`LogReloadCoverageStatus(ReloadCoverageStatus.Error);`
`261`	`261`	`logger.Log(t.Exception.InnerExceptions[0]);`
`262`		`- await reportGeneratorUtil.LogCoverageProcessAsync(t.Exception.ToString());`
	`262`	`+ reportGeneratorUtil.LogCoverageProcess(t.Exception.ToString());`
`263`	`263`	`break;`
`264`	`264`	`case System.Threading.Tasks.TaskStatus.RanToCompletion:`
`265`	`265`	`LogReloadCoverageStatus(ReloadCoverageStatus.Done);`
`266`		`-#pragma warning disable VSTHRD103 // Call async methods when in an async method`
	`266`	`+#pragma warning disable VSTHRD002 // Avoid problematic synchronous waits`
`267`	`267`	`UpdateUI(t.Result.coverageLines, t.Result.reportHtml);`
`268`		`-#pragma warning restore VSTHRD103 // Call async methods when in an async method`
	`268`	`+#pragma warning restore VSTHRD002 // Avoid problematic synchronous waits`
`269`	`269`	`break;`
`270`	`270`	`}`
`271`		`- await reportGeneratorUtil.EndOfCoverageRunAsync();`
	`271`	`+ reportGeneratorUtil.EndOfCoverageRun();`
`272`	`272`
`273`	`273`	`}`
`274`	`274`
`@@ -284,7 +284,7 @@ private async System.Threading.Tasks.Task PollInitializedStatusAsync(Cancellatio`
`284`	`284`	`return;`
`285`	`285`
`286`	`286`	`case InitializeStatus.Initializing:`
`287`		`- await reportGeneratorUtil.LogCoverageProcessAsync("Initializing");`
	`287`	`+ reportGeneratorUtil.LogCoverageProcess("Initializing");`
`288`	`288`	`LogReloadCoverageStatus(ReloadCoverageStatus.Initializing);`
`289`	`289`	`await System.Threading.Tasks.Task.Delay(InitializeWait);`
`290`	`290`	`break;`
`@@ -305,7 +305,7 @@ public void ReloadCoverage(Func<System.Threading.Tasks.Task<List<ICoverageProjec`
`305`	`305`
`306`	`306`	`await PollInitializedStatusAsync(cancellationToken);`
`307`	`307`
`308`		`- await reportGeneratorUtil.LogCoverageProcessAsync("Starting coverage - full details in FCC Output Pane");`
	`308`	`+ reportGeneratorUtil.LogCoverageProcess("Starting coverage - full details in FCC Output Pane");`
`309`	`309`	`LogReloadCoverageStatus(ReloadCoverageStatus.Start);`
`310`	`310`
`311`	`311`	`var coverageProjects = await coverageRequestCallback();`
`@@ -325,7 +325,7 @@ public void ReloadCoverage(Func<System.Threading.Tasks.Task<List<ICoverageProjec`
`325`	`325`	`return (coverageLines, reportHtml);`
`326`	`326`
`327`	`327`	`}, cancellationToken)`
`328`		`- .ContinueWith(DisplayCoverageResultAsync, System.Threading.Tasks.TaskScheduler.Default);`
	`328`	`+ .ContinueWith(DisplayCoverageResult, System.Threading.Tasks.TaskScheduler.Default);`
`329`	`329`
`330`	`330`	`}`
`331`	`331`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,8 +26,8 @@ interface IReportGeneratorUtil`
`26`	`26`	`string ProcessUnifiedHtml(string htmlForProcessing,string reportOutputFolder);`
`27`	`27`	`Task<ReportGeneratorResult> GenerateAsync(IEnumerable<string> coverOutputFiles,string reportOutputFolder, bool throwError = false);`
`28`	`28`	`string BlankReport(bool withHistory);`
`29`		`- Task LogCoverageProcessAsync(string message);`
`30`		`- Task EndOfCoverageRunAsync();`
	`29`	`+ void LogCoverageProcess(string message);`
	`30`	`+ void EndOfCoverageRun();`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`internal class ReportGeneratorResult`
`@@ -216,23 +216,23 @@ async Task<bool> run(string outputReportType, string inputReports)`
`216`	`216`	`var reportGeneratorResult = new ReportGeneratorResult { Success = false, UnifiedHtml = null, UnifiedXmlFile = unifiedXmlFile };`
`217`	`217`
`218`	`218`	`var startTime = DateTime.Now;`
`219`		`- await LogCoverageProcessAsync("Generating cobertura report");`
	`219`	`+ LogCoverageProcess("Generating cobertura report");`
`220`	`220`	`var coberturaResult = await run("Cobertura", string.Join(";", coverOutputFiles));`
`221`	`221`	`var duration = DateTime.Now - startTime;`
`222`	`222`
`223`	`223`	`if (coberturaResult)`
`224`	`224`	`{`
`225`	`225`	`var coberturaDurationMesage = $"Cobertura report generation duration - {duration}";`
`226`		`- await LogCoverageProcessAsync(coberturaDurationMesage); // result output includes duration for normal log`
	`226`	`+ LogCoverageProcess(coberturaDurationMesage); // result output includes duration for normal log`
`227`	`227`
`228`	`228`	`startTime = DateTime.Now;`
`229`		`- await LogCoverageProcessAsync("Generating html report");`
	`229`	`+ LogCoverageProcess("Generating html report");`
`230`	`230`	`var htmlResult = await run("HtmlInline_AzurePipelines", unifiedXmlFile);`
`231`	`231`	`duration = DateTime.Now - startTime;`
`232`	`232`	`if (htmlResult)`
`233`	`233`	`{`
`234`	`234`	`var htmlReportDurationMessage = $"Html report generation duration - {duration}";`
`235`		`- await LogCoverageProcessAsync(htmlReportDurationMessage); // result output includes duration for normal log`
	`235`	`+ LogCoverageProcess(htmlReportDurationMessage); // result output includes duration for normal log`
`236`	`236`	`reportGeneratorResult.UnifiedHtml = fileUtil.ReadAllText(unifiedHtmlFile);`
`237`	`237`	`reportGeneratorResult.Success = true;`
`238`	`238`	`}`
`@@ -1687,16 +1687,14 @@ public string BlankReport(bool withHistory)`
`1687`	`1687`	`return ProcessUnifiedHtml(resourceProvider.ReadResource("dummyReportToProcess.html"),null);`
`1688`	`1688`	`}`
`1689`	`1689`
`1690`		`- public async Task LogCoverageProcessAsync(string message)`
	`1690`	`+ public void LogCoverageProcess(string message)`
`1691`	`1691`	`{`
`1692`		`- await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();`
`1693`	`1692`	`eventAggregator.SendMessage(new InvokeScriptMessage(CoverageLogJSFunctionName, message));`
`1694`	`1693`	`logs.Add(message);`
`1695`	`1694`	`}`
`1696`	`1695`
`1697`		`- public async Task EndOfCoverageRunAsync()`
	`1696`	`+ public void EndOfCoverageRun()`
`1698`	`1697`	`{`
`1699`		`- await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();`
`1700`	`1698`	`eventAggregator.SendMessage(new InvokeScriptMessage(ShowFCCWorkingJSFunctionName, false));`
`1701`	`1699`	`}`
`1702`	`1700`
Original file line number	Diff line number	Diff line change
`@@ -73,8 +73,13 @@ public void Handle(NewReportMessage message)`
`73`	`73`
`74`	`74`	`public void Handle(InvokeScriptMessage message)`
`75`	`75`	`{`
`76`		`- InvokeScript(message.ScriptName, message.Arguments);`
`77`		`- }`
	`76`	`+ ThreadHelper.JoinableTaskFactory.Run(async () =>`
	`77`	`+ {`
	`78`	`+ await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();`
	`79`	`+`
	`80`	`+ InvokeScript(message.ScriptName, message.Arguments);`
	`81`	`+ });`
	`82`	`+ }`
`78`	`83`
`79`	`84`	`public void Handle(ObjectForScriptingMessage message)`
`80`	`85`	`{`