b'\n_START_ARTICLE_\nSingleton (ontwerppatroon)\n_START_PARAGRAPH_\nSingleton is een ontwerppatroon om het aantal objecten van een bepaalde klasse tot \xc3\xa9\xc3\xa9n te beperken. Met dit ontwerppatroon is het mogelijk om de toegang tot bepaalde systeembronnen altijd via \xc3\xa9\xc3\xa9n object te laten gaan._NEWLINE_Een toepassing van de singleton is bijvoorbeeld het maken van unieke identificatienummers binnen een programma. Om er altijd zeker van te zijn dat elk identificatienummer uniek is, is het handig om dit door \xc3\xa9\xc3\xa9n enkel object te laten genereren. Dit is dan een singleton._NEWLINE_Een singleton wordt gemaakt door een klasse te defini\xc3\xabren met een methode die een nieuw object aanmaakt als het nog niet bestaat en een bestaand object teruggeeft als er al wel een dergelijk object bestaat.\n_START_SECTION_\nKeerzijde van Singleton\n_START_PARAGRAPH_\nSingleton is een controversieel ontwerppatroon. Singleton is eigenlijk tegengesteld aan de principes van het object-geori\xc3\xabnteerd programmeren. Singletons introduceren binnen een programma, een enkele globale instantie van een klasse in plaats van verscheidene instanties van een klasse daar waar nodig. Dit doorbreekt het patroon van een object-geori\xc3\xabnteerd ontwerp en kan een stap terug betekenen naar het imperatief programmeren._NEWLINE_Bovendien moet in veel talen de Singleton zo ge\xc3\xafmplementeerd worden dat het moeilijk of zelfs onmogelijk is om via overerving aanpassingen aan de Singleton-klasse te maken. In het bovenstaande voorbeeld is de Singleton uitgevoerd met behulp van statische methoden. In Java is het bijvoorbeeld erg moeilijk om via overerving het gedrag van een statische methode aan te passen. Het \'doorboort\' de object-geori\xc3\xabnteerde ontwerpprincipes._NEWLINE_Bij een verkeerd gebruik kunnen met een Singleton vaak heel makkelijk geheugenlekken ge\xc3\xafntroduceerd worden. Dit kan door onnodig beslag leggen van geheugen als hij niet gebruikt wordt en niet opgeruimd kan worden. Ook kunnen er geheugenproblemen ontstaan in talen als C++ waarin een component een Singleton kan verwijderen die nog elders in gebruik is. Bovendien kan in gedistribueerde programma\'s zonder voorzorgsmaatregelen een Singleton verscheidene malen ge\xc3\xafnstantieerd worden en dus uiteindelijk geen Singleton zijn.\n_START_SECTION_\nJava\n_START_PARAGRAPH_\nEen voorbeeld in Java:_NEWLINE_public class Singleton {_NEWLINE_    private static Singleton _instance = null;_NEWLINE__NEWLINE_    // Private constructor vervangt de standaard public constructor _NEWLINE_    private Singleton () {}_NEWLINE__NEWLINE_    //gesynchroniseerde creator om multi-threading-problemen te voorkomen_NEWLINE_    //nog een controle om te voorkomen dat er meer dan een object wordt ge\xc3\xafnstantieerd_NEWLINE_    private synchronized static void createInstance () {_NEWLINE_        if (_instance == null) _instance = new Singleton ();_NEWLINE_    }_NEWLINE__NEWLINE_    public static Singleton getInstance () {_NEWLINE_        if (_instance == null) createInstance ();_NEWLINE_        return _instance;_NEWLINE_    }}\n_START_SECTION_\nC#\n_START_PARAGRAPH_\nEen voorbeeld in C#:_NEWLINE_public class Singleton {_NEWLINE_    // Thread-safe oplossing om slechts \xc3\xa9\xc3\xa9n instantie aan te maken._NEWLINE_    private static Singleton _instance = new Singleton ();_NEWLINE__NEWLINE_    // Private constructor om te voorkomen dat anderen een instantie kunnen aanmaken._NEWLINE_    private Singleton () { }_NEWLINE__NEWLINE_    // Via een static read-only property kan de instantie benaderd worden._NEWLINE_    public static Singleton Instance {_NEWLINE_        get {_NEWLINE_            return _instance;_NEWLINE_        }_NEWLINE_    }}\n_START_SECTION_\nC# (met generics)\n_START_PARAGRAPH_\nEen thread-safe voorbeeld met een luie initialisatie._NEWLINE_/// <summary>/// Generic class implements singleton pattern./// </summary>/// <typeparam name="T">/// Reference type. Important: Must have private constructor (not public)./// </typeparam>public class Singleton<T> where T : class{_NEWLINE_    protected Singleton () { }_NEWLINE__NEWLINE_    public static T Instance {_NEWLINE_      get { return SingletonCreator.instance; }_NEWLINE_    }_NEWLINE__NEWLINE_    class SingletonCreator_NEWLINE_    {_NEWLINE_        // static SingletonCreator() { } redundant as it is created by the compiler automatically_NEWLINE_        internal static readonly T instance = typeof(T).InvokeMember(typeof(T).Name,_NEWLINE_                           BindingFlags.CreateInstance |_NEWLINE_                           BindingFlags.Instance |_NEWLINE_                           BindingFlags.NonPublic,_NEWLINE_                           null, null, null) as T;_NEWLINE_    }}\n_START_SECTION_\nPHP 5\n_START_PARAGRAPH_\nSingleton-patroon in PHP 5:_NEWLINE_class Singleton {_NEWLINE_    // object instance_NEWLINE_    private static $instance;_NEWLINE_  _NEWLINE_    private function __construct() {}_NEWLINE_    private function __clone() {}_NEWLINE_  _NEWLINE_    public static function getInstance() {_NEWLINE_        if (!Singleton::$instance instanceof self) {_NEWLINE_            Singleton::$instance = new self();_NEWLINE_        }_NEWLINE_        return Singleton::$instance;_NEWLINE_    }}\n_START_SECTION_\nRuby\n_START_PARAGRAPH_\nSingleton-patroon in Ruby_NEWLINE_require \'singleton\'class Singleton_NEWLINE_    include Singletonend\n_START_SECTION_\nScala\n_START_PARAGRAPH_\nSingleton-patroon in Scala is een taalelement._NEWLINE_object Singleton {val pi = 3.14var teller = 0}_NEWLINE_Ook hier met Scala thread safety gegarandeerd, bovendien kunnen er "companion" klassen gemaakt worden.'