Namespace: System.Threading
Asynchronous programming is simply allowing some portion of
code to be executed on separate threads. Many .Net Framework classes support
APM with methods like BeginXXX and EndXXX.
FileStream FS = new
Filestream(Filename, FileMode.Open, FileAccess.Read, FileShare.Read, 1024,
FileOptions.Asynchronous);
IAsyncResult vResult =
FS.BeginRead(buffer, 0 , Buffer.length, null, null);
//Do your work
int NoOfBytes = FS.EndRead(vResult);
FS.Close();
This type of APM is 1. Rendezvous
Wait-Until-Done model.
2. Rendezvous Polling Model:
Keeping doing some other work along with checking whether the
APM work is completed or not.
IAsyncResult vResult =
FS.BeginRead(buffer, 0 , Buffer.length, null, null);
While ( ! vResult.IsCompleted )
{
//Do your work
}
int NoOfBytes = FS.EndRead(vResult);
FS.Close();
3. Callback Model:
Register
a callback to notify you about the APM work ended.
IAsyncResult vResult = FS.BeginRead( buffer, 0 , Buffer.length,
new AsyncCallback
( ReadCompleted),
FS);
static void CompletedRead(IASyncResult
V)
{
FileStream
FS = (FileStream) v.SyncState;
Int
NoOfBytes = FS.EndRead();
FS.Close();
}
Exception Handling:
All exceptions are hold downed and
thrown when End method of APM is called. So wrap EndXXX calls in
try/catch block.
Application.ThreadException
can be assigned an event handler to handle exceptions at application level.
Using ThreadPool:
ThreadPool class maintains some
minimum no. of Threads to do work. One can queue his own work item. One can
also set minimum and maximum no. of thread using SetMinThreads
and SetMaxThreads.
ThreadPool static methods are:
GetAvailableThreads(# no of
Threads), GetMaxThreads, GetMinThreads, QueueUserWorkItem,
RegisterWaitForSingleObject, SetMinThreads, SetMaxThreads,
UnsafeQueueNativeOverlapped, UnsafeQueueUserWorkItem, UnsafeRegisterWitForSingleObject.
Unsafe methods do not propagate execution context info thus provide performance
on cost of security.
WaitHandle and ThreadPool:
If we want to queue work item and we want that until a Mutex/Semaphore
is not available. The work should not get started.
Mutex m = new Mutex (true);
ThreadPool.RegisterWaitForSingleObject(M,
new WaitOrTimerCallback(MyWorkItem), null, Timeout.Infite, true);
m.ReleaseMutex(); //Now Work will
start
The Synchronization Context:
It provides a middle way to resolve difference between
threading model of windows application and Web Application. One can call:
SynchronizationContext.Send(RunMe,
“Hello”);
OR
SynchronizationContext.Post(RunMe,
“Hello”);
Post returns immediately but Send does not.
Timers: (System.Threading.Timer)
Timers call a method after specified time defined by TimerCallback delegate.
Timer tm = new Timer ( new
TimerCallback(TimerTick), null, 0, 1000);
Static void TimerTick(object state)
{
Console.WriteLine(“Tick
Tick…”);
}
On can also call Timer(tm).Change to specify when timer start
firing and Timer(tm).Change(Timeout.Infinite, 1000) to stop timer.
Other timer classes are
System.Windows.Forms.Timer
And
System.Timers.Timer.
Comments