A Singleton should be inheritable or not?

2
votes


A Singleton should be inheritable or They should not be ?

According to Gof "when the sole instance should be extensible by subclassing, and clients should be able to use an extended instance without modifying their code."

but then why do i see Sealed and Private constructor examples on MSDN

2
c#design-patternsinheritancesingleton
what's your reason for using a singleton? Try not to. - Adrian
read singleton tag wiki. stackoverflow.com/tags/singleton/info - Jayy
@Adrian: Well i think if i don't Seal the singleton class a junior programmer might inherit it and may break the singleton pattern resulting in multiple instantiation of the childclass Singleton,That's why it should be Sealed. - Owais Qureshi
But then i see Gof "instance should be extensible by subclassing". - Owais Qureshi
"If you want to use inheritance in conjunction with the singleton pattern, you should put the inheritable state and behaviour into an abstract base class and define the singletons as (final) subclasses." taken from stackoverflow.com/questions/2573492/… - Owais Qureshi

2 Answers

2
votes

In my projects, I use an Ambient Context implementation from Mark Seemanns book Dependency Injection in .NET. The main point of use of that pattern is that always when you are asking for Current instance, there has to be something and also Context can be switched by other implementation. F.E.

public class TimeContext
{
    private static TimeContext _instance;

    public static TimeContext Current
    {
        get
        {
            if (_instance == null)
            {
                _instance = new DefaultContext();
            }
            return _instance;
        }
        set
        {
            if (value != null)
            {
                _instance = value;
            }
        }
    }
    public abstract DateTime GetDateTime();
}

And concrete implementation of context should be like:

public class DefaultContext : TimeContext
{
    public DateTime GetDateTime()
    {
        return DateTime.Now();
    }

}
2
votes

I think you're mixing two different things here. The singleton pattern calls for a single instance that is used by all callers. Inheritance just means I can share common logic between a class hierarchy. This, I feel, is an implementation of the singleton pattern: (ignore the lack of locking/thread safety, for the example's sake)

public class Singleton
{
    private static Singleton _instance;
    public static Singleton Instance
    {
         get 
         { 
            if (_instance == null)
            {
                 // This is the original code.
                 //_instance = new Singleton();

                 // This is newer code, after I extended Singleton with
                 // a better implementation.
                 _instance = new BetterSingleton();
            }
            return _instance;
         }
    }

    public virtual void ActualMethod() { // whatever }
}

public class BetterSingleton : Singleton
{
    public override void ActualMethod() { // newer implementation }
}

We still have a singleton, accessed through the Singleton class's static Instance member. But the exact identity of that instance can be extended through subclassing.