Throttle "geterr" requests for better performance

This change causes the "geterr" request to be throttled to the specified
millisecond delay argument.  This prevents the language service from
getting overloaded by many successive calls into Script Analyzer.

Author: daviwil

src/PowerShellEditorServices.Transport.Stdio/Request/ErrorRequest.cs

@@ -6,13 +6,19 @@
 using Microsoft.PowerShell.EditorServices.Session;
 using Microsoft.PowerShell.EditorServices.Transport.Stdio.Event;
 using Microsoft.PowerShell.EditorServices.Transport.Stdio.Message;
+using Microsoft.PowerShell.EditorServices.Utility;
+using System;
 using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Microsoft.PowerShell.EditorServices.Transport.Stdio.Request
 {
     [MessageTypeName("geterr")]
     public class ErrorRequest : RequestBase<ErrorRequestArguments>
     {
+        private static CancellationTokenSource existingRequestCancellation;
+
         public static ErrorRequest Create(params string[] filePaths)
         {
             return new ErrorRequest
@@ -30,8 +36,78 @@ public override void ProcessMessage(
         {
             List<ScriptFile> fileList = new List<ScriptFile>();
 
+            // If there's an existing task, attempt to cancel it
+            try
+            {
+                if (existingRequestCancellation != null)
+                {
+                    // Try to cancel the request
+                    existingRequestCancellation.Cancel();
+
+                    // If cancellation didn't throw an exception,
+                    // clean up the existing token
+                    existingRequestCancellation.Dispose();
+                    existingRequestCancellation = null;
+                }
+            }
+            catch (Exception e)
+            {
+                // TODO: Catch a more specific exception!
+                Logger.Write(
+                    LogLevel.Error,
+                    string.Format(
+                        "Exception while cancelling analysis task:\n\n{0}",
+                        e.ToString()));
+
+                return;
+            }
+
+            // 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?
+            existingRequestCancellation = new CancellationTokenSource();
+            Task.Factory.StartNew(
+                () =>
+                    DelayThenInvokeDiagnostics(
+                        this.Arguments.Delay,
+                        this.Arguments.Files,
+                        editorSession,
+                        messageWriter,
+                        existingRequestCancellation.Token),
+                CancellationToken.None,
+                TaskCreationOptions.None,
+                TaskScheduler.Default);
+        }
+
+        private static async Task DelayThenInvokeDiagnostics(
+            int delayMilliseconds,
+            string[] filesToAnalyze,
+            EditorSession editorSession,
+            MessageWriter messageWriter,
+            CancellationToken cancellationToken)
+        {
+            // First of all, wait for the desired delay period before
+            // analyzing the provided list of files
+            try
+            {
+                await Task.Delay(delayMilliseconds, cancellationToken);
+            }
+            catch (TaskCanceledException)
+            {
+                // If the task is cancelled, exit directly
+                return;
+            }
+
+            // If we've made it past the delay period then we don't care
+            // about the cancellation token anymore.  This could happen
+            // when the user stops typing for long enough that the delay
+            // period ends but then starts typing while analysis is going
+            // on.  It makes sense to send back the results from the first
+            // delay period while the second one is ticking away.
+
             // Get the requested files
-            foreach (string filePath in this.Arguments.Files)
+            foreach (string filePath in filesToAnalyze)
             {
                 ScriptFile scriptFile = 
                     editorSession.Workspace.GetFile(