C# 4 and .NET 4

summary ❘ 543
comp.LongTaskAsync("input", 33);
}
Console.ReadLine();
static void Comp_LongTaskCompleted(object sender,
LongTaskCompletedEventArgs e)
{
Console.WriteLine("completed, result: {0}, thread: {1}", e.Output,
Thread.CurrentThread.ManagedThreadId);
}
code snippet AsyncComponent/Program.cs
With a Windows Forms application the SynchronizationContext is set to
WindowsFormsSynchronizationContext — that’s why the event handler code is invoked in the
same thread:
WindowsFormsSynchronizationContext syncContext =
new WindowsFormsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncContext);
summary
This chapter explored how to code applications that use multiple threads using the System.Threading
namespace and multiple tasks using the System.Threading.Tasks namespace. Using multithreading in
your applications takes careful planning. Too many threads can cause resource issues, and not enough
threads can cause your application to seem sluggish and to perform poorly. With tasks, you get an
abstraction to threads. This abstraction helps you not to create too many threads because threads are
reused from a pool.
You’ve seen various ways to create multiple threads such as using the delegate, timers, a ThreadPool, and
the Thread class. Various synchronization techniques have been explored, such as a simple lock statement,
as well as the Monitor, Semaphore, and Event classes. You’ve seen how to program the asynchronous
pattern with the IAsyncResult interface and the event-based asynchronous pattern.
The System.Threading namespace in the .NET Framework gives you multiple ways to manipulate threads;
however, this does not mean that the .NET Framework handles all the difficult tasks of multithreading
for you. You need to consider thread priority and synchronization issues. This chapter discussed these
issues and how to code for them in your C# applications. It also looked at the problems associated with
deadlocks and race conditions.
Just remember that if you are going to use multithreading in your C# applications, careful planning needs to
be a major part of your efforts.
Here are some final guidelines regarding threading:
➤
➤
➤
Try to keep synchronization requirements to a minimum. Synchronization is complex and blocks
threads. You can avoid it if you try to avoid sharing state. Of course, this is not always possible.
Static members of a class should be thread-safe. Usually, this is the case with classes in the .NET
Framework.
Instance state does not need to be thread-safe. For best performance, synchronization is better used
outside of the class where it is needed, and not with every member of the class. Instance members of
.NET Framework classes usually are not thread-safe. In the MSDN library, you can find this information
documented for every class of the Framework in the Thread Safety section.
The next chapter gives information on another core .NET topic: security.
www.it-ebooks.info