public class TheKing
 {
   static TheKing Elvis = new TheKing();

   private TheKing()
   {
     // You don't want clients to create
     // their own King instance
   }


   public static TheKing TheOneAndOnly()
   {
     return Elvis;
   }
 }

 public class TheKing
 {
   static TheKing Elvis;

   private TheKing() {}

   public static TheKing TheOneAndOnly()
   {
     lock (typeof(TheKing))
     {
       if (null == Elvis)
         Elvis = new TheKing();
       return Elvis;
     }
   }
 }

 public static TheKing TheOneAndOnly()
 {
   if (null == Elvis)
   {  
     lock(typeof(TheKing))
     {
       if ( null==Elvis)
       {   // double check
         Elvis = new TheKing();
         System.Threading.Thread.MemoryBarrier();
       }
     }
   }
   return Elvis;
 }

 class Program
 {
   [STAThread]
   static void Main()
   {
     FileStream fs = new FileStream("DataFile.dat", FileMode.Create);
     try
     {
       // Construct a BinaryFormatter and use it
       // to serialize the data to the stream.
       BinaryFormatter formatter = new BinaryFormatter();
       // Create an array with multiple elements refering to
       // the one Singleton object.
       TheKing[] a1 = { TheKing.TheOneAndOnly(), TheKing.TheOneAndOnly() };
       // This displays "True".
       Console.WriteLine(
         "There is only one king " +
         (a1[0] == a1[1]));    
      
       // Serialize the array elements.
       formatter.Serialize(fs, a1);

       // Deserialize the array elements.
       fs.Position = 0;
       TheKing[] a2 = (TheKing[]) formatter.Deserialize(fs);

       // You'd expect this to print "True"
       // but it displays "False".
       Console.WriteLine(
         "There is only one king? " +
         (a2[0] == a1[0]));

       Console.WriteLine("Press Any Key to Continue");
       Console.ReadLine();
     }  
     catch (SerializationException e)
     {
       Console.WriteLine("Failed to serialize. Reason: " + e.Message);
       throw;
     }
     finally
     {
       fs.Close();
     }
   }
 }

 [Serializable]
 // time to fix serializable bug

 public class TheKing : ISerializable
 {
   static TheKing Elvis;
   private TheKing() {}

 
   public static TheKing TheOneAndOnly()
   {
     if (null == Elvis)
     {  
       lock(typeof(TheKing))
       {
         if ( null==Elvis)
         { // double check
           Elvis = new TheKing();
           // On the X86 write orderings are guaranteed
           // so the following is not needed
           System.Threading.Thread.MemoryBarrier();
         }
       }
     }
     return Elvis;
   }

   // A method called when serializing a Singleton.
   void ISerializable.GetObjectData(
      SerializationInfo info, StreamingContext context)
   {
     // Instead of serializing this object,
     // serialize an ElvisHelper instead.
     info.SetType(typeof(ElvisHelper));
     // No other values need to be added.
   }
 }

 [Serializable]
 internal sealed class ElvisHelper : IObjectReference
 {
   // This object has no fields (although it could).
   // GetRealObject is called after this object is deserialized.
   public Object GetRealObject(StreamingContext context)
   {
     // When deserialiing this object, return a reference to
     // the King instead.
     return TheKing.TheOneAndOnly();
   }
 }