Das Singleton Muster (Singleton Pattern) ist ein Entwurfsmuster in der Sofwareentwickung, welches beschreibt, das man ein Objekt nur einmal instanziieren darf.
Was genau wird realisiert?
Der Konstruktor des Objektes wird auf private gesetzt. Dies hat zur Folge, das man keine Instanz mit dem new Operator erstellen kann. Danach wird eine statische Methode erstellt, die eine neue Instanz des Objektes zurück gibt. In dieser Methode wird überprüft, ob es schon eine Instanz gibt, anhand einer statischen Membervariable. Das wars. Eingesetzt wird dies unter anderem bei Winforms, damit man ein Fenster nicht mehrfach erzeugen kann.
class Singleton
{
/**
* @var Singeleton
*/
private static $_instance;
/**
* Kontruktor MUSS logischerweise auf private gesetzt werden
*/
private function __construct() { /* beliebiger CODE */ }
/**
* @return Singleton
*/
public function getInstance() {
if (self::$_instance == null || !(self::$_instance instanceof Singeleton)) {
self::$_instance = new Singleton();
}
return self::$_instance;
}
}
// aufruf
$mySingletonOnject = Singleton->getInstance(); |
class Singleton
{
/**
* @var Singeleton
*/
private static $_instance;
/**
* Kontruktor MUSS logischerweise auf private gesetzt werden
*/
private function __construct() { /* beliebiger CODE */ }
/**
* @return Singleton
*/
public function getInstance() {
if (self::$_instance == null || !(self::$_instance instanceof Singeleton)) {
self::$_instance = new Singleton();
}
return self::$_instance;
}
}
// aufruf
$mySingletonOnject = Singleton->getInstance();
Quelle: Wikipedia DE
// Nur zur Veranschaulichung – bitte nicht verwenden!
sealed class Singleton
{
private Singleton() { /* beliebiger CODE im Kontruktor */ }
private static Singleton _instance = null;
public static Singleton getInstance()
{
if(_instance == null) {
_instance = new Singleton();
}
return _instance;
}
}
// Diese Version verwenden, wegen der ThreadSicherheit
sealed class Singleton
{
private Singleton() { /* beliebiger CODE */ }
private static volatile Singleton _instance = null;
public static Singleton getInstance()
{
// DoubleLock
if(_instance == null) {
lock(m_lock) {
if (_instance == null) {
_instance = new Singleton();
}
}
}
return _instance;
}
// Hilfsfeld für eine sichere Threadsynchronisierung
private static object m_lock = new object();
}
// Zugriff über Singleton
Singleton MySingletonObject = Singleton.getInstance(); |
// Nur zur Veranschaulichung – bitte nicht verwenden!
sealed class Singleton
{
private Singleton() { /* beliebiger CODE im Kontruktor */ }
private static Singleton _instance = null;
public static Singleton getInstance()
{
if(_instance == null) {
_instance = new Singleton();
}
return _instance;
}
}
// Diese Version verwenden, wegen der ThreadSicherheit
sealed class Singleton
{
private Singleton() { /* beliebiger CODE */ }
private static volatile Singleton _instance = null;
public static Singleton getInstance()
{
// DoubleLock
if(_instance == null) {
lock(m_lock) {
if (_instance == null) {
_instance = new Singleton();
}
}
}
return _instance;
}
// Hilfsfeld für eine sichere Threadsynchronisierung
private static object m_lock = new object();
}
// Zugriff über Singleton
Singleton MySingletonObject = Singleton.getInstance();
Für weitere Informationen zu Singleton oder weiteren Design Pattern empfehle ich folgende Links
Edit: eine erweiterte Variante, basieren auf Dirk Primbs Post
sealed class Singleton
{
// > c# 2008 - Hier wird eine statische Variable erzeugt, die mit
// volatile => Threadsafe
// readonly => mit dem Schlüsselwort stellen wir sicher, das keine neue Instanz erzeugt wird
public static readonly volatile Singleton Instance = new Singleton();
public string Name {get; set; }
// Konstruktor auf private
private Singleton() { /* beliebiger CODE */ }
}
// Testing
var x = Singleton.Instance;
x.Name = "Hans";
var y = Singleton.Instance;
y.Name = "Werner";
// Beide Ausgaben ergeben Werner, weil es nur eine Instanz des Objektes zurückgegeben wird
Console.WriteLine("X: " + x.Name);
Console.WriteLine("Y: " + y.Name);
Console.ReadLine(); |
sealed class Singleton
{
// > c# 2008 - Hier wird eine statische Variable erzeugt, die mit
// volatile => Threadsafe
// readonly => mit dem Schlüsselwort stellen wir sicher, das keine neue Instanz erzeugt wird
public static readonly volatile Singleton Instance = new Singleton();
public string Name {get; set; }
// Konstruktor auf private
private Singleton() { /* beliebiger CODE */ }
}
// Testing
var x = Singleton.Instance;
x.Name = "Hans";
var y = Singleton.Instance;
y.Name = "Werner";
// Beide Ausgaben ergeben Werner, weil es nur eine Instanz des Objektes zurückgegeben wird
Console.WriteLine("X: " + x.Name);
Console.WriteLine("Y: " + y.Name);
Console.ReadLine();
Related Posts: