cmd.exe style application written in C#

I am trying to get the results from any DOS-based application, effectively letting C# operate it as if it were a user.

I can get it to execute a command, and then show the output. The problem is knowing when the output has ended! For example, if I go start/run "cmd.exe", type "D:", then "cd D:\", and then "tree", it outputs my folder structure on the D drive, and then allows me to type my next command (only after it's finished printing the list).

However I can't find a way in code to get it to realise it's finished, and should allow the next command (basically when cmd.exe starts blinking your cursor).

        public Process p = null;

    private void Form1_Load(object sender, System.EventArgs e)
    {
        ProcessStartInfo procStarter = new ProcessStartInfo("cmd.exe");
        procStarter.RedirectStandardOutput = true;
        procStarter.RedirectStandardInput = true;
        procStarter.UseShellExecute = false;
        procStarter.Cr开发者_运维技巧eateNoWindow = true;
        p = Process.Start(procStarter);
    }

    private void Form1_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    {
        p.Close();
    }

    private void btnSend_Click(object sender, System.EventArgs e)
    {
        p.StandardInput.WriteLine("D:");
        p.StandardInput.WriteLine(@"cd D:\");
        txtOutput.Text = SendCommand(txtInput.Text);
    }

    private string SendCommand(string cmd)
    {
        p.StandardInput.WriteLine(cmd);
        return p.StandardOutput.ReadToEnd();
    }

In SendCommand(string cmd), if I run p.StandardOutput.ReadToEnd(), as per the code above, it hangs forever, presumably waiting for the application to close?

If I loop through p.StandardOutput.ReadLine(), it shows all the text (including the "D:\>" just before where the blinking cursor would then be, however it doesn't realise it's the end, calls ReadLine again, and hangs in a smiliar fashion to ReadToEnd. A dirty workaround would be to treat it as the end of the response if the current line ends with ">", however that falls apart if a line ends like that anywhere in the response.

I've tried looping through the stream character by character, and there's no special character sent at the end.

Any ideas?

Note: My ultimate goal is to provide a light library I can use for executing any DOS executable (which may require several typed commands passed to it, not just the one off arguments passed via command line on opening), parsing the results returned with a regex template, and returning the extracted result. I figured if I can effectively re-implement the cmd.exe in a windows application, then such a library will be possible.

Thanks, Lee

I suspect that your approach doesn’t work. cmd.exe is not going to communicate to you via StandardOutput when or whether the command you ran has finished or not. (I should point out though that this doesn’t stop you from running multiple commands. You can probably just send the command lines and don’t actually need to wait for it to finish.)

Perhaps a more suitable approach might be not to use cmd.exe at all. Instead, use Process.Start() to run each individual command. Then you can use StandardOutput.ReadToEnd() and it will finish when the process is finished, and you can run the next one.

I agree with Timwi, But see if something like below helps

        ProcessStartInfo procStarter = new ProcessStartInfo("cmd.exe");
        procStarter.RedirectStandardOutput = true;
        procStarter.RedirectStandardInput = true;
        procStarter.UseShellExecute = false;
        procStarter.CreateNoWindow = true;
        procStarter.WorkingDirectory = @"D:\";
        procStarter.Arguments = "/C dir";
        Process p = Process.Start(procStarter);
        string output = p.StandardOutput.ReadToEnd();

/C command line to cmd.exe will terminate cmd.exe once the work is done. You can also use p.Exited (exited event) to know when it happens.

However it will not keep the cmd.exe always running. But do you really need to keep it running?

If you're looking for 'how to wait till the spawned process terminates', Process.WaitForExit is what should do the trick. You could spawn a new shell for each "command".

About a year ago I wrote a telnet server for windows that allowed the remote user to issue commands against cmd.exe. Maybe you can use it as a starting point for your own project.

• Get the code on my blog

By reading the output asynchronous I have gotten this to work (aleast almost) like you described:

    public Process p = null;

    private void Send_Click(object sender, System.EventArgs e)
    {

        p.StandardInput.WriteLine("D:");
        p.StandardInput.WriteLine(@"cd D:\");
        p.StandardInput.WriteLine(txtInput.Text);
    }

    private void Form1_Load_1(object sender, EventArgs e)
    {
        ProcessStartInfo procStarter = new ProcessStartInfo("cmd.exe");
        procStarter.RedirectStandardOutput = true;
        procStarter.RedirectStandardInput = true;
        procStarter.UseShellExecute = false;
        procStarter.CreateNoWindow = true;

        p = Process.Start(procStarter);

        p.OutputDataReceived += new DataReceivedEventHandler(p_OutputDataReceived);
        p.BeginOutputReadLine();

    }

    void p_OutputDataReceived(object sender, DataReceivedEventArgs e)
    {
        addTextToOutput(e.Data);
    }

    private void addTextToOutput(string text)
    {
        if (txtOutput.InvokeRequired)
        {
            addTextCallback cb = new addTextCallback(addTextToOutput);
            this.Invoke(cb, new Object[] { text });
        }
        else
        {
            txtOutput.Text += text+ System.Environment.NewLine;
        }
    }

    delegate void addTextCallback(String text);

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        p.Close();
    }