『片段』ShellHelper 控制台程序 的 程序调用（支持输入命令得到返回字符串输出）

背景：

> 之前做 OGG 时，被 OGG的配置 恶心到了。（OGG是啥，这里就不解释了）

> 总之就是一个 控制台程序，总是得手动执行一堆命令，每次都得输入 —— 实在是打字打累了。

> 于是，搜索：Shell控制输入输出 的代码 —— 没有找到完美的。【部分网友给出的往往是：一堆命令，得到全部输出 —— 而我要的是：输入一行命令就得到对应的输出】

源码：

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

namespace Temp
{
    /// <summary>
    /// 控制台程序Shell辅助类
    /// </summary>
    public class ShellHelper
    {
        private static List<ShellInfo> m_ListShell = null;
        private static Thread m_ManageShell = null;
        private static readonly object m_Locker = new object();

        public static bool IsManageShellThread
        {
            get { return Thread.CurrentThread == m_ManageShell; }
        }


        public static ShellInfo Start(string exePath, ShellInfoReadLine ReadLine)
        {
            ShellInfo shellInfo = new ShellInfo();
            Process process = shellInfo.Process = new Process();
            process.StartInfo.FileName = exePath;
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardInput = true;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.RedirectStandardError = true;
            process.StartInfo.CreateNoWindow = true;
            //process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;  

            process.OutputDataReceived += new DataReceivedEventHandler(Process_OutputDataReceived);
            process.ErrorDataReceived += new DataReceivedEventHandler(Process_ErrorDataReceived);

            process.EnableRaisingEvents = true;                      // 启用Exited事件  
            process.Exited += new EventHandler(Process_Exited);   // 注册进程结束事件  

            process.Start();
            process.BeginOutputReadLine();
            process.BeginErrorReadLine();
            process.StandardInput.WriteLine();

            shellInfo.ReadLine = ReadLine;

            if (m_ListShell == null) m_ListShell = new List<ShellInfo>();
            m_ListShell.Add(shellInfo);
            InitShellManageThread();
            return shellInfo;
        }

        private static void InitShellManageThread()
        {
            if (m_ManageShell == null)
            {
                m_ManageShell = new Thread(ManageShell_ThreadWork);
                m_ManageShell.IsBackground = true;
                m_ManageShell.Start();
            }
        }
        private static void ManageShell_ThreadWork()
        {
            while (m_ListShell != null && m_ListShell.Count >= 1)
            {
                try
                {
                    lock (m_Locker)
                    {
                        foreach (ShellInfo shell in m_ListShell)
                            if (shell != null) shell.InvokeInputOutput();
                    }

                    //线程休眠 50毫秒
                    AutoResetEvent eventHandle = new AutoResetEvent(false);
                    eventHandle.WaitOne(50);
                    eventHandle.Dispose();
                }
                catch (Exception ex) { Console.WriteLine("ERR: " + ex.ToString()); }
            }
        }

        private static void Process_OutputDataReceived(object sender, DataReceivedEventArgs e)
        {
            try
            {
                ShellInfo shell = FindShellInfo(sender as Process);
                if (shell != null) shell.DataReceived(e.Data);
            }
            catch (Exception ex) { Console.WriteLine("ERR: " + ex.ToString()); }
        }
        private static void Process_ErrorDataReceived(object sender, DataReceivedEventArgs e)
        {
            try
            {
                ShellInfo shell = FindShellInfo(sender as Process);
                if (shell != null) shell.ErrorReceived(e.Data);
            }
            catch (Exception ex) { Console.WriteLine("ERR: " + ex.ToString()); }
        }
        private static void Process_Exited(object sender, EventArgs e)
        {
        }

        public static ShellInfo FindShellInfo(Process process)
        {
            if (process == null) return null;
            ShellInfo shell = m_ListShell.Find(x => x.Process == process);
            return shell;
        }
    }

    public class ShellInfo
    {
        private ShellState m_State = ShellState.Wait;
        private DateTime m_StateTime = DateTime.MinValue;

        private string m_LastOutLine;
        private List<ShellLine> m_ListWrite = new List<ShellLine>();
        private List<string> m_ListData = new List<string>();
        private List<string> m_ListError = new List<string>();




        public Process Process { get; set; }
        public ShellInfoReadLine ReadLine { get; set; }

        public ShellState State
        {
            get { return m_State; }
            private set
            {
                m_State = value;
                m_StateTime = DateTime.Now;
                m_EventHandle.Set();
            }
        }


        public string PrevCmd { get { return string.Empty; } }
        public string NextCmd { get { return string.Empty; } }

