Prozess In & Output umleiten

    • C#
    • .NET (FX) 3.0–3.5

      Prozess In & Output umleiten

      Guten Tag,
      ich habe kürzlich in einem anderem Forum Hilfestellung gegeben, um Befehle in den InputStream eines Prozesses zu schreiben. Rausgekommen ist die Klasse ProcessController, vieleicht kann ja jemand damit was anfangen.

      ProcessController

      C#-Quellcode

      1. class ProcessController : IDisposable
      2. {
      3. #region Events
      4. //***************
      6. public event EventHandler<ProcessControllerEventArgs.ProcessStart> OnProcessStart;
      7. protected virtual void EventProcessStart(Process p, DateTime startTime)
      8. {
      9. if (OnProcessStart != null)
      10. OnProcessStart(this, new ProcessControllerEventArgs.ProcessStart(p, startTime));
      11. }
      13. public event EventHandler<ProcessControllerEventArgs.ProcessStop> OnProcessStop;
      14. protected virtual void EventProcessStop(string processName, DateTime shutdownTime)
      15. {
      16. if (OnProcessStop != null)
      17. OnProcessStop(this, new ProcessControllerEventArgs.ProcessStop(processName, shutdownTime));
      18. }
      20. public event EventHandler<ProcessControllerEventArgs.ProcessOutputDataReceived> OnProcessOutputDataReceived;
      21. protected virtual void EventProcessOutputDataReceived(string data)
      22. {
      23. if (OnProcessOutputDataReceived != null)
      24. OnProcessOutputDataReceived(this, new ProcessControllerEventArgs.ProcessOutputDataReceived(data));
      25. }
      27. public event EventHandler<ProcessControllerEventArgs.ProcessErrorDataReceived> OnProcessErrorDataReceived;
      28. protected virtual void EventProcessErrorDataReceived(string data)
      29. {
      30. if (OnProcessErrorDataReceived != null)
      31. OnProcessErrorDataReceived(this, new ProcessControllerEventArgs.ProcessErrorDataReceived(data));
      32. }
      34. //=============
      35. #endregion Events
      37. #region Private Felder
      38. //***********************
      40. private Process process;
      41. private StreamWriter swCmdWriter;
      43. //==================
      44. #endregion Private Felder
      46. #region Konstruktoren
      47. //***********************
      49. /// <summary>
      50. /// ProcessController Konstruktor
      51. /// </summary>
      52. /// <param name="executableName">Name des Processes der gestartet werden soll</param>
      53. /// <param name="arguments">Startargumente die verwerndet werden sollen. Wenn keine Startargumente verwendet werden sollen, muss ein leerer string übergeben werden.</param>
      54. /// <param name="createNoWindow">Wenn False, wird keine Prozessfenster erstellt</param>
      55. public ProcessController(string executableName, string arguments, bool createNoWindow)
      56. {
      57. if (executableName == null || executableName == "")
      58. throw new ArgumentNullException("Executable name can´t be null");
      60. // Prozess Instanzieren
      61. process = new Process();
      62. process.StartInfo = CreateStartInfo(executableName, arguments, createNoWindow);
      63. process.OutputDataReceived += ProcessOutputDataReceived;
      64. process.ErrorDataReceived += ProcessErrorDataReceived;
      65. process.Start();
      67. // Event Feuern
      68. EventProcessStart(process, DateTime.Now);
      70. // Output des Prozesses Asynchron lesen
      71. process.BeginErrorReadLine();
      72. process.BeginOutputReadLine();
      74. // Standartinput des Prozess festlegen
      75. swCmdWriter = process.StandardInput;
      76. }
      77. //
      78. public ProcessController(string executableName, bool createNoWindow) : this(executableName, "", createNoWindow) { }
      79. //
      80. public ProcessController(string executableName, string arguments) : this(executableName, arguments, false) { }
      81. //
      82. public ProcessController(string executableName) : this(executableName, "") { }
      84. //==================
      85. #endregion Konstruktoren
      87. public void Dispose()
      88. {
      89. if (process != null) {
      90. process.OutputDataReceived -= ProcessOutputDataReceived;
      91. process.ErrorDataReceived -= ProcessErrorDataReceived;
      92. StopProcess();
      93. process.Dispose();
      94. process = null;
      95. }
      97. if (swCmdWriter != null)
      98. swCmdWriter.Dispose();
      100. GC.SuppressFinalize(this);
      101. }
      103. /// <summary>
      104. /// Stoppt den Prozess
      105. /// </summary>
      106. public void StopProcess()
      107. {
      108. if (process != null && IsProcessAlive) {
      109. process.Kill();
      111. // Event Feuern
      112. EventProcessStop(process.ProcessName, DateTime.Now);
      113. }
      114. }
      116. /// <summary>
      117. /// Schreibt den anbgegebenen Befehl in den Inputstream des Prozesses
      118. /// </summary>
      119. /// <param name="cmd">Befehl der in den Inputstream geschrieben werden soll</param>
      120. /// <returns>True wenn der befehl geschrieben wurde, andernfalls false</returns>
      121. public bool ExecuteCommand(string cmd)
      122. {
      123. if (process == null || !IsProcessAlive || cmd == "")
      124. return false;
      126. swCmdWriter.WriteLine(cmd);
      127. return true;
      128. }
      130. /// <summary>
      131. /// Erstellt ein ProcessStartInfo -Objekt
      132. /// </summary>
      133. /// <param name="executableName">Name des Processes der gestartet werden soll</param>
      134. /// <param name="arguments">Startargumente die verwerndet werden sollen.</param>
      135. /// <param name="createNoWindow">Wenn False, wird keine Prozessfenster erstellt</param>
      136. /// <returns>ProcessStartInfo</returns>
      137. private ProcessStartInfo CreateStartInfo(string executableName, string arguments, bool createNoWindow)
      138. {
      139. ProcessStartInfo procInfo = new ProcessStartInfo(executableName);
      140. procInfo.CreateNoWindow = createNoWindow;
      142. if (arguments != "")
      143. procInfo.Arguments = arguments;
      145. procInfo.UseShellExecute = false;
      146. procInfo.RedirectStandardInput = true;
      147. procInfo.RedirectStandardOutput = true;
      148. procInfo.RedirectStandardError = true;
      150. return procInfo;
      151. }
      153. /// <summary>
      154. /// Prüft ob eine Prozess Instanz aktiv ist
      155. /// </summary>
      156. private bool IsProcessAlive
      157. {
      158. get
      159. {
      160. if (process != null)
      161. return Process.GetProcessesByName(process.ProcessName).ToList().Find(x => x.Id == process.Id) != null;
      162. else
      163. return false;
      164. }
      165. }
      167. // Abonnierter Process -Events
      168. //********************************
      170. private void ProcessOutputDataReceived(object sender, DataReceivedEventArgs e)
      171. {
      172. EventProcessOutputDataReceived(e.Data);
      173. }
      175. private void ProcessErrorDataReceived(object sender, DataReceivedEventArgs e)
      176. {
      177. EventProcessErrorDataReceived(e.Data);
      178. }
      180. }


      C#-Quellcode

      1. class ProcessControllerEventArgs
      2. {
      3. public class ProcessStart : EventArgs
      4. {
      5. public Process CurrentProcess { get; private set; }
      6. public DateTime StartTime { get; private set; }
      8. public ProcessStart(Process p, DateTime startTime)
      9. {
      10. CurrentProcess = p;
      11. StartTime = startTime;
      12. }
      13. }
      15. public class ProcessStop : EventArgs
      16. {
      17. public string ProcessName { get; private set; }
      18. public DateTime ShutdownTime { get; private set; }
      20. public ProcessStop(string processName, DateTime shutdownTime)
      21. {
      22. ProcessName = processName;
      23. ShutdownTime = shutdownTime;
      24. }
      25. }
      27. public class ProcessOutputDataReceived : EventArgs
      28. {
      29. public string Data { get; private set; }
      30. public ProcessOutputDataReceived(string data)
      31. {
      32. Data = data;
      33. }
      34. }
      36. public class ProcessErrorDataReceived : EventArgs
      37. {
      38. public string Data { get; private set; }
      39. public ProcessErrorDataReceived(string data)
      40. {
      41. Data = data;
      42. }
      43. }
      44. }



      AnwendungsBeispiel

      C#-Quellcode

      1. ProcessController pc;
      3. #region GUI
      4. //************
      6. private void button_startProcess_Click(object sender, EventArgs e)
      7. {
      8. if (textBox_process.Text == "")
      9. return;
      11. if (pc != null) {
      12. pc.Dispose();
      13. pc = null;
      14. }
      16. pc = new ProcessController(textBox_process.Text, true);
      17. pc.OnProcessStart += pc_OnProcessStart;
      18. pc.OnProcessStop+=pc_OnProcessStop;
      19. pc.OnProcessOutputDataReceived +=pc_OnProcessOutputDataReceived;
      20. pc.OnProcessErrorDataReceived+=pc_OnProcessErrorDataReceived;
      21. }
      23. private void button_stopProcess_Click(object sender, EventArgs e)
      24. {
      25. pc.StopProcess();
      26. pc.Dispose();
      27. pc = null;
      28. }
      30. private void button_prozessCmd_Click(object sender, EventArgs e)
      31. {
      32. if (pc == null || textBox_cmd.Text == "")
      33. return;
      35. pc.ExecuteCommand(textBox_cmd.Text);
      36. }
      38. //==========
      39. #endregion GUI
      41. #region Abonnierte Events
      42. //***************************
      44. private void pc_OnProcessStart(object sender, ProcessControllerEventArgs.ProcessStart e)
      45. {
      46. WriteProcessMessage(string.Format("[{0}] Prozess {1} wurde gestartet...",e.StartTime.ToShortTimeString(), e.CurrentProcess.ProcessName));
      47. }
      49. private void pc_OnProcessStop(object sender, ProcessControllerEventArgs.ProcessStop e)
      50. {
      51. WriteProcessMessage(string.Format("[{0}] Prozess {1} wurde beendet...",e.ShutdownTime.ToShortTimeString(), e.ProcessName));
      52. }
      54. private void pc_OnProcessOutputDataReceived(object sender, ProcessControllerEventArgs.ProcessOutputDataReceived e)
      55. {
      56. WriteProcessMessage(e.Data);
      57. }
      59. private void pc_OnProcessErrorDataReceived(object sender, ProcessControllerEventArgs.ProcessErrorDataReceived e)
      60. {
      61. WriteProcessMessage(e.Data);
      62. }
      64. //=====================
      65. #endregion Abonnierte Events
      67. private void WriteProcessMessage(string msg)
      68. {
      70. if (textBox_output.InvokeRequired)
      71. textBox_output.Invoke(new MethodInvoker(delegate()
      72. {
      73. textBox_output.Text += msg + Environment.NewLine;
      74. }));
      75. else
      76. textBox_output.Text += msg + Environment.NewLine;
      77. }