Skip to main content

Singleton

The Singleton design pattern seems generally frowned upon, except for use in logging classes.  Below are several variants of the Singleton design pattern, of which, only the thread-safe version merits attention:


Salient Chacteristic(s)

  • A private constructor
  • Static variable for self-tracking
Three (3) variants
  • Eager
  • Lazy
  • Thread-safe (Double-checked Locking)

Code


namespace DesignPatterns
{

    //double-checked locking singleton
    //required for threaded environments
    public class DoubleCheckingSingleton
    {
        private static volatile DoubleCheckingSingleton _Instance = null;
        private static object _SyncRoot = new object();
    
        //Private constructor prevents instantiation from other classes
        private DoubleCheckingSingleton()
        {
            //class contruction
        }
        
        public static DoubleCheckingSingleton Instance
        {
            get
            {
                if (_Instance == null)
                {
                    lock (_SyncRoot)
                    {
                        if (_Instance == null)
                        {
                            _Instance = new DoubleCheckingSingleton();
                        }
                    }
                }
                return _Instance;
            }   
        }
    }

    //lazy initialization of singleton
    public class LazySingleton 
    {
        private static LazySingleton _Instance = null;
    
        // Private constructor prevents instantiation from other classes
        private LazySingleton() 
        {
            //class contruction
        }


        public LazySingleton getInstance() 
        {
            if (_Instance == null)
            {
                _Instance = new LazySingleton();
            }
            else
            {
                return _Instance;
            }
            return _Instance;
        }
    }


    //eager initialization of singleton
    public class EagerSingleton
    {
        private static EagerSingleton _Instance = new EagerSingleton();

        // Private constructor prevents instantiation from other classes
        private EagerSingleton()
        {
            //class contruction
        }

        public EagerSingleton getInstance()
        {
            return _Instance;
        }
    }
}

Popular posts from this blog

Multiton

A fairly simple example of the multiton pattern, with a private constructor, and a tracker for created objects, the name being an integer identifier.

Salient Chacteristic(s)
A private keyed list for tracking objectsA private constructorNamed objectsCode

using System.Collections.Generic;
using System.Linq;

namespace DesignPatterns
{
    public class Multiton
    {
        //read-only dictionary to track multitons
        private static IDictionary<int, Multiton> _Tracker = new Dictionary<int, Multiton> { };

        private Multiton()
        {
        }

        public static Multiton GetInstance(int key)
        {
            //value to return
            Multiton item = null;

            //lock collection to prevent changes during operation
            lock (_Tracker)
            { 
                //if value not found, create and add
                if(!_Tracker.TryGetValue(key, out item))
                {
                    item = new Multiton();

                    //calculate next key
       …

Decorator Pattern

This is an example of the Decorator pattern, in this case a decorator for ObservableCollection.  Working with WPF and ObservableCollection using threads, one will run into the problem whereby the ObservableCollection cannot be updated from outside the owning thread; Delegates and Invoke will not work. A solution is to contain and expand the class, as is done in this example on michIG's Blog.

This linked file contains the original code in C#, as well as the same code converted to VB.NET.

Salient Characteristic(s)
Sets an internal pointer to the decorated object, sending method calls and property actions to the internal objectExtends the object by wrapping it and adding some aspect handled by the decorator
Code

using System;
using System.Collections.ObjectModel;
using System.Windows.Threading;
using System.Collections.Specialized;
using System.ComponentModel;

namespace DesignPatterns
{
    /// <summary>  
    /// This class is an observablecollection which invokes automatically.  
    /// T…