Introduction
In this article I m going to describe the
basics of thread and process which improve your basic knowledge about process
and thread.
What is a process?
A process is a program that is running on your computer. This can
be anything from a small background task, such as a spell-checker or system
events handler to a full-blown application like Internet Explorer or Microsoft
Word. Every process have at least
one thread.
A computer program is a ive collection of instructions; a process is the
actual execution of those instructions. Several processes may be associated with
the same program; for example, opening up several instances of the same program
often means more than one process is being executed.
How To: Starting Processes From C#
The System.Diagnostics namespace contains functions that allow you to
manage processes, threads, eventlogs and performance information.
The Process class is part of the System.Diagnostics namespace.
A C# program can launch another program using the
process class.You
start another program by instantiating a Process object, setting members of it's
StartInfo property, and invoking it's Start() method.
Add this line to your using list:
using
System.Diagnostics;
Example 1
using
System;
using
System.Diagnostics;
namespace
Csharpcornerhow_to_use
{
class
csharpcorner
{
static void
Main(string[] args)
{
Process notepad =
new Process();
notepad.StartInfo.FileName = "notepad.exe";
notepad.StartInfo.Arguments = "csharpcorner.cs";
notepad.Start();
Console.Read();
}
}
}
When we run this program, this will open a notepad window with editing mode on the csharpcorner.cs file. The program does instantiate a Process object called notePad
Process notepad =
new Process();
In this next step, we give that what program will be run. This happens to give the
program name to the FileName member of the notePad Process object's StartInfo
property. here we give code for it.
notepad.StartInfo.FileName = "notepad.exe";
The StartInfo property have a ability to take argument, which is used to know command-line options that are give to the program. In the following
example, the string csharpcorner.cs is ed as an argument, so the notepad
application will know what file to open when it is executed:
notepad.StartInfo.Arguments = "csharpcorner.cs";
The program is then executed by invoking the Start() method, as shown here:
notepad.Start();
The results of this program are the same as if the instructions below were typed
on the command-line:
C:>notepad csharpcorner.cs
Example 2 Web browser example
You can specify the URL and send it to Windows. Here we launch a
Google search for some search terms, such as "http://www.c-sharpcorner.com/".
Your users might run Firefox, Google Chrome, Internet Explorer, Opera, or Safari
on Windows. Call the following code with SearchGoogle("http://www.c-sharpcorner.com/");
using
System;
using
System.Diagnostics:
namespace
Csharpcornerhome
{
class
Csharpcorner
{
static void
SearchGoogle(string t)
{
Process.Start("http://google.com/search?q="
+ t);
}
static void
Main(string[] args)
{
// Search Google for this.
SearchGoogle("http://www.c-sharpcorner.com/");
}
}
}
What is
thread?
A single thread in a C#
application, is an independent execution path that can run simultaneously with
the main application thread. A C# client program (Console, WPF, or Windows
Forms) starts in a single thread created automatically by the CLR and operating
system (the "main" thread), and is made multithreaded by creating additional
threads.
Threading enables your C# program to perform
concurrent processing so you can do more than one operation at a time. For
example, you can use threading to monitor input from the user, perform
background tasks, and handle simultaneous streams of input. The
System.Threading namespace provides classes and interfaces that support
multithreaded programming and enable you to easily perform tasks such as
creating and starting new threads, synchronizing multiple threads, suspending
threads, and aborting threads.
Creating Threads
Creating a thread in C# is close to simple, but
not quite. The only difficult thing about creating a thread is dotNet
delegate-classes. Let me explain in few words what is a delegate class. The
delegate is a wrapper around a code construct in the dotNet. The code construct
could be an object instance, an instance method or a static method. Delegates
are used when you want to one of the three code constructs as a parameter
to another method.
The .NET framework has thread-associated
classes in the System.Threading
namespace. The following steps demonstrate how to create a thread in
C#.
Step 1:
using
System.Threading namespace to
include classes and interface that support threading.
Step 2: When we create a new thread we
have to use the ThreadStart delegate class to wrap the nstance method that will
be executed in the newly created thread. The instance method must return void
and must not have any parameters.
public
void ThreadJob()
Step 3: To create a new thread, first
create a new ThreadStart object, ing the instance method of the thread
procedure in the constructor. The new delegate object is then ed to the
constructor of the Thread.
Thread thread =
new Thread(new
ThreadStart(obj.ThreadStart));
Step 4: You've now created a new thread,
but the thread is not yet started. To start the thread, you call the
Thread.Start instance method.
Thread.start();
And that's it. You have a new running thread. A
complete console application that creates a thread and outputs a couple messages
to the console window as following.
using
System;
using
System.Threading;
|namespace
bestCsharpcorner
{
class
Csharpcorner
{
public void
ThreadJob()
{
for (int
i = 0; i < 10; i++)
{
Console.WriteLine("i
m other thread : {0}", i);
Thread.Sleep(500);
}
}
static void
Main(string[] args)
{
Csharpcorner c=new
Csharpcorner();
ThreadStart job =
new Thread(new
ThreadStart(c.ThreadJob));
Thread.Start();
for (int
i = 0; i < 5; i++)
{
Console.WriteLine("C#corner
is one of the best website for technology seekers: {0}", i);
Thread.Sleep(1000);
}
Console.Read();
}
}
}
The code creates a new thread which runs the
ThreadJob method, and starts it. That thread counts from 0 to 9 fairly fast
(about twice a second) while the main thread counts from 0 to 4 fairly slowly
(about once a second). The way they count at different speeds is by each of them
including a call to Thread.Sleep, which just makes the current thread sleep (do
nothing) for the specified period of time. Between each count in the main thread
we sleep for 1000ms, and between each count in the other thread we sleep for
500ms. Here are the results from one test run on my machine:
Advantage of
threads
One of the advantages of using the threads is that
you can have multiple activities happening simultaneously. Another advantage is
that a developer can make use of threads to achieve faster computations by doing
two different computations in two threads instead of serially one after the
other.