Stream output from commands run in debugger

This change updates the way we execute commands in the debugger which need
to have their output streamed to the console.  Previously the command
execution would just evaluate the expression and return the results
without writing them to the host.  Now for PowerShell v4/5 users, the output
can be streamed as the command is being executed.  For PowerShell v3 users
the output will be written after the command fully completes executing.

Author: daviwil

src/PowerShellEditorServices/Session/PowerShellContext.cs

@@ -208,7 +208,6 @@ public async Task<IEnumerable<TResult>> ExecuteCommand<TResult>(
             PSCommand psCommand,
             bool sendOutputToHost = false)
         {
-            Pipeline nestedPipeline = null;
             RunspaceHandle runspaceHandle = null;
             IEnumerable<TResult> executionResult = null;
 
@@ -255,17 +254,10 @@ public async Task<IEnumerable<TResult>> ExecuteCommand<TResult>(
                                 "Attempting to execute nested pipeline command(s):\r\n\r\n{0}",
                                 GetStringForPSCommand(psCommand)));
 
-                        nestedPipeline = this.currentRunspace.CreateNestedPipeline();
-                        foreach (var command in psCommand.Commands)
-                        {
-                            nestedPipeline.Commands.Add(command);
-                        }
-
                         executionResult =
-                            nestedPipeline
-                                .Invoke()
-                                .Select(pso => pso.BaseObject)
-                                .Cast<TResult>();
+                            this.ExecuteCommandInDebugger<TResult>(
+                                psCommand,
+                                sendOutputToHost);
                     }
                     else
                     {
@@ -337,7 +329,7 @@ await Task.Factory.StartNew<IEnumerable<TResult>>(
                         {
                             this.WritePromptWithRunspace(runspaceHandle.Runspace);
                         }
-                        else if (nestedPipeline != null)
+                        else
                         {
                             this.WritePromptWithNestedPipeline();
                         }
@@ -348,10 +340,6 @@ await Task.Factory.StartNew<IEnumerable<TResult>>(
                     {
                         runspaceHandle.Dispose();
                     }
-                    else if(nestedPipeline != null)
-                    {
-                        nestedPipeline.Dispose();
-                    }
                 }
             }
 
@@ -571,6 +559,73 @@ private void OnSessionStateChanged(object sender, SessionStateChangedEventArgs e
 
         #region Private Methods
 
+        private IEnumerable<TResult> ExecuteCommandInDebugger<TResult>(PSCommand psCommand, bool sendOutputToHost)
+        {
+            IEnumerable<TResult> executionResult = null;
+
+            if (PowerShellVersion >= new Version(4, 0))
+            {
+#if PowerShellv4 || PowerShellv5
+                PSDataCollection<PSObject> outputCollection = new PSDataCollection<PSObject>();
+
+                if (sendOutputToHost)
+                {
+                    outputCollection.DataAdded +=
+                        (obj, e) =>
+                        {
+                            for (int i = e.Index; i < outputCollection.Count; i++)
+                            {
+                                this.WriteOutput(outputCollection[i].ToString(), true);
+                            }
+                        };
+                }
+
+                DebuggerCommandResults commandResults =
+                    this.currentRunspace.Debugger.ProcessCommand(
+                        psCommand,
+                        outputCollection);
+
+                // If the command was a debugger action, run it
+                if (commandResults.ResumeAction.HasValue)
+                {
+                    this.ResumeDebugger(commandResults.ResumeAction.Value);
+                }
+
+                executionResult =
+                    outputCollection
+                        .Select(pso => pso.BaseObject)
+                        .Cast<TResult>();
+#endif
+            }
+            else
+            {
+                using (var nestedPipeline = this.currentRunspace.CreateNestedPipeline())
+                {
+                    foreach (var command in psCommand.Commands)
+                    {
+                        nestedPipeline.Commands.Add(command);
+                    }
+
+                    executionResult =
+                        nestedPipeline
+                            .Invoke()
+                            .Select(pso => pso.BaseObject)
+                            .Cast<TResult>();
+                }
+
+                // Write the output to the host if necessary
+                if (sendOutputToHost)
+                {
+                    foreach (var line in executionResult)
+                    {
+                        this.WriteOutput(line.ToString(), true);
+                    }
+                }
+            }
+
+            return executionResult;
+        }
+
         private void WriteOutput(string outputString, bool includeNewLine)
         {
             ((IConsoleHost)this).WriteOutput(
@@ -847,10 +902,9 @@ private void WritePromptWithNestedPipeline()
                                 .Cast<string>()
                                 .FirstOrDefault();
                     });
-
             }
         }
-
+        
         #endregion
 
         #region Events