        public void Close()
        {
            try { if (Process != null && !Process.HasExited) Process.Close(); }
            catch { }
        }




        #region  输 入 输 出 处 理

        private DateTime m_DataTime = DateTime.MinValue;
        private DateTime m_ErrorTime = DateTime.MinValue;
        private AutoResetEvent m_EventHandle = new AutoResetEvent(false);
        private ManualResetEvent m_EventWaitLogoOutputHandle = new ManualResetEvent(false);
        private AutoResetEvent m_EventAwaitWriteHandle = new AutoResetEvent(false);
        private const int MAX_UIWAIT_MILLSECOND = 60 * 1000;

        /// <summary>
        /// 等待 Shell 的 Logo输出结束 (也就是 刚启动Shell程序时, Shell程序最先输出文本, 然后才允许用户输入, 这里等待的就是 最先输出文本的过程)
        /// </summary>
        public void WaitLogoOuput()
        {
            if (ShellHelper.IsManageShellThread) return;
            m_EventWaitLogoOutputHandle.WaitOne(MAX_UIWAIT_MILLSECOND);
        }
        /// <summary>
        /// 阻塞当前线程, 直到当前 Shell 处于 指定的状态
        /// </summary>
        public void WaitState(ShellState state)
        {
            if (ShellHelper.IsManageShellThread || m_State == ShellState.Exited) return;

            const int JOIN_MILL_SECOND = 100; //等待毫秒数
            while (m_State != ShellState.Exited && (m_State & state) != m_State)
                m_EventHandle.WaitOne(JOIN_MILL_SECOND);
        }

        /// <summary>
        /// 向Shell中, 输入一段命令, 且等待命令返回 执行后的输出字符串.
        /// </summary>
        public string WriteLine(string cmd)
        {
            return WriteLine(cmd, MAX_UIWAIT_MILLSECOND);
        }
        /// <summary>
        /// 向Shell中, 输入一段命令, 且等待命令返回 执行后的输出字符串.
        /// </summary>
        public string WriteLine(string cmd, int ms)
        {
            if (ms < 0) ms = MAX_UIWAIT_MILLSECOND;
            WaitLogoOuput();
            WaitState(ShellState.Input | ShellState.Wait);
            State = ShellState.Input;

            if (m_ListWrite == null) m_ListWrite = new List<ShellLine>();

            cmd = (cmd ?? string.Empty).Trim();
            ShellLine cmdLine = this.CurrLine = new ShellLine(m_LastOutLine, cmd);
            m_ListWrite.Add(cmdLine);

            m_EventAwaitWriteHandle.Reset();
            m_EventAwaitWriteHandle.WaitOne(ms);
            return cmdLine.Result;
        }
        /// <summary>
        /// 向Shell中, 以异步模式输入一段命令, 命令返回的输出字符串, 可以通过 ReadLine 回调捕获
        /// </summary>
        public void BeginWriteLine(string cmd)
        {
            WaitLogoOuput();
            WaitState(ShellState.Input | ShellState.Wait);
            State = ShellState.Input;

            if (m_ListWrite == null) m_ListWrite = new List<ShellLine>();
            cmd = (cmd ?? string.Empty).Trim();
            ShellLine cmdLine = this.CurrLine = new ShellLine(m_LastOutLine, cmd);
            m_ListWrite.Add(cmdLine);
            //m_EventAwaitWriteHandle.Reset();
            //m_EventAwaitWriteHandle.WaitOne(MAX_UIWAIT_MILLSECOND);
        }

        protected ShellLine CurrLine { get; set; }

        public void DataReceived(string str)
        {
            WaitState(ShellState.Output | ShellState.Wait);
            State = ShellState.Output;


            ShellLine cmdLine = this.CurrLine;
            if (cmdLine != null && !cmdLine.IsEmpty && !string.IsNullOrEmpty(str) && !cmdLine.Output)
            {
                Process.StandardInput.WriteLine();
                string diffStr = cmdLine.GetDiffString(str);
                if (!string.IsNullOrEmpty(diffStr)) m_ListData.Add(diffStr);
                cmdLine.Output = true;
                return;
            }

            if (cmdLine != null) cmdLine.Output = true;
            m_ListData.Add(str);
            State = ShellState.Output;
        }
        public void ErrorReceived(string err)
        {
            WaitState(ShellState.OutputError | ShellState.Wait);
            State = ShellState.OutputError;

            m_ListError.Add(err);
            State = ShellState.OutputError;
        }



