Design Pattern How-To: Singleton

The Singleton Design Pattern is one of the easiest design patterns to understand, and also one of the most useful in my opinion. When done correctly, the singleton pattern ensures that one and only one instance of a class is instantiated. In this post we will cover the singleton pattern, how to make it thread safe, and show a simple implementation. If you are new to design patterns, see my introductory post on the Factory pattern for an explanation.

The singleton pattern is a Creational Pattern that deals with how and when objects are created. They have many uses, and are often found as components in other design patterns. The pattern can be used when only one instance of an object is desired, either out of necessity or for performance reasons. For our example, we will create a class to store common data that can be safely accessed from any class on any thread. Please note that there are many ways to accomplish thread-safety, this post shows a simple, proven method.

Steps

1. Create a private field to store an instance of the class you wish to make a singleton.
2. Create a private static readonly object that will be our locking mechanism (lock statement).
3. Create a single private constructor so that other classes do not use the singleton incorrectly.
4. Create a public static property to access the private field we created in step 1.

That’s it. The key is in step 4. Again, there are many ways to ensure thread-safety, but for this example (and my preferred implementation) you lock a static object, check to see if the instance is instantiated, then return the instance.

Now you can add properties to store data.

Example Implementation

namespace SingletonExample
{
	/// <summary>
	/// Class to store common data. Implemented as a thread-safe Singleton.
	/// </summary>
	public sealed class CommonData
	{
		#region Fields

		private static CommonData _instance = null;
		private static readonly object _lock = new object();

		#endregion Fields

		#region Constructors

		/// <summary>
		/// Initializes a new instance of the <see cref="CommonData"/> class.
		///
		/// A single private constructor to keep other classes from incorrectly
		/// instantiating this class.
		/// </summary>
		private CommonData() { }

		#endregion Constructors

		#region Properties

		/// <summary>
		/// Gets the current instance of this class.
		/// </summary>
		/// <value>The current instance of this class.</value>
		public static CommonData Current
		{
			get
			{
				lock (_lock)
				{
					if (_instance == null)
					{
						_instance = new CommonData();
					}

					return _instance;
				}
			}
		}

		/// <summary>
		/// Gets or sets the user ID.
		/// </summary>
		/// <value>The user ID.</value>
		public string UserID { get; set; }

		/// <summary>
		/// Gets or sets the first name.
		/// </summary>
		/// <value>The first name.</value>
		public string FirstName { get; set; }

		/// <summary>
		/// Gets or sets the last name.
		/// </summary>
		/// <value>The last name.</value>
		public string LastName { get; set; }

		#endregion Properties
	}
}

Using the Singleton

CommonData.Current.UserID = "test";
CommonData.Current.FirstName = "Brandon";
CommonData.Current.LastName = "Zeider";

Download

SingletonExample.zip (51.62 kb)

This work is licensed under a Creative Commons Attribution 3.0 Unported License.