Working With Singleton Design Pattern In Real Time Projects

A class is like a blueprint that specifies, what the type can do. An object is basically a block of memory, which has been allocated to the blueprint. A program may create many objects of the same class. Objects are also called the instances and are stored in Heap memory location. I will now explain what happens when we will create an object of the class.

• When we create an object of a class a memory is allocated in the RAM (Random Access Memory).
• RAM is volatile and the information stored will be lost when you close the program or on any Power loss.
• RAM (Random Access Memory) is made up of cells. Each cell has its own unique address, where exactly the object will be stored.
  
  
  

If we create multiple objects of the same class, multiple memory will be allocated to the same object but with different cell addresses in RAM.

The figure, given below, will explain, how the memory is allocated to RAM while multiple instance is created, using new keyword.

• Stack is used for static memory allocation and Heap for dynamic memory allocation. Both are stored in the computer's RAM .
  
  
  Thus, in this way, the memory is wasted, while we create a new instance of a class in every call. Thus, to prevent this thing, we can use this "singleton" pattern, which will restrict the user to create more than a single object.
  
  A Singleton should be used when managing access to a resource, which is shared by the entire Application or we can say when we want to make a centralized global object.

In Singleton pattern only one object is created for the class and that object is shared across all the clients,this approach is used when we want to make something centralized. This approach is used in creating a logged file for the whole Application. This is because, whatever error is generated for all the clients, we need to track it from a single file. Thus, we need a singleton pattern here.

In this case, if we follow singlecall (one object for each UI) approach, there is a chance of removing the first user errors from the file, when the second user encounters some error, and here only the second user error will be logged in the logged file.

To implement Singleton pattern in our project, we have to follow three main steps, which are-

• Declare a private constructor for the class for which you want to make Singleton.
• Declare a static variable for that class.
• Create a static method for that class and assign the object to the declared static variable.
  

Private Constructor

1. A private constructor cannot be inherited. If you try to inherit a private constructor, it will give the error and one more important point about the private constructor is if you want to create an object of the class, it will give an error and hence does not allow you to create an object.
   
   1. using System;
   2. using System.Collections.Generic;
   3. using System.Linq;
   4. using System.Text;
   5. using System.Threading.Tasks;
   7. namespace oops1
   8. {
   9. public class Toyota
   10. {
   12. private Toyota()
   13. {
   16. }
   17. }
   18. public class Mycar:Toyota
   19. {
   20. static void Main(string[] args)
   21. {
   23. Console.ReadLine();
   26. }
   27. }
   30. }
   It will show the error message, given below-
   
   
   
   
2. Now the question is, how will we consume the members of a class that has a private constructor. Thus, if we are taking a private constructor for a class, we have to declare all the members of the class as static.This is because the static member of a class can be called or consumed by only the class name.
   
   1. using System;
   2. using System.Collections.Generic;
   3. using System.Linq;
   4. using System.Text;
   5. using System.Threading.Tasks;
   7. namespace oops1
   8. {
   9. public class Toyota
   10. {
   13. private Toyota()
   14. {
   17. }
   18. public static string name;
   19. public static string getData()
   20. {
   21. return name;
   22. }
   23. }
   24. public class Mycar
   25. {
   26. static void Main(string[] args)
   27. {
   28. Toyota.name = "India";
   29. Console.WriteLine(Toyota.name);
   31. Console.ReadLine();
   34. }
   35. }
   38. }

Thus, we have seen the importance of Private constructor. This private constructor plays an important role in singleton pattern in any language.

Now, we will see, how to implement Singleton pattern, using private constructor. I am doing one Console Application to make use of Singleton pattern, given below-
Here, I have designed this class as singleton class. Here, I have taken one static variable and one static method as GetInstance. I am checking whether an object is null or not.When the Application starts for the first time, the value will be null and then it will contain some value until the end of the programme and would not execute the if condition and thus does not create the object.

Now, call from another class.

The implementation here is straightforward. The constructor of Toyota is private. Thus, it is not possible to instantiate it from outside. The only way to get an instance is to call static GetInstance() method. GetInstance() first checks, whether an instance is already created or not. If not, then it creates an instance, refersit via private static member instance and then returns it. If already created, it returns the previously created instance. Thus, the first call GetInstance() instantiates a Toyota object only and any further call returns the same object. Also note, the object is not instantiated until GetInstance() is called, i.e. we only create, when actually required.

Now, I can create one more object like-
In this case, even if we will try to create a new object, it will not execute the if condition and gives up the first object.



For another object, this obj!=null now and and it will not go to execute the condition.



This is how it fails to the condition and gives the first object reference.



In this way, we can implement Singleton pattern in our project. Now, the main concept is about handling multiple request in Singleton pattern.

To increase the performance of the Applications, one has to be very cautious, how and when objects are created and destroyed.

An early creation of an object is very dangerous, as it has a delayed clean-up. When an object is created before it is actually required, the object finds itself residing in a memory stack at much father location from the place it is referenced – hence requiring more POP and PUSH statements to retrieve its value each time it is referenced.

To optimize this, C# 4.0 introduced Lazy object loading. Lazy loading refers to the creating and initializing of the objects only, when it is required for the first time. This means, you can define the object, whenever you wish to, but it actually gets created only, when you access its method/property/function. This article talks about Lazy loading in C# 4.0.

As per Wiki,

In computer programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a value or some other expensive process until the first time it is needed.