public new void Dispose()
 {
     StandardInput.Flush();
     StandardInput.Close();
     if (!WaitForExit(1000))
     {
         Kill();
     }
     if (WaitForExit(1000))
     {
         WaitHandle.WaitAll(_waitHandles);
     }
     base.Dispose();
     _isDisposed = true;
 }
 public void SendCommand(string command)
 {
     StandardInput.Write(command);
     StandardInput.Flush();
 }
Beispiel #3
0
        /// <summary>
        /// Runs the executable file
        /// </summary>
        /// <returns>The result of running the executable file</returns>
        public ProcessResult Run()
        {
            lock (this)
            {
                CheckNotRunning();

                _running = true;

                _process = new System.Diagnostics.Process
                {
                    StartInfo = GetStartInfo()
                };

                WriteStandardInput();

                if (_result.Status == ProcessStatus.NotStarted)
                {
                    _result.Status = ProcessStatus.Started;

                    _endTime = System.DateTime.Now.AddSeconds(Timeout);

                    _process.Start();
                }
            }


            if (_result.Status == ProcessStatus.Started)
            {
                if (Options.StandardInputEncoding != null)
                {
                    _standardInput = new StreamWriter(_process.StandardInput.BaseStream, Options.StandardInputEncoding);
                }
                else
                {
                    _standardInput = _process.StandardInput;
                }

                var inputThread = new Thread(new ThreadStart(() => StandardInput.Flush()));
                inputThread.Start();
                var outputReader = new ProcessReader(this, ProcessReader.OutputType.StandardOutput);
                var errorReader  = new ProcessReader(this, ProcessReader.OutputType.StandardError);

                lock (this)
                {
                    AddEvent(new ProcessEventArgs(ProcessEventType.Started, this));
                    DoEvents();

                    while (!_process.HasExited)
                    {
                        Monitor.Wait(this, 250);
                        DoEvents();
                        if ((_timeout > 0) && (System.DateTime.Now > _endTime))
                        {
                            // Not a very nice way to end a process,
                            // but effective.
                            _process.Kill();
                            _result.Status = ProcessStatus.TimedOut;
                        }
                        else if (_result.Status == ProcessStatus.Cancelled)
                        {
                            _process.Kill();
                        }
                    }
                }

                _process.WaitForExit();

                outputReader.Join();
                errorReader.Join();
                inputThread.Join();

                DoEvents();

                _result.ExitCode = _process.ExitCode;
            }

            if (_result.Status == ProcessStatus.Started)
            {
                _result.Status = ProcessStatus.Finished;
            }

            lock (this)
            {
                if (Options.StandardInputEncoding != null && _standardInput != null)
                {
                    _standardInput.Dispose();
                }
                _standardInput = null;
                _running       = false;
            }

            return(_result);
        }