Improve Task usage

src/PowerShellEditorServices.Hosting/Configuration/HostLogger.cs

@@ -288,7 +288,11 @@ public StreamLogger(StreamWriter streamWriter)
             _messageQueue = new BlockingCollection<string>();
 
             // Start writer listening to queue
-            _writerTask = Task.Run(RunWriter);
+            _writerTask = Task.Factory.StartNew(
+                RunWriter,
+                CancellationToken.None, // Inner method will manage cancellation
+                TaskCreationOptions.LongRunning | TaskCreationOptions.DenyChildAttach,
+                TaskScheduler.Default);
         }
 
         public void OnCompleted()

src/PowerShellEditorServices/Services/Analysis/AnalysisService.cs

@@ -578,14 +578,9 @@ private PowerShellResult InvokePowerShell(string command, IDictionary<string, ob
             }
         }
 
-        private async Task<PowerShellResult> InvokePowerShellAsync(string command, IDictionary<string, object> paramArgMap = null)
+        private Task<PowerShellResult> InvokePowerShellAsync(string command, IDictionary<string, object> paramArgMap = null)
         {
-            var task = Task.Run(() =>
-            {
-                return InvokePowerShell(command, paramArgMap);
-            });
-
-            return await task.ConfigureAwait(false);
+            return Task.Run(() => InvokePowerShell(command, paramArgMap));
         }
 
         /// <summary>
@@ -694,7 +689,7 @@ private class PowerShellResult
             public bool HasErrors { get; }
         }
 
-        internal async Task RunScriptDiagnosticsAsync(
+        internal Task RunScriptDiagnosticsAsync(
             ScriptFile[] filesToAnalyze)
         {
             // If there's an existing task, attempt to cancel it
@@ -721,30 +716,22 @@ private class PowerShellResult
 
                 TaskCompletionSource<bool> cancelTask = new TaskCompletionSource<bool>();
                 cancelTask.SetCanceled();
-                return;
+                return Task.CompletedTask;
             }
 
             // If filesToAnalzye is empty, nothing to do so return early.
             if (filesToAnalyze.Length == 0)
             {
-                return;
+                return Task.CompletedTask;
             }
 
             // Create a fresh cancellation token and then start the task.
             // We create this on a different TaskScheduler so that we
             // don't block the main message loop thread.
             // TODO: Is there a better way to do this?
             s_existingRequestCancellation = new CancellationTokenSource();
-            await Task.Factory.StartNew(
-                () =>
-                    DelayThenInvokeDiagnosticsAsync(
-                        750,
-                        filesToAnalyze,
-                        _configurationService.CurrentSettings.ScriptAnalysis.Enable ?? false,
-                        s_existingRequestCancellation.Token),
-                CancellationToken.None,
-                TaskCreationOptions.None,
-                TaskScheduler.Default).ConfigureAwait(false);
+            bool scriptAnalysisEnabled = _configurationService.CurrentSettings.ScriptAnalysis.Enable ?? false;
+            return Task.Run(() => DelayThenInvokeDiagnosticsAsync(delayMilliseconds: 750, filesToAnalyze, scriptAnalysisEnabled, s_existingRequestCancellation.Token));
         }
 
         private async Task DelayThenInvokeDiagnosticsAsync(

src/PowerShellEditorServices/Services/PowerShellContext/Console/WindowsConsoleOperations.cs

@@ -37,11 +37,7 @@ public async Task<ConsoleKeyInfo> ReadKeyAsync(bool intercept, CancellationToken
             await _readKeyHandle.WaitAsync(cancellationToken).ConfigureAwait(false);
             try
             {
-                return
-                    _bufferedKey.HasValue
-                        ? _bufferedKey.Value
-                        : await Task.Factory.StartNew(
-                            () => (_bufferedKey = System.Console.ReadKey(intercept)).Value);
+                return _bufferedKey ?? await Task.Run(() => (_bufferedKey = System.Console.ReadKey(intercept)).Value).ConfigureAwait(false);
             }
             finally
             {