Waiting for commands to be complete

I am working with a winform that runs a cmd in the background, redirecting input and output asynchronously.

Currently, the winform iterating through an array of commands, writing each to the cmd via the StreamWriter the StandardInput is redirected to. How can I force the loop to wait until the present command is complete in the cmd before writing the next line in?

EDIT: I took out all of my actual project code, and 开发者_运维问答replaced it with this, a stripped down version of what I'm trying to do, only including components of my project relevant to my question.

public partial class Form1 : Form
{

    public delegate void WriteToConsoleMethod(string text);
    Process _process;

    string[] _commands = 
    {
        "echo hello world",
        "echo my name is T.K.",
        "echo Here is a list of commands"
    };
    public Form1()
    {
        InitializeComponent();
        ProcessStartInfo processStartInfo = new ProcessStartInfo("cmd")
        {
            RedirectStandardError = true,
            RedirectStandardInput = true,
            RedirectStandardOutput = true,
            UseShellExecute = false,
            CreateNoWindow = true
        };

        _process = Process.Start(processStartInfo);
        _process.OutputDataReceived += new DataReceivedEventHandler(new DataReceivedEventHandler(DataReceived_EventHandler));
        _process.ErrorDataReceived += new DataReceivedEventHandler(new DataReceivedEventHandler(DataReceived_EventHandler));
        _process.BeginErrorReadLine();
        _process.BeginOutputReadLine();
    }

    private void DataReceived_EventHandler(object sender, DataReceivedEventArgs e)
    {
        IAsyncResult result = this.BeginInvoke(new WriteToConsoleMethod(writeToConsole), new object[] { e.Data + Environment.NewLine });
        this.EndInvoke(result);
    }

    private void writeToConsole(string output)
    {
        txtbxConsole.AppendText(output);
    }

    private void btnBegin_Click(object sender, EventArgs e)
    {
        foreach (string command in _commands)
        {
            _process.StandardInput.WriteLine(command);
            // I want a way to pause here until the cmd has finished processing the command.
        }
    }
}

I don't think there is anything built-in that will support that. However you could send your own special command and then wait until you see this in the output for example , something like :

    const string Separator= "---Command Completed--\xE3\xE2\xE1\xE0\xE3";   
    // Has to be something that won't occur in normal output.  

    volatile bool finished = false;

    private void button1_Click(object sender, EventArgs e)
    {         
        foreach (string command in _commands)
            Run(command);
    }

    private void writeToConsole(string output)
    {
        if (output.IndexOf(Separator) >= 0)
            finished = true;
        else
            richTextBox1.AppendText(output);
    }


    private void Run(string command)
    {
        finished = false;
        _process.StandardInput.WriteLine(command);
        _process.StandardInput.WriteLine("@echo " + Seperator);
        while (!finished)
        {
            Application.DoEvents();
            System.Threading.Thread.Sleep(100);
        }
    }

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        finished = true;
    }

Assuming you are using System.Diagnostics.Process, then you probably need something like

ProcessStartInfo pi = new ProcessStartInfo(cmd);                
pi.Arguments = ...
pi.WorkingDirectory = ...
Process myProcess = Process.Start(pi);      
myProcess.WaitForExit();

I ended up solving this problem by wrapping my interaction with the command prompt into a separate class and instead of maintaining one prompt for all of the actions, I started up another prompt for each call. Then I take advantage of WaitForExit() to synchronize my threads.

After each command, I write in an exit command to close the process. I scan the output for exit calls, and when I find one, I use the context of that line to save the workspace so that the prompt for the next command will be made from the same working directory. I also had to hook up a DataRecievedEventHandler to parse out the header and exit calls before forwarding the EventHandlers to the winform.

The thing that's nagging me about this solution is that if the output of whatever process I'm running prints out exit, output scanner will behave as though it found the original exit. I employed the same solution sgmoore had in his answer - I write in exit [UNIQUE STRING] to the prompt, and scan the output for that, but I'm sure that's far from best practice.