Creating a real singleton class in Delphi 5
Abstract:The article describes how to create a class that follows the singleton pattern. The class described will take care of the singleton requirements and effects itself, effectively leaving the programmer to use the class as any others.
by Lasse V錱s鎡her Karlsen, Systems Developer for
|Errata||1.||Implementation of TSingleton.NewInstance had the first test switched, the one that checked if the Instance variable was assigned or not. -- Fixed 11-08-2000 - Thanks to the people that emailed me about this --|
|2.||Overzealous fix for the first errata, the NewInstance method should now work as stated. -- Fixed 11.08.2000 --|
A singleton is a class that supports the creation of just one object. Its like your computer -- theres just one keyboard. So if you were writing Delphi code that simulated your computer, you would want just one object instance to deal with keyboard read, write, and control activities.
Articles about singleton classes are rare but there are a few on the Internet. Ive seen some in magazines too. But none of these articles include sample code to create a real singleton class.
By "real" I mean that the class itself enforces the one-instance requirement, instead of leaving that task to the programmer. All of the articles I have seen so far have required the programmer to use the class in a special way to enforce the singleton pattern.
In this article you will see how to create a proper singleton class that includes logic to enforce the one-instance rule.
Note: The conventional approach, in which the one-instance rule is maintained explicitly by the programmer, is not without merit. Real singleton classes like the one I present here effectively hide the details and awareness of the singleton pattern from the programmer. The programmer is relieved of the task of enforcing the pattern -- thats good -- but the programmer may also be unaware of the special nature of the class, which is bad. If you dont know that the class is a singleton class then all sorts of errors can crop up. You have been warned!
Our goal is to write a class that can be used like this:
procedure Test; var s1, s2 : TSingleton; begin s1 := TSingleton.Create; s2 := TSingleton.Create; // Do something with s1 and s2 here s2.Free; s1.Free; end;(Ive left out the try...finally blocks and other safeguards for simplicitys sake.)
The goal is to make the TSingleton class behave in such a way that both s1 and s2 refer to the same object. Heres what we have to do:
class function NewInstance: TObject; virtual; procedure FreeInstance; virtual;
NewInstance is responsible for allocating memory to hold a new instance of the class, and
FreeInstance is responsible for freeing that memory when the class is through with it.
These methods control what happens when the object is created and when the object is destroyed. If we overwrite this code, we can alter the default behavior to work the say a singleton class requires. Nothing to it.
Tracking instances is a little trickier. We must:
Instanceso we know what it refers to.
As for keeping track of how many references exist, we need another variable. We can it inside the class or make it a sort-of global like
Instance. Ill opt for the latter way but do what you feel is best. Ill name this variable
We now have two variables:
var Instance : TSingleton = nil; Ref_Count : Integer = 0;I initialize the variables so that initially they dont contain any garbage. I know that the compiler does this automatically, so this is just a readability issue.
Well need to declare the TSingleton class above the variable block, and if you take a look at the example files that you can download at the end of this article youll see that Ive put the declaration in the interface part of the unit so that its visible outside of it.
Heres the declaration of the TSingleton class:
type TSingleton = class public class function NewInstance: TObject; override; procedure FreeInstance; override; class function RefCount: Integer; end;I added the RefCount function so that we can see that it actually works, and its often handy to be able to read how many references to the object exist. Its not required, however, so you dont have to add it to your singleton classes if you dont need it.
Ok, now for the implementation of the three methods:
procedure TSingleton.FreeInstance; begin Dec( Ref_Count ); if ( Ref_Count = 0 ) then begin Instance := nil; // Destroy private variables here inherited FreeInstance; end; end; class function TSingleton.NewInstance: TObject; begin if ( not Assigned( Instance ) ) then begin Instance := inherited NewInstance; // Initialize private variables here, like this: // TSingleton(Result).Variable := Value; end; Result := Instance Inc( Ref_Count ); end; class function TSingleton.RefCount: Integer; begin Result := Ref_Count; end;And thats it!
When you call TSingletons constructor, a call is placed to the
NewInstance method declared in
TObject. This method allocates memory to hold the new object and returns it to the constructor. The constructor uses that memory and eventually returns a pointer to the memory to the code that called the constructor. This pointer is usually stored in a variable while the object is in use.
I have overridden the
NewInstance method so it will allocate the memory only if no instance of the class exists. If there is an existing instance, the function simply returns that instance to the constructor so it will be reused