Question

I was researching on the singleton pattern for C# I found this example from the msdn website.

public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();

   private Singleton(){}

   public static Singleton Instance
   {
      get 
      {
         return instance; 
      }
   }
}

Because the Singleton instance is
referenced by a private static member
variable, the instantiation does not
occur until the class is first
referenced by a call to the Instance
property. This solution therefore
implements a form of the lazy
instantiation property, as in the
Design Patterns form of Singleton.

I am not pretty sure when will the memory will get allocated to

private static readonly Singleton instance 

1)Will it happen when the Instance property is called or even before it?

2) I need to force the class to create a new memory sometimes to purge its content. Is it safe to do so using set ?

set
{
instance = null;
}

Answer 1

In the example code you provided, the singleton instance will be created at the time of the first access to the class. This means for your example at the time when Instance gets called for the first time.

More insight you can find in Jon Skeet’s article Implementing the Singleton Pattern in C#, see Method 4.

Basically, in order to achieve truly lazy behaviour something like

public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();

    static Singleton(){}
    private Singleton(){}

    public static Singleton Instance
    {
        get { return instance; }
    }
}

is enough.

(But anyway, the full and much better overview can be found in the mentioned article.)

EDIT
Actually, as it follows from the mentioned article, the instance is not guaranteed to be created at the first access, because of BeforeFiledInit mark. You need to add an empty static constructor, this way it’s guaranteed to be lazy. Otherwise the instance will get created at some unspecified time between the program start and first access. (.NET runtime 2.0 is known to have more eager strategy, so you’ll probably not get the lazy behaviour.)

Quoting from the said article:

The laziness of type initializers is only guaranteed by .NET when the type isn’t marked with a special flag called beforefieldinit. Unfortunately, the C# compiler […] marks all types which don’t have a static constructor […] as beforefieldinit.

EDIT 2
If you want the singleton object to clean up, you should include this functionality into the class Singleton itself.

Removing the property value will effectively make your class not a singleton any more! Imagine that someone accesses the singleton and gets the singleton instance. After that you set the property to null. The existing object of the Singleton class won’t disappear, because there’s still a reference to it! So the next time you access the Instance property, yet another instance of the Singleton class would be created. So you lost two things: your object is not a singleton any more (because you have got 2 instances existing at the same time), and the memory hasn’t been cleared either.