Thread: Encapsulating cmd.exe

I'm trying to encapsulate cmd.exe in a C# program by spawning the process and redirecting StdIn and StdOut to different controls.

Basically, I have a text box for output and text box for input. When the program starts, I spawn the process, and then start two threads, for StdOut and StdError.

The StdOut thread loops indefinitely, appending line at a time to the output text control. If the stream ends, the thread exits. The StdError thread just reads in anything in the stream, because I heard that the process stalls if something is sitting in StdError.

When some text is entered into the input text control, I send that input to the StdIn stream.

The results are discouraging. When the process is spawned, nothing is written to the text control. Nothing happens when I write to the input control. However, task manager shows that cmd.exe has been spawned.

I managed to get partial results using a couple non-thread methods previously. One involved using a console project, so I could just have a loop running indefinitely on the main thread for the StdOut stream, and the console provided the StdIn from the keyboard, using the cmd.exe process. This worked ok, but that was without redirecting the StdIn. I didn't want the console hanging around, so I moved to just windows forms.

I tried a similar method with the forms, redirecting StdOut by running a loop on the main thread, to write each line to a text control. I didn't redirect StdIn. Unfortunately, the program only wrote the output of cmd.exe up until input would have been required, then cmd.exe was terminated. I believe this was because there was no console around to provide StdIn, so the spawned process had no choice but to terminate.

Now with the threads, nothing happens. Any advice on how I could resolve this, or go about it better?

Code:

public void Spawn()
{
	//Start the process
	m_proc = new Process();
	m_proc.StartInfo.FileName = "cmd.exe";
	m_proc.StartInfo.UseShellExecute = false;
	m_proc.StartInfo.RedirectStandardOutput = true;
	m_proc.StartInfo.RedirectStandardError=true;
	m_proc.StartInfo.RedirectStandardInput=true;
	m_proc.StartInfo.CreateNoWindow=true;
	m_proc.Start();

	
	//Threading
	StdOutUseThreads();
	StdErrUseThreads();
}

//Threading for stdout, a similar thread is created for stderr
public void StdOutUseThreads()
{
	Thread ReaderThread=new Thread( new ThreadStart (StdOutReader) );
	ReaderThread.Start();
}

public void StdOutReader()
{
	for (;;)
	{
		string output=m_proc.StandardOutput.ReadLine();
		if (null==output)
			break;
		m_text.AppendText(output+"\r\n");
	}
}

//Runs on main thread, writes a line to StdIn
private void m_input_Leave(object sender, EventArgs e)
{
	if (m_input.Text.Length>0)
	{
		m_proc.StandardInput.WriteLine(m_input.Text);
	}
}

Does anyone have any advice?

Thanks for the code but I think my primary problem is that I am trying to encapsulate a console based process without a console running in my process. This causes issues which I don't exactly understand. I'll try to incorporate your code though.

If anyone has any ideas please let me know.

Problem solved. Instead of reading a line at a time from Standard Output, read a character at a time.