Mahmoud Abas, Full-Stack Software Engineer & AI

Operating Systems 1 (2025-2026) - Operating Systems Lab - Week 5: Process Management in C#

In the print dialog, choose "Save as PDF" as the destination.

Operating Systems 1 - Week 05 Lab

Process Management in C#

Launching, inspecting and controlling external processes with System.Diagnostics, and capturing what they print back.

What Is a Process

A process: A running instance of a program. Launching an application is what makes the operating system create one for it.

Each process gets its own isolated memory space
And a unique Process ID, the PID
Plus its own resources: open files and network connections
And an execution state that the operating system tracks

Why Learn Process Management

Launch other applications from your own code: editors, browsers, a calculator
Monitor system processes, including their memory and CPU usage
Control a lifecycle: start it, stop it, wait for it to finish
Execute shell commands programmatically and automate system tasks
Real uses are monitoring tools, automated testing, deployment scripts and administration

Starting a Process

csharp

using System.Diagnostics;

Process.Start("xed");                  // launch a program
Process.Start("xed", "example.txt");   // launch and open a file

Every process API lives in System.Diagnostics, and the simple case is one line.

Process Properties

Property	What it holds
`ProcessName`	the process name, such as `notepad`
`Id`	the unique Process ID
`StartTime`	the date and time it started
`HasExited`	whether it is still running
`WorkingSet64`	memory usage in bytes

csharp

Process process = Process.Start("xed");
Console.WriteLine($"{process.ProcessName} (PID: {process.Id})");

Finding Processes

Process.GetProcesses returns every process running on the system
Process.GetCurrentProcess returns your own application's process
Process.GetProcessesByName returns all processes matching a name
Process.GetProcessById returns one by PID, throwing ArgumentException when it is gone

csharp

Process[] chromeProcesses = Process.GetProcessesByName("chrome");
Process me = Process.GetCurrentProcess();

Waiting with WaitForExit

csharp

Process process = Process.Start("xed");
bool exited = process.WaitForExit(5000);
Console.WriteLine(exited ? "Exited in time" : "Still running");

With no argument it blocks with no time limit. With one, it waits that many milliseconds and reports back.

Kill Compared With Close

Call	What actually happens
`Kill()`	terminates the process immediately, with no chance to clean up
`Close()`	releases your tracking of it, and the process keeps running

ProcessStartInfo for Fine Control

csharp

var startInfo = new ProcessStartInfo
{
    FileName = "xed",
    Arguments = "example.txt",
    WindowStyle = ProcessWindowStyle.Maximized
};
Process.Start(startInfo);

It also carries WorkingDirectory and CreateNoWindow
And the redirection switches: RedirectStandardOutput, RedirectStandardInput and RedirectStandardError

UseShellExecute Explained

Value	What you gain, and what you lose
`true`, the default	opens URLs and documents with their default program, but cannot redirect input or output
`false`	runs a program directly with redirection, but cannot open a URL

Opening a URL therefore needs true plus the URL itself as the FileName

Capturing Command Output

csharp

var startInfo = new ProcessStartInfo
{
    FileName = "/bin/bash",
    Arguments = "-c \"date\"",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    CreateNoWindow = true
};
Process process = Process.Start(startInfo);
string output = process.StandardOutput.ReadToEnd();
process.WaitForExit();

Read the stream to the end before waiting, or a full pipe buffer can deadlock the wait.

Cross-Platform Detection

csharp

using System.Runtime.InteropServices;

if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
    Console.WriteLine("Running on Linux");
}

Windows uses notepad.exe and cmd.exe with /c
Linux uses xed, nano or vim, and /bin/bash with -c

Best Practices

Wrap process operations in try-catch, because a missing executable throws
Check HasExited before reading properties of a process that may be gone
Detect the platform so one code path works on both systems
Never execute untrusted user input as a shell command

Key Takeaways

A process is an isolated running instance with its own PID, memory and resources
Start, GetProcesses, GetCurrentProcess, GetProcessesByName and GetProcessById cover launching and finding
WaitForExit waits, Kill terminates forcefully, and Close only stops tracking
ProcessStartInfo gives the fine control, and UseShellExecute is the switch between shell integration and redirection
Capturing output needs UseShellExecute = false together with RedirectStandardOutput = true
Cross-platform code branches on RuntimeInformation.IsOSPlatform

Open this lesson

Mahmoud AbasOperating Systems Lab - Week 5: Process Management in C#

Property

What it holds

ProcessName

the process name, such as notepad

Id

the unique Process ID

StartTime

the date and time it started

HasExited

whether it is still running

WorkingSet64

memory usage in bytes

Call

What actually happens

Kill()

terminates the process immediately, with no chance to clean up

Close()

releases your tracking of it, and the process keeps running

Value

What you gain, and what you lose

true, the default

opens URLs and documents with their default program, but cannot redirect input or output

false

runs a program directly with redirection, but cannot open a URL

var startInfo = new ProcessStartInfo { FileName = "/bin/bash", Arguments = "-c \"date\"", UseShellExecute = false, RedirectStandardOutput = true, CreateNoWindow = true }; Process process = Process.Start(startInfo); string output = process.StandardOutput.ReadToEnd(); process.WaitForExit();