Is the Singleton design pattern built into any frameworks?

Question

Using a Singleton class guarantees one instance of a class to give control to the programmer. Really useful.

I was wondering if for example a Singleton Interface existed in a given framework to bypass the need to create/add one explicitly?

Would be handy to decalre:

public sealed class MySingleton : ISingleton  //or a different class 
    { ... }

And then expect the class to only ever be instantiated once.

Is this a good idea, or am I thinking a bit off the mark? :)

Answer 1

Singleton does not prevent stack overflow, not sure what you are getting at with that.

For Java, what came to mind is Spring. By default, every Spring bean you write is a singleton. You can use it in 100 places, and they will all be set automagically via injection, and all 100 references will go to the same object (i.e. a singleton). When you set up a project in Spring, you can make any class you want a singleton just by following the conventions.

Answer 2

I was wondering if for example a Singleton Interface existed in a given framework to bypass the need to create/add one explicitly?

It doesn't and can't exist. A singleton basically requires a static Singleton getInstance() method, but because it's static, it cannot be definied as an abstract (interface) method. It also makes sense, there can be only one singleton implementation, not multiple. Abstracting it is pointless.

You'll need to boilerplate complete singletons yourself. I however highly question how that's useful. It's certainly not its sole purpose to prevent stackoverflow or memory errors. Writing good code prevents that. Singletons are only useful if you want to have the enduser to deal with the same instance all the time. Which can be done as good without the singleton pattern by the way. Either just declare it static or make use of the "application scope" concept the average framework can provide you.

Instead of singletons, rather look for inversion of control (dependeny injection). That's by the way also exactly what Spring is doing. They do not use "pure" singletons. It was a poor word choice they made.

See also:

• Singletons are evil
• Patterns I hate #1: Singleton
• Inversion of Control and Dependency Injection pattern
• A Spring Singleton is not a Singleton

Answer 3

The intention behind the singleton pattern is "Configure once. Use multiple times". This is typically used to share any kind of data or resources as mentioned in one of the answers above. But it is also useful to enable any kind of "management" application. (think JMX if it is Java)

You have one instance of a certain class that you can use multiple times. Since there is only one instance, by configuring that instance appropriately, you can reflect the configuration changes across the app. Hence the singleton pattern gives the ability to enable a "management dashboard" to your app.

Spring or Spring.NET (the .NET implementation of Spring) are useful for configuring and injecting singletons. The same arguments apply for any kind of dependency injection framework. You should read about dependency injection in general to harness the full power. A true singleton, across multiple JVMs or clusters, is usually harder to create and manage. and might require tool support. In practice, it is not necessary to create and maintain that.

Don't confuse singletons with statics! The construct looks similar but it can be pretty different. Now to drum my own trumpet! Here is a link to an article that I had written about static methods.

Answer 4

Google Guice is a dependency-injection framework that supports a @Singleton annotation.

Note that classes annotated with @Singleton aren't "true" singletons - there's nothing stopping client code from creating many instances of such a class. However, Guice-managed dependencies will all share the same instance.

See http://code.google.com/p/google-guice/wiki/Scopes

Answer 5

Maybe not what you're looking for, but here's my favorite version of the singleton pattern in C#. It's thread-safe, uses lazy instantiation, and doesn't require any locks. It's also pretty painless to write... no frameworks needed. ;)

class MyClass
{
  // ...
  #region Singleton pattern
  private MyClass() { }
  public static MyClass Instance { get { return Singleton.instance; } }
  class Singleton
  {
    static Singleton() { }
    internal static readonly MyClass instance = new MyClass();
  }
  #endregion
  // ...
}

To get the object instance:

MyClass m = MyClass.Instance;

Answer 6

In Java you can do this simply with an enumerated type. You specify the number of instances so that there can be none (also called a utility class), one (also called a singleton) or more as you choose.

public enum MySingleton {
    INSTANCE;
} 

Answer 7

.NET 4.0 has the Lazy(T) Class, which will lazily-initialize a value on first access, in a thread-safe manner. There are lots of examples at the Lazy Initialization topic.

Also, if you are using Unity, there is a lifetime manager which you can configure with the ContainerControlledLifetimeManager to ensure a single instance.

Answer 8

Ruby has a module called singleton that makes the class which includes it a singleton. This module is built into the standard library.