Singleton Pattern for C# [closed]

Answer 1

So, as far as I am concerned, this is the most concise and simple implementation of the Singleton pattern in C#.

http://blueonionsoftware.com/blog.aspx?p=c6e72c38-2839-4696-990a-3fbf9b2b0ba4

I would, however, suggest that singletons are really ugly patterns... I consider them to be an anti-pattern.

http://blogs.msdn.com/scottdensmore/archive/2004/05/25/140827.aspx

For me, I prefer to have something like a Repository, implementing IRepository. Your class can declare the dependency to IRepository in the constructor and it can be passed in using Dependency Injection or one of these methods:

http://houseofbilz.com/archive/2009/05/02.aspx

Answer 2

Using C# 6 Auto-Property Initializers.

public sealed class Singleton
{
    private Singleton() { }
    public static Singleton Instance { get; } = new Singleton();
}

Short and clean - I'll be happy to hear the downsides.

Answer 3

A Singleton isn't just a static class that can't be inherited. It's a regular class that can be instantiated only once, with everybody sharing that single instance (and making it thread safe is even more work).

The typical .NET code for a Singleton looks something like the following. This is a quick example, and not by any means the best implementation or thread-safe code:

public sealed class Singleton
{
    Singleton _instance = null;

    public Singleton Instance
    {
        get
        {
            if(_instance == null)
                _instance = new Singleton();

            return _instance;
        }
    }

    // Default private constructor so only we can instanctiate
    private Singleton() { }

    // Default private static constructor
    private static Singleton() { }
}

If you're going to go down the path you're thinking, a static sealed class will work just fine.

Answer 4

Use your language features. Mostly simple thread-safe implementation is:

public sealed class Singleton
{
    private static readonly Singleton _instance;

    private Singleton() { }

    static Singleton()
    {
        _instance = new Singleton();
    }

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

Answer 5

...what would be the very simplest singleton class?

Just to add one more possible solution. The simplest, most straight forward and easy to use approach I can think of would be something like this:

//The abstract singleton
public abstract class Singleton<T> where T : class
{
    private static readonly Lazy<T> instance = new Lazy<T>( CreateInstance, true );

    public static T Instance => instance.Value;

    private static T CreateInstance()
    {
        return (T)Activator.CreateInstance( typeof(T), true);
    }
}

//This is the usage for any class, that should be a singleton
public class MyClass : Singleton<MyClass>
{
    private MyClass()
    {
        //Code...
    }

    //Code...
}

//Example usage of the Singleton
class Program
{
    static void Main(string[] args)
    {
        MyClass clazz = MyClass.Instance;
    }
}

Answer 6

There are several Patterns which might be appropriate for you, a singleton is one of the worse.

Registry

struct Data {
  public String ProgramName;
  public String Parameters;
}

class FooRegistry {
  private static Dictionary<String, Data> registry = new Dictionary<String, Data>();
  public static void Register(String key, Data data) {
     FooRegistry.registry[key] = data;
  }
  public static void Get(String key) {
     // Omitted: Check if key exists
     return FooRegistry.registry[key];
  }
}

Advantages

• Easy to switch to a Mock Object for automated testing
• You can still store multiple instances but if necessary you have only one instance.

Disadvantages

• Slightly slower than a Singleton or a global Variable

Static Class

class GlobalStuff {
  public static String ProgramName {get;set;}
  public static String Parameters {get;set;}
  private GlobalStuff() {}
}

Advantages

• Simple
• Fast

Disadvantages

• Hard to switch dynamically to i.e. a Mock Object
• Hard to switch to another object type if requirements change

Simple Singleton

class DataSingleton {
  private static DataSingleton instance = null;
  private DataSingleton() {}
  public static DataSingleton Instance {
     get {
         if (DataSingleton.instance == null) DataSingleton.instance = new DataSingleton();
         return DataSingleton;
     }
  }
}

Advantages

• None really

Disadvantages

• Hard to create a threadsafe singleton, the above Version will fail if multiple threads access the instance.
• Hard to switch for a mock object

Personally I like the Registry Pattern but YMMV.

You should take a look at Dependency Injection as it's usually considered the best practice but it's too big a topic to explain here:

Dependency Injection