The Singleton Pattern

11. The Singleton Pattern The Singleton pattern is grouped with the other Creational patterns, although it is to some extent a pattern that limits the creation of classes rather than promoting such creation. Specifically, the Singleton assures that there is one and only one instance of a class, and provides a global point of access to it. There are any number of cases in programming where you need to make sure that there can be one and only one instance of a class. For example, your system can have only one window manager or print spooler, or a single point of access to a database engine. Your PC might have several serial ports but there can only be one instance of “COM1.” Creating Singleton Using a Static Method The easiest way to make a class that can have only one instance is to embed a static variable inside the class that we set on the first instance and check for each time we enter the constructor. A static variable is one for which there is only one instance, no matter how many instances there are of the class. To prevent instantiating the class more than once, we make the constructor private so an instance can only be created from within the static method of the class. Then we create a method called getSpooler that will return an instance of Spooler, or null if the class has already been instantiated. public class Spooler { private static bool instance_flag= false; private Spooler() { } public static Spooler getSpooler() { if (! instance_flag) return new Spooler (); else return null; } } One major advantage to this approach is that you don’t have to worry about exception handling if the singleton already exists-- you simply get a null return from the getSpooler method. Spooler sp = Spooler.getSpooler(); if (sp != null) Console.WriteLine ("Got 1 spooler"); Spooler sp2 = Spooler.getSpooler (); if (sp2 == null) Console.WriteLine ("Can\'t get spooler"); } And, should you try to create instances of the Spooler class directly, this will fail at compile time because the constructor has been declared as private. //fails at compiler time Spooler sp3 = new Spooler (); Finally, should you need to change the program to allow two or three instances, this class is easily modified to allow this. Exceptions and Instances The above approach has the disadvantage that it requires the programmer to check the getSpooler method return to make sure it is not null. Assuming that programmers will always remember to check errors is the beginning of a slippery slope that many prefer to avoid. Instead, we can create a class that throws an Exception if you attempt to instantiate it more than once. This requires the programmer to take action and is thus a safer approach. Let’s create our own exception class for this case: public class SingletonException:Exception { //new exception type for singleton classes public SingletonException(string s):base(s) { } } Note that other than calling its parent classes through the base constructor, this new exception type doesn’t do anything in particular. However, it is convenient to have our own named exception type so that the runtime system will warn us if this type of exception is thrown when we attempt to create an instance of Spooler. Throwing the Exception Let’s write the skeleton of our PrintSpooler class-- we’ll omit all of the printing methods and just concentrate on correctly implementing the Singleton pattern: public class Spooler { static bool instance_flag = false; //true if one instance public Spooler() { if (instance_flag) throw new SingletonException( "Only one printer allowed"); else { instance_flag = true; //set flag Console.WriteLine ("printer opened"); } } } Creating an Instance of the Class Now that we’ve created our simple Singleton pattern in the PrintSpooler class, let’s see how we use it. Remember that we must enclose every method that may throw an exception in a try - catch block. public class singleSpooler { static void Main(string[] args) { Spooler pr1, pr2; //open one printer--this should always work Console.WriteLine ("Opening one spooler"); try { pr1 = new Spooler(); } catch (SingletonException e) { Console.WriteLine (e.Message); } //try to open another printer --should fail Console.WriteLine ("Opening two spoolers"); try { pr2 = new Spooler(); } catch (SingletonException e) { Console.WriteLine (e.Message); } } Then, if we execute this program, we get the following results: Opening one spooler printer opened Opening two spoolers Only one spooler allowed where the last line indicates than an exception was thrown as expected. Providing a Global Point of Access to a Singleton Since a Singleton is used to provide a single point of global access to a class, your program design must provide for a way to reference the Singleton throughout the program, even though there are no global variables in C#. One solution is to create such singletons at the beginning of the program and pass them as arguments to the major classes that might need to use them. pr1 = iSpooler.Instance(); Customers cust = new Customers(pr1); The disadvantage is that you might not need all the Singletons that you create for a given program execution, and this could have performance implications. A more elaborate solution could be to create a regis try of all the Singleton classes in the program and make the registry generally available. Each time a Singleton is instantiated, it notes that in the Registry. Then any part of the program can ask for the instance of any singleton using an identifying string and get back that instance variable. The disadvantage of the registry approach is that type checking may be reduced, since the table of singletons in the registry probably keeps all of the singletons as Objects, for example in a Hashtable object. And, of course, the registry itself is probably a Singleton and must be passed to all parts of the program using the constructor or various set functions. Probably the most common way to provide a global point of access is by using static methods of a class. The class name is always available and the static methods can only be called from the class and not from its instances, so there is never more than one such instance no matter how many places in your program call that method.. Other Consequences of the Singleton Pattern 1. It can be difficult to subclass a Singleton, since this can only work if the base Singleton class has not yet been instantiated. 2. You can easily change a Singleton to allow a small number of instances where this is allowable and meaningful. Programs on Your CD-ROM \Singleton\SinglePrinter Shows how print spooler could be written thowing exception \Singleton\InstancePrinter Creates one instance or returns null