Design Patterns: Singleton
Tags: beginners, learning
Published: 2019-11-24 05:03:58

---
title: Design Patterns: Singleton
published: true
description: Explore design patterns starting with the Singleton pattern.
tags: beginner, learning
cover_image: https://thepracticaldev.s3.amazonaws.com/i/jmzaqt0wvh3m6yyvonwf.png
series: Design Patterns
---

Hey guys, thanks for being here! I've decided to start writing some posts as I review design patterns. Design patterns help provide a general and reusable solution to recurring software development problems. First, we're going to be taking a look at the Singleton pattern.

---

# Overview
+ [Definition](#definition)
+ [Implementation](#implementation)
+ [Real-World Examples](#realworldexamples)

---
# Definition <a name="definition"></a>
Singleton: a single person or thing of the kind under consideration. 
The Singleton design pattern is a creational design pattern. It refers to a class that has only one instance in existence at any given time. If we try to instantiate an instance of the Singleton class for a second time, the new variable also points to the first instance that was created earlier. 
Let's take a look at the implementation of this pattern and then talk about some problems it can help solve.

---
# Implementation <a name="implementation"></a>
To achieve the Singleton pattern, the class has two main characteristics:
1. The constructor is private.
2. There is a static method that returns the Singleton instance.

These characteristics allow us to first create an instance for the class if it has yet to be instantiated, and then return that instance whenever the class is called for.

Using C#, the pattern looks like this:
```csharp
using System;
					
public class Program
{
	public static void Main()
	{
		Singleton object1 = Singleton.Instance();
		Singleton object2 = Singleton.Instance();
		if (object1 == object2)
			Console.WriteLine("They're the same instance!");
	}
}

/// <summary>
/// The Singleton class.
/// </summary>
class Singleton
{
	private static Singleton myInstance;

    // 1. The constructor is private.
	private Singleton() { }

    // 2. Static method that returns the Singleton instance.
	public static Singleton Instance()
	{
  		if (myInstance == null)
			myInstance = new Singleton();
		
  		return myInstance;
	}
}
```
> In this case, the program would write the string "They're the same instance!".  You can play with this code here on [.NET Fiddle](https://dotnetfiddle.net/9AE0tO)

---
# Real-World Examples <a name="realworldexamples"></a>
Sweet, now we're able to write a class that will only have one instance in our program at a time! What can we do with that? What kind of recurring software development problems can this pattern help solve?

A Singleton pattern is especially useful when accessing some sort of resource that the entire application is making use of that may have issues when being accessed by more than one instance at a time (it helps solve concurrency issues). There are a lot of common development situations where this might be the case, like hardware interface access, and logging data to a file. 

In the case of hardware interface access, we may be connecting to hardware that will have concurrency issues when being accessed by multiple instances. For example, the Singleton pattern can help a printer print documents in a certain order, avoiding deadlock situations. In the case of logging data to a file, we may have multiple clients logging to a single file at the same time. The Singleton pattern can help prevent problems with concurrent access to this log file.

---
######Disclaimer: There are a lot of resources for learning design patterns, and they can be implemented in different ways. I would recommend exploring more resources when finished with this post.