Introduction
This article provides a simple example of how to use the System.Diagnostics.Process library to display a list of running processes, and to select and kill processes by their process name and ID. It would not be a major trick to display additional information about the process using the same library or to kill processes by their ID or name alone rather than their name and ID but in this example, process names and IDs are used for display purposes and the purpose of killing a running process.
Figure 1: Listing and Killing Processes by Process Name and ID
Getting Started
There is a single solution included with this download, the solution contains a Win Forms project called "ProcessKiller"; this project contains one form (Form1.cs) and all of the code required to display and kill processes is contained within that single form class. If you open the attached project into Visual Studio 2008; you should see the following in the solution explorer:
Figure 2: Solution Explorer
Code: The Main Form
The main form contains all of the user interface elements necessary to display and update the list of currently running processes found on the user's machine. It also contains a button handler which will kill a process by the process name. You can also kill a process by its ID but in terms of readability, if the user is selecting the process, the process name is going to make a lot more sense to them than will the process ID.
The class begins with the normal and default imports:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
The constructor calls a method called "UpdateProcessList" which is used to get and display a list of running processes; it will be described shortly.
namespace ProcessKiller
{
public partial class frmProcessKiller : Form
{
/// <summary>
/// constructor
/// </summary>
public frmProcessKiller()
{
InitializeComponent();
// get an initial list of processes
UpdateProcessList();
}
The next bit of code is the UpdateProcessList function; this function clears the listbox of any existing entries and then loops through each of the current processes, adding the name and ID of each process to the list (as Process Name – ID). At the end of the function, a status message is updated to display the current number of found processes.
/// <summary>
/// Loop through the list of running processes
/// and add each process name to the process
/// listbox
/// </summary>
private void UpdateProcessList()
{
// clear the existing list of any items
lstProcesses.Items.Clear();
// loop through the running processes and add
//each to the list
foreach (System.Diagnostics.Process p in
System.Diagnostics.Process.GetProcesses())
{
lstProcesses.Items.Add(p.ProcessName + " - " + p.Id);
}
// display the number of running processes in
// a status message at the bottom of the page
tslProcessCount.Text = "Processes running: " +
lstProcesses.Items.Count.ToString();
}
The next bit of code in the application is the update button's click event handler; all it does is to call the UpdateProcessList function to update the contents of the listbox.
/// <summary>
/// Manually update the contents of the process
/// listbox
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnUpdateProcessList_Click(object sender, EventArgs e)
{
UpdateProcessList();
}
The last bit of the code in the application is used to kill a running process. Since you can have multiple processes with the same name, it was necessary to add in the ID along with the name in order to make some distinction between multiple instances of a single application, else, we would end up killing all running instances of the application which may or may not be desirable depending upon what you are doing. If you do want to kill off all running instances of an application, disregard the ID and kill all running processes with the same process name.
In the kill button click event handler; we again loop through all of the running processes and we take the selected item from the process/ID list, and parse it into a string containing the process name and an integer value containing the ID. If the current process (in the loop) matches on both the process name and process ID, the process is killed. At the end, the handler calls the update method used to repopulate the listbox such that is displays the current list of active processes and their IDs.
/// <summary>
/// Kill the process selected in the process name
/// and ID listbox
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnKill_Click(object sender, EventArgs e)
{
// loop through the running processes looking for a match
// by comparing process name to the name selected in the listbox
foreach (System.Diagnostics.Process p in
System.Diagnostics.Process.GetProcesses())
{
string[] arr = lstProcesses.SelectedItem.ToString().Split('-');
string sProcess = arr[0].Trim();
int iId = Convert.ToInt32(arr[1].Trim());
if (p.ProcessName == sProcess && p.Id == iId)
{
p.Kill();
}
}
// update the list to show the killed process
// has been removed
UpdateProcessList();
}
That concludes the description of all of the code used in this example.
Summary
The article shows one approach that may be used to display a list of current processes, and to single out and kill a single process based upon both the process name and its ID. One could also kill all instances of a particular process by killing all processes that match on name without giving any consideration to the process ID. The approach shown allows for singling out specific instances of a process and killing it without taking down all other matching processes.