about Singleton class

what about  WikiPedia[^] ?

You got it.

Singleton design pattern: Thread-safe Singleton[^]

FYI another one which is good too. Implementing the Singleton Pattern in C#[^]

Unfortunately, the sample in this article (I refer to advice of vivekse) is not thread-safe, but thread-safety is much more important for singletons than anywhere else.

Look at this article: http://www.dofactory.com/Patterns/PatternSingleton.aspx#_self1[^].

Locate the class Singleton and look at the "not thread safe" comment:

class Singleton {
   private static Singleton _instance;
   protected Singleton() { }
   public static Singleton Instance() {
         // Uses lazy initialization.
         // Note: this is not thread safe.
         if (_instance == null)
            _instance = new Singleton();
         return _instance;
   } //Instance
} //Singleton

It looks like this comment and its placement suggests that thread safety could be provided by locking of the method returning its instance (I will also improve usability by converting it to a property:

class Singleton { //the class better be non-static
   private static Singleton _instance;
   private static object SignletonLock = new object();
   protected Singleton() { }
   public static Singleton Instance() {
      get {   // Uses lazy initialization.
         // Note: this is not thread safe.
         if (_instance == null)
            lock(SignletonLock)
               _instance = new Singleton();
         return _instance;
      } //get Instance
   } //Instance
} //Singleton

Will it resolve the issue? Of course not!
In real life class Singleton is not such an empty class, it has to have members which might be accessed from different threads.
As this is a singleton, all threads will work with the same object, accessing same very members of the same instance in competition.

So, to make it thread safe, one need to make sure every shared resource in the singleton instance is interlocked. It will require one or more extra lock objects like SingletonLock.

Better yet, you may need to use System.Threading.ReaderWriterLockSlim instead of simple lock. This is important when threads often need read access to some singleton and much less need write (modification) access. This situation is quite typical, and ReaderWriterLockSlim deals with it with much better thoughput, because multiple threads can really allowed to read at the same time. Please see Microsoft help on System.Threading.ReaderWriterLockSlim complete with very clear code sample.