        public void InvokeInputOutput()
        {
            if (Process == null || Process.HasExited)
            {
                m_EventHandle.Set();
                m_EventWaitLogoOutputHandle.Set();
                m_EventAwaitWriteHandle.Set();
                return;
            }

            //100 ms 没有进行 输入、输出 操作, 则管理线程开始接收 Shell的处理
            const int DIFF_MILL_SECOND = 100;
            if (/*m_State != ShellState.Wait && */(DateTime.Now - m_StateTime).TotalMilliseconds > DIFF_MILL_SECOND)
            {

                ShellInfoReadLine handle = this.ReadLine;
                ShellLine waitCmdLine = this.CurrLine;
                string waitCmd = waitCmdLine == null ? string.Empty : waitCmdLine.Cmd;

                if (waitCmdLine != null || (m_ListWrite == null || m_ListWrite.Count <= 0))
                {
                    #region  正常输出
                    if (m_ListData != null && m_ListData.Count >= 1)
                    {
                        string last = m_ListData[m_ListData.Count - 1];
                        if (!string.IsNullOrEmpty(last) && !last.Trim().EndsWith(">")) m_ListData.Add(string.Empty);

                        string data = "
" + string.Join("
", m_ListData);
                        m_LastOutLine = last;
                        m_ListData.Clear();
                        handle(waitCmd, data);
                        if (waitCmdLine != null) waitCmdLine.Result = data;
                        this.CurrLine = null;
                        m_EventAwaitWriteHandle.Set();
                        m_EventWaitLogoOutputHandle.Set();
                    }
                    #endregion

                    #region  异常输出
                    if (m_ListError != null && m_ListError.Count >= 1)
                    {
                        string last = m_ListError[m_ListError.Count - 1];
                        if (!string.IsNullOrEmpty(last) && !last.Trim().EndsWith(">")) m_ListError.Add(string.Empty);

                        string error = "
" + string.Join("
", m_ListError);
                        m_ListError.Clear();
                        handle(waitCmd, error);
                        if (waitCmdLine != null) waitCmdLine.Result = error;
                        this.CurrLine = null;
                        m_EventAwaitWriteHandle.Set();
                        m_EventWaitLogoOutputHandle.Set();
                    }
                    #endregion
                }

                #region  执行输入
                if (m_ListWrite != null && m_ListWrite.Count >= 1)
                {
                    ShellLine cmdLine = m_ListWrite[0];
                    this.Process.StandardInput.WriteLine(cmdLine.Cmd);
                    m_ListWrite.RemoveAt(0);
                    //输入命令后, 优先接收 Shell 的 错误信息
                    State = ShellState.OutputError;
                }
                else
                    State = ShellState.Wait;
                #endregion


            }
        }

        #endregion


    }
    public class ShellLine
    {
        public ShellLine(string cmd)
        {
            this.Cmd = cmd;
        }
        public ShellLine(string tip, string cmd)
        {
            this.Tip = tip;
            this.Cmd = cmd;
        }

        public string Tip { get; set; }
        public string Cmd { get; set; }
        public string Result { get; set; }


        public bool Output { get; set; }
        public bool IsEmpty
        {
            get { return string.IsNullOrEmpty(this.Cmd); }
        }
        public string Line
        {
            get { return Tip + Cmd; }
        }


        public string GetDiffString(string str)
        {
            if (string.IsNullOrEmpty(str)) return string.Empty;

            string tip = this.Tip;
            string line = this.Line;
            if (str.StartsWith(line)) return str.Substring(line.Length);
            if (str.StartsWith(tip)) return str.Substring(tip.Length);
            return str;
        }
    }

    [Flags]
    public enum ShellState
    {
        /// <summary>
        /// Shell 暂时没有任何输入输出, 可能是在等待用户输入, 也可能是Shell正在处理数据
        /// </summary>
        Wait = 1,
        /// <summary>
        /// 正在向 Shell 中写入命令
        /// </summary>
        Input = 2,
        /// <summary>
        /// Shell 正式输出 正常信息
        /// </summary>
        Output = 4,
        /// <summary>
        /// Shell 正在输出 错误信息
        /// </summary>
        OutputError = 8,
        /// <summary>
        /// Shell 已经退出
        /// </summary>
        Exited = 16,


    }

    public delegate void ShellInfoReadLine(string cmd, string result);

}

调用：

            ShellInfo shell = ShellHelper.Start("cmd.exe", (cmd, rst) => {  });
            shell.WaitLogoOuput(); //先等程序把 LOGO 输出完

            string aaa = shell.WriteLine("D:");  //相当于在 cmd 中输入 D:
            string bbb = shell.WriteLine("dir"); //相当于在 cmd 中输入 dir
              string ccc = shell.WriteLine("AAAA");

截图：