When a program starts, a new process (a program in execution) is created by the operating system, and this process is identified by its process Id and also a name. A set of counters are set attached to this process by the OS in order to have some statistics about it.
In .NET, the process component is used to start a new process or even kill or suspend an existing one. Also we can get some statistics about the process already running through the following properties:.
- NonpagedSystemMemorySize
- PagedMemorySize
- PagedSystemMemorySize
- PeakPagedMemorySize
- PeakVirtualMemorySize
- PeakWorkingSet
- PriorityClass
- PrivateMemorySize
- PrivilegedProcessorTime
The process component offers static and instance methods. Some very important static methods are:
- EnterDebugMode: Put the process in debugging for interaction with the OS.
- GetCurrentProcess: Returns the current running process.
- GetProcessById: Returns a process instance of an existing process receiving as parameter the process id.
- GetProcesses: Returns an array of Process instances of the currently running process in the host machine.
- Start: Starts a new process.
The Process Class Methods:
- Close: Frees the resources associated with an instantiated process component.
- Kill: Terminates a running process
- CloseMainWindow: Close a process which a main windows by sending a message to its main window.
The Process Class Properties:
- Responding: Gets a value about the current status of a process: true for running false for not Responding.
- StandardError: Gets a file descriptor for the standard error in order to be able to redirect to a normal Stream Reader and read as a file.
- StandardInput: Gets the standard input of the process as file descriptor in order to be able to redirect and write to it as if writing to a StremWriter.
- StandardOutput: Similar as the Standard error but used to read the standard output of the process.
- StartInfo: This property has to be set with a ProcessStartInfo instance to pass initialization parameters to the process, before it starts. Altering this process after starting a process has no effect.
The list of properties and methods above show is not exhaustive, you can find some other ones through the help online.
In this example I'll try to illustrate some of the power of this component by starting a normal process (windows app) or also by redirecting the standard error, output and input of a DOS app. Also, you will see how to execute DOS commands by using the process component. You can also extend the example by reading some of the counters associated to a process and showing them in a window, like the Task Manager app. The let's see the example and some important details about it:
First of all we need to instantiate a ProcessStartInfo class passing as a constructor param the name of the app that we want to launch and to set some parameters to be passed to the Process instances (p):
ProcessStartInfo psI =
new ProcessStartInfo("cmd");
The property psI.UseShellExecute was set as false, to be able to redirect the StandardInput, etc. After that, the properties
psI.RedirectStandardInput
psI.RedirectStandardOutput
psI.RedirectStandardError
...are set to true.
To avoid the cmd annoying window we set as true the property psI.CreateNoWindow so no window will be created for the cmd app.Finally we set the p.StartInfo property to the instance of ProcessStartInfo that we have just created and voila , starts the process.
To be able to capture the p.StandardInput, p.StandardOutput and p.StandardError we get the File Descriptors (StreamReaders and StreamWriter classes) to read the StandardOutput and StandardError and to write to the StandardInput. The read and write operations are performed as we do it in a normal file. (Hmm, does this way of working with the IO remind you the unix world?) The process cmd is closed when we close the p.StandardInput file descriptor.
At the very end we read the p.StandardOutput and p.StandardError file descriptors into the text box. See the complete code of the method that implements the whole stuff.
private
void start()
{
Process p = new Process();
StreamWriter sw;
StreamReader sr;
StreamReader err;
ProcessStartInfo psI = new ProcessStartInfo("cmd");
psI.UseShellExecute = false;
psI.RedirectStandardInput = true;
psI.RedirectStandardOutput = true;
psI.RedirectStandardError = true;
psI.CreateNoWindow = true;
p.StartInfo = psI;
p.Start();
sw = p.StandardInput;
sr = p.StandardOutput;
sw.AutoFlush = true;
if (tbComm.Text != "")
sw.WriteLine(tbComm.Text);
else
//execute default command
sw.WriteLine("dir \\");
sw.Close();
textBox1.Text = sr.ReadToEnd();
textBox1.Text += err.ReadToEnd();
} 
Sam HobbsPosted Jan 11, 2019, 1:52 PM
DOS is deprecated and current versions of Windows does not support it. There is no such thing as a DOS commands and DOS apps in current versions of Windows. I assume you mean command prompt or console window. Console windows might look like DOS windows but they are totally different internally (at the programmer level). DOS programs communicate with DOS using software interrupts (a machine instruction) and Windows programs usually use a DLL. DOS programs are capable of graphics but Windows console windows are incapable of graphics; Windows console windows never receive a WM_PAINT message from Windows.
Sam HobbsPosted Jan 11, 2019, 1:44 PM
Note that the Stackoverflow question "Best way to interact with Command Line application" has a link to here.
Sam HobbsPosted Jan 11, 2019, 1:43 PM
Initially I did not know what "above show" meant but then I realized you meant "shown above", correct?
abdelrhman ismailPosted Feb 17, 2010, 6:40 PM
when i write command cd.. it executed one time even if i typed more than one time