C# 4 and .NET 4

synchronization ❘ 517
}
lock (this)
{
// only one thread at a time can access the DoThis and DoThat methods
}
}
public void DoThat()
{
lock (this)
{
}
}
However, because the object of the instance can also be used for synchronized access from the outside, and
you can’t control this from the class itself, you can apply the SyncRoot pattern. With the SyncRoot pattern,
a private object named syncRoot is created, and this object is used with the lock statements:
public class Demo
{
private object syncRoot = new object();
}
public void DoThis()
{
lock (syncRoot)
{
// only one thread at a time can access the DoThis and DoThat methods
}
}
public void DoThat()
{
lock (syncRoot)
{
}
}
Using locks costs time and is not always needed. You can create two versions of a class: a synchronized and
a nonsynchronized version. This is demonstrated here by changing the class Demo. The class Demo itself is
not synchronized, as you can see in the implementation of the DoThis() and DoThat() methods. The class
also defines the IsSynchronized property, where the client can get information about the synchronization
option of the class. To make a synchronized variant of the class, the static method Synchronized() can
be used to pass a nonsynchronized object, and this method returns an object of type SynchronizedDemo.
SynchronizedDemo is implemented as an inner class that is derived from the base class Demo and overrides
the virtual members of the base class. The overridden members make use of the SyncRoot pattern.
public class Demo
{
private class SynchronizedDemo: Demo
{
private object syncRoot = new object();
private Demo d;
public SynchronizedDemo(Demo d)
{
this.d = d;
}
public override bool IsSynchronized
{
get { return true; }
}
www.it-ebooks.info