C# - Read Text From Console Window Asynchronously

    public class ProcessWithOutput :IDisposable
    {
        public enum PipeType { StdOut, StdErr }
        public class Output
        {
            //Theres a few ways to arrange the data.  Play with this or just output a string
            public string Message { get; set; }
            public PipeType Pipe { get; set; }
            public override string ToString()
            {
                return string.Format("{0}: {1}", Pipe, Message);
            }
        }

        private readonly string _command;
        private readonly string _args;
        private readonly string _workingDirectory;
        private Process _process;
        private bool _isDisposed = false;

        private readonly Queue<output> _outputQueue = new Queue<output>();

        private StreamWriter _inputStreamWriter;

        //These stop us rushing ahead before async threads are ready
        private ManualResetEvent[] _waitHandles = new ManualResetEvent[2];
        private ManualResetEvent _outputSteamWaitHandle = new ManualResetEvent(false);

        public ProcessWithOutput(string startCommand, string args, string workingDirectory)
        {
            _command = startCommand;
            _args = args;
            _workingDirectory = workingDirectory;
        }

        //This enumerable might be handy.  Whatever reads from it will pause when _outputSteamWaitHandle is not set, 
        //which might be ideal, or could cause your program to lock up if no output is ever received >_<        
public IEnumerable<string> GetMessages()
        {
            while (!_isDisposed)
            {
                _outputSteamWaitHandle.WaitOne();
                if (_outputQueue.Any())
                    yield return _outputQueue.Dequeue().ToString();
            }
            yield break;
        }

        // Easy interface for command input
        public void SendCommand(string command)
        {
            _inputStreamWriter.Write(command);
            _inputStreamWriter.Flush();
        }

        //You might want to start in the ctor, even ^_^
        public int StartProcess()
        {
            ProcessStartInfo startInfo = new ProcessStartInfo
            {
                FileName = _command,
                Arguments = _args,
                WorkingDirectory = _workingDirectory,
                UseShellExecute = false,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                RedirectStandardInput = true
            };

            _process = new Process { StartInfo = startInfo };


            //Outputs will be async
            _process.OutputDataReceived += delegate(object sender, DataReceivedEventArgs args)
            {
                if (args.Data == null)
                {
                    //the pipe has closed. i.e. the process has ended
                    _waitHandles[0].Set();
                }
                else if (args.Data.Length > 0)
                {
                    _outputQueue.Enqueue(new Output { Message = args.Data, Pipe = PipeType.StdOut });
                    _outputSteamWaitHandle.Set();
                }
            };
            _process.ErrorDataReceived += delegate(object sender, DataReceivedEventArgs args)
            {
                if (args.Data == null)
                {
                    //the pipe has closed. i.e. the process has ended
                    _waitHandles[1].Set();
                }
                else if (args.Data.Length > 0)
                {
                    _outputSteamWaitHandle.Set();
                    _outputQueue.Enqueue(new Output { Message = args.Data, Pipe = PipeType.StdErr });
                }
            };

            //This will be your hook in to write commands
            _inputStreamWriter = _process.StandardInput;

            _process.Start();

            //Now the process has started and those buffers are beginning to fill.
            //These two lines start reading the buffers
            _waitHandles[0] = new ManualResetEvent(false);
            _process.BeginErrorReadLine();
            _waitHandles[1] = new ManualResetEvent(false);
            _process.BeginOutputReadLine();

            return _process.Id;
        }

        //Notice I have implemented the disposable interface to make sure that everything get cleaned up properly.
        public void Dispose()
        {
            _inputStreamWriter.Flush();
            _inputStreamWriter.Close();
            if(!_process.WaitForExit(1000))
                _process.Kill();
            //This next bit might seem odd, but trust me: You HAVE to clear those bufferes!
            if(_process.WaitForExit(1000))
                WaitHandle.WaitAll(_waitHandles);
            _isDisposed = true;
        }
    }

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;

namespace ProcessWithOutput
{

    public class ProcessWrapper : Process, IDisposable
    {
        public enum PipeType { StdOut, StdErr }
        public class Output{
            
            public string Message { get; set; }
            public PipeType Pipe { get; set; }
            public override string ToString(){
                return $"{Pipe}: {Message}";
            }
        }

        private readonly string _command;
        private readonly string _args;
        private bool _isDisposed;

        private readonly Queue<Output> _outputQueue = new Queue<Output>();
        
        
        private readonly ManualResetEvent[] _waitHandles = new ManualResetEvent[2];
        private readonly ManualResetEvent _outputSteamWaitHandle = new ManualResetEvent(false);

        public ProcessWrapper(string startCommand, string args){
            _command = startCommand;
            _args = args;
        }
      
        public IEnumerable<string> GetMessages(){

            while (!_isDisposed){

                _outputSteamWaitHandle.WaitOne();
                if (_outputQueue.Any())
                    yield return _outputQueue.Dequeue().ToString();
            }
        }
        
        public void SendCommand(string command){

            StandardInput.Write(command);
            StandardInput.Flush();
        }

        public new int Start(){

            ProcessStartInfo startInfo = new ProcessStartInfo{

                FileName = _command,
                Arguments = _args,
                UseShellExecute = false,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                RedirectStandardInput = true
            };
            
            StartInfo = startInfo;
            
            OutputDataReceived += delegate (object sender, DataReceivedEventArgs args){

                if (args.Data == null){

                    _waitHandles[0].Set();
                }
                else if (args.Data.Length > 0){

                    _outputQueue.Enqueue(new Output { Message = args.Data, Pipe = PipeType.StdOut });
                    _outputSteamWaitHandle.Set();
                }
            };

            ErrorDataReceived += delegate (object sender, DataReceivedEventArgs args){

                if (args.Data == null){

                    _waitHandles[1].Set();
                }
                else if (args.Data.Length > 0){

                    _outputSteamWaitHandle.Set();
                    _outputQueue.Enqueue(new Output { Message = args.Data, Pipe = PipeType.StdErr });
                }
            };
            
            base.Start();
            
            _waitHandles[0] = new ManualResetEvent(false);
            BeginErrorReadLine();
            _waitHandles[1] = new ManualResetEvent(false);
            BeginOutputReadLine();
            
            return Id;
        }
        
        public new void Dispose(){

            StandardInput.Flush();
            StandardInput.Close();
            if (!WaitForExit(1000)){
                Kill();
            }
            if (WaitForExit(1000)){
                WaitHandle.WaitAll(_waitHandles);
            }
            base.Dispose();
            _isDisposed = true;
        }
    }
}

using System;
using System.Threading;
namespace ConsoleWithOutput
{
    class Program
    {

        static void Main(string[] args){

            var count = 0;
            while (true){

                Console.Out.WriteLine($"{count++:0000} + some output");
                Thread.Sleep(1000);

            }
        }
    }
}

using System;

namespace ProcessWithOutput
{
    class Program
    {
        static void Main(string[] args)
        {
            var process = new ProcessWrapper(args[0],"");
            process.OutputDataReceived += (sender, eventArgs) => Console.WriteLine($"Received: {eventArgs.Data}");
            process.Start();

            Console.ReadLine();
        }
    }
}