Software Dev/02 - Singleton.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Singleton\n",
    "\n",
    "## General idea\n",
    "The Singleton pattern is a creational design pattern that ensures a class has only one instance and provides a global point of access to that instance. It is often used in situations where there should be exactly one instance of a class, such as a configuration manager, database connection pool, or logging system.\n",
    "\n",
    "## Benefits\n",
    "The Singleton pattern offers several benefits and use cases:\n",
    "\n",
    "- Single Instance: It ensures that there is only one instance of the class throughout the application. This can be useful when there should be a single point of control or access to a particular resource.\n",
    "\n",
    "- Global Access: The Singleton instance can be accessed globally from any part of the application. This eliminates the need to pass instances between objects or manage global state explicitly.\n",
    "\n",
    "- Resource Management: Singletons can be used to manage and control access to shared resources, such as database connections, file systems, or thread pools. They can help centralize and optimize the usage of these resources.\n",
    "\n",
    "- Configuration Settings: Singleton patterns are commonly used for managing application-wide configuration settings. The instance can hold and provide access to these settings, ensuring consistency throughout the application.\n",
    "\n",
    "- Easy Testing: Singleton instances can be replaced or mocked during testing, allowing for easier unit testing of other components that depend on the Singleton.\n",
    "\n",
    "> However, it's important to note that the Singleton pattern should be used with caution. While it can provide benefits, it can also introduce dependencies and global state, which may make code harder to test, maintain, and reason about. Overuse of the Singleton pattern can lead to tight coupling and hinder flexibility and extensibility. It's crucial to carefully consider the specific requirements and potential drawbacks before applying the Singleton pattern in a design.\n",
    "\n",
    "## How it works\n",
    "- Private Constructor: The class's constructor is made private to prevent direct instantiation of the class from outside. This means that other classes cannot create instances of the Singleton class using the \"new\" keyword.\n",
    "\n",
    "- Static Instance: The class provides a static method that returns the single instance of the class. This method is typically named `getInstance()` or just `Instance()` and is responsible for creating the instance if it doesn't exist or returning the existing instance. In C#, you can just use a \"property\" called `Instance` (that will have a `get` method only).\n",
    "\n",
    "- Lazy Initialization: The Singleton instance is created only when the `Instance()` method is called for the first time. Subsequent calls to this method return the already created instance.\n",
    "\n",
    "- Thread Safety: If multiple threads can access the `Instance()` method simultaneously, additional synchronization mechanisms are implemented to ensure thread safety. This prevents the possibility of multiple instances being created in a multi-threaded environment.\n",
    "\n",
    "> Note: the last one (thread safety) it is only needed if you are using a multi-threaded environment. If you are not, you can skip that step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Example of implementation of singleton pattern in C#, in a single-thread environment\n",
    "\n",
    "// Singleton class is declared as sealed to prevent inheritance\n",
    "public sealed class Singleton\n",
    "{\n",
    "    // Private constructor to prevent instantiation outside the class\n",
    "    private Singleton() { }\n",
    "\n",
    "    // Private member, the singleton intance is static\n",
    "    private static Singleton instance = null;\n",
    "\n",
    "    // Public property (only get) to access the singleton instance\n",
    "    public static Singleton Instance\n",
    "    {\n",
    "        get\n",
    "        {\n",
    "            // Lazy-loading the singleton instance\n",
    "            // If you don't need this, just remove the if statement, and make the instance attribute readonly\n",
    "            if (instance == null) instance = new Singleton();\n",
    "            return instance;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    // Other members and methods of the singleton class\n",
    "    public void PrintMessage(string message)\n",
    "    {\n",
    "        Console.WriteLine($\"Singleton says: {message}\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Client (Test class where the singleton instance is accessed)\n",
    "public class Client\n",
    "{\n",
    "    public void Code()\n",
    "    {\n",
    "        // Singleton singleton0 = new Singleton(); // Error\n",
    "\n",
    "        // singleton1 and singleton2 are the same instance\n",
    "        Singleton singleton1 = Singleton.Instance;\n",
    "        Singleton singleton2 = Singleton.Instance;\n",
    "        \n",
    "        // Perform your operations on the Singleton instance here\n",
    "        singleton1.PrintMessage(\"Hello desgin patterns!\");\n",
    "        singleton2.PrintMessage(\"I'm the same instance!\");\n",
    "\n",
    "        // Test if they are the same instance\n",
    "        Console.WriteLine(singleton1 == singleton2); // Output: True\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to implement a singleton in a multi-threading context, it is recommended to add a synchronization mechanism for thread safety. A simple way to do this is to use the `lock` keyword to ensure that only one thread can access the `Instance()` method at a time. This will prevent multiple threads from creating multiple instances of the Singleton class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Example of implementation of singleton pattern in C#, in a multi-thread environment\n",
    "\n",
    "// A big part of the implementation remains the same.\n",
    "// But we need to add a lock to prevent multiple threads from creating multiple instances\n",
    "public sealed class Singleton\n",
    "{\n",
    "    private static Singleton instance = null;\n",
    "    private static readonly object padlock = new object();\n",
    "\n",
    "    private Singleton() { }\n",
    "\n",
    "    public static Singleton Instance\n",
    "    {\n",
    "        get\n",
    "        {\n",
    "            // Null double-checking\n",
    "            if (instance == null)\n",
    "            {\n",
    "                lock (padlock)\n",
    "                {\n",
    "                    if (instance == null) instance = new Singleton();\n",
    "                }\n",
    "            }\n",
    "            return instance;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    // Other members and methods of the singleton class\n",
    "    public void PrintMessage(string message)\n",
    "    {\n",
    "        Console.WriteLine($\"Singleton says: {message}\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Client (Test class where the singleton instance is accessed)\n",
    "public class Client\n",
    "{\n",
    "    public void Code()\n",
    "    {\n",
    "        // singleton1 and singleton2 are the same instance\n",
    "        Singleton singleton1 = Singleton.Instance;\n",
    "        Singleton singleton2 = Singleton.Instance;\n",
    "        \n",
    "        // Perform your operations on the Singleton instance here\n",
    "        singleton1.PrintMessage(\"I'm not a padlockless singleton!\");\n",
    "        singleton2.PrintMessage(\"I'm the same instance!\");\n",
    "\n",
    "        // Test if they are the same instance\n",
    "        Console.WriteLine(singleton1 == singleton2); // Output: True\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In this example:\n",
    "\n",
    "- The `Singleton` class is defined with a private constructor to prevent instantiation from outside the class, and is a sealed class to prevent inheritance.\n",
    "\n",
    "- The `Instance` property provides the single instance of the Singleton class. It uses double-check locking and the `lock` keyword to ensure that only one thread can access the instance creation logic at a time, that is, to ensure thread safety during the creation of the instance (the critical section is synchronized).\n",
    "\n",
    "- The `padlock` is a static object used for locking purposes to prevent multiple threads from creating multiple instances simultaneously When a thread enters the lock block, it checks if the instance is `null`. If it is, a new instance of the `Singleton` class is created. Subsequent threads that reach the lock block will wait until the lock is released before accessing the instance. This ensures that only one instance is created, even in a multi-threaded environment.\n",
    "\n",
    "- `PrintMessage` method is just an example of a member method within the singleton class.\n",
    "\n",
    "- The `Client` class demonstrates how the Singleton pattern is used. It creates a first instance of the Singleton class and calls the `PrintMessage` method. It then creates a second instance of the Singleton class and calls the `PrintMessage` method again. The output shows that the same instance is used both times, demonstrating that only one instance of the Singleton class exists.\n",
    "\n",
    "> The Singleton pattern ensures that there is only one instance of a class throughout the application, providing global access to that instance. It is commonly used in scenarios where having multiple instances of a class would be detrimental, such as managing a shared resource or a central configuration object.\n"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}