Learn About Static VS Singleton

Static vs Singleton

• Static class is implicitly abstract, meaning a static class object can neither be created nor instantiated whereas singleton pattern allows us to create a single (only one) instance of a class.
• Static class is a stateless class whereas singleton class is state full
• Static class instance is created whenever it is first accessed and becomes accessible throughout the application or per appdomain whereas Singleton pattern provides flexibility that allows us to control instantiation based on the conditions; for example, instance of singleton class can be created per context like single instance of ShoppingCart can be created per customer
• Data stored in the static variable or class is shared and accessed globally throughout the application whereas singleton instance created per context is shared and accessible per context meaning data stored with in the instance created in context will not be shared or accessible from instance created in another context for example items stored in ShoppingCart will be shared and accessible among different login session of a customer but will not be accessible to another customer.
• Static class cannot be inherited or derived from any other class whereas singleton can implement interfaces and inherit from another class.
• Static class cannot be passed as a parameter to any method whereas instance of singleton class can be passed as a parameter to a method or constructor of another class.
• Only static members/fields/properties can be defined within the static class whereas singleton class allows both static and non-static members/fields/properties.

We will now look at and understand the below mentioned use case implementation that demonstrates all of the above facts.

Use Case

Let’s think about the e-commerce online web portal to which thousands of customer already have subscribed. There could be a scenario when several hundred people login at the same time out of which a few people login in to the web portal from multiple applications; i.e., web portal, mobile app or background processes then logged in customers search and add items into their shopping cart. Now think of those customers who have logged in from multiple applications and add items into the shopping cart from multiple applications.

Now the request is to provide a solution that every customer should be able to view all the items of their own private shopping cart but a specific user should be able to view all the items added in the shopping cart from different applications.

Solution

First of all we will implement a solution to have different instances of shopping cart per customer so we need three entities in the solution as mentioned below:

1. ShoppingCart class that represents shopping cart. This class has a private field to store items added into the shopping cart.
2. Customer class that represents a customer.
3. LoggedinCustomers class that stores list a list of logged in customers

Is it possible to create instance of shopping cart per customer with static class implementation? The answer is No because static class is implicitly abstract meaning Static class object can neither be created nor instantiated. .Net CLR implicitly creates one instance of static class internally whenever it is first accessed and the same instance is shared among all other objects in an application.

Now the question arises – Is it possible to create an instance of shopping cart per customer with singleton pattern implementation? The answer is YES, we can use or implement Singleton pattern to restrict one instance created per customer, meaning instance of shopping cart that will be created for customer one will be different from instance created for customer two. Then later the same instance of shopping cart can be passed to different login sessions of customer.

Let’s follow the below mentioned steps to have this implementation in place,

1. Implement a Singleton pattern in the ShoppingCart class that ensures or restricts that only one instance of shopping cart is created.
2. To meet our requirement of one instance per customer, add a Boolean flag to determine whether we need to create an instance of ShoppingCart or not.
3. Declare a collection object variable of type List to store items added into the Shopping Cart.
   
   1. /// <summary>
   2. /// An abstract representation of Shopping Cart.
   3. /// This class is the implementation of singleton design pattern
   4. /// which restricts the instantiation of a class to one object
   5. /// </summary>
   6. public sealed class ShoppingCart
   7. {
   8. private static volatile ShoppingCart _instance; //A static variable which holds a reference to the single created instance
   9. private static readonly object SyncRoot = new Object();
   10. private readonly List<string> _itemsAdded = new List<string>();
   13. /// <summary>
   14. /// private and parameterless constructor that prevents other classes from instantiating it
   15. /// </summary>
   16. private ShoppingCart() { }
   18. /// <summary>
   19. /// This method is to get the instance of ShoppingCart class
   20. /// </summary>
   21. /// <param name="bCreateInstance">This flag determines whether new instance is to be created or not</param>
   22. /// <returns>An instance of ShoppingCart class</returns>
   23. public static ShoppingCart Instance(bool bCreateInstance)
   24. {
   25. if ((_instance == null) || (bCreateInstance == true))
   26. {
   27. lock (SyncRoot)
   28. {
   29. if ((_instance == null) || (bCreateInstance == true))
   30. _instance = new ShoppingCart();
   31. }
   32. }
   33. return _instance;
   34. }
   36. /// <summary>
   37. /// This method is to add item into the Shopping cart
   38. /// </summary>
   39. /// <param name="itemCode"></param>
   40. public void AddItemToShoppingCart(string itemCode)
   41. {
   42. _itemsAdded.Add(itemCode);
   43. }
   45. /// <summary>
   46. /// This method is to get the list of items added into the shopping cart
   47. /// </summary>
   48. /// <returns>A list of item added into the shopping cart</returns>
   49. public List<string> GetShoppingCartItems()
   50. {
   51. return _itemsAdded;
   52. }
   53. }
4. Now define a Customer class with a field to store an instance of ShoppingCart.
5. Within the constructor of customer class create an instance of ShoppingCart class.
6. Within the Customer class define a method “AddItemToShoppingCart” to add item into the ShoppingCart and method “PrintShoppingCartItem” to print all the items currently added into the shopping cart
   
   1. /// <summary>
   2. /// This class is a blueprint of a customer
   3. /// </summary>
   4. public class Customer
   5. {
   6. //A local variable to store an instance of ShoppingCart.
   7. private readonly ShoppingCart _shoppingCartInstance = null;
   9. #region Properties
   11. /// <summary>
   12. /// Property to hold customer name
   13. /// </summary>
   14. public string CustomerName { get; set; }
   16. #endregion
   18. #region Constructor
   19. /// <summary>
   20. /// Constructor to initialize Customer Identifier and Customer Name
   21. /// </summary>
   22. /// <param name="customerName">Customer Name</param>
   23. ///
   24. public Customer(string customerName)
   25. {
   26. CustomerName = customerName;
   27. _shoppingCartInstance = ShoppingCart.Instance(true);
   28. }
   29. #endregion
   32. /// <summary>
   33. /// This method is to the add item into the Shopping Cart
   34. /// </summary>
   35. /// <param name="itemCode">Item to be added into the shopping cart</param>
   36. public void AddItemToShoppingCart(string itemCode)
   37. {
   38. _shoppingCartInstance.AddItemToShoppingCart(itemCode);
   39. }
   41. /// <summary>
   42. /// This method is to print the items currently added into the shopping cart
   43. /// </summary>
   44. public void PrintShoppingCartItem()
   45. {
   46. List<string> itemsAdded = _shoppingCartInstance.GetShoppingCartItems();
   48. StringBuilder itemsAddedToShoppingCart = new StringBuilder();
   49. foreach (var item in itemsAdded)
   50. {
   51. if (itemsAddedToShoppingCart.Length > 0)
   52. itemsAddedToShoppingCart.Append(", ");
   54. itemsAddedToShoppingCart.Append(item);
   55. }
   56. Console.WriteLine("Items Added in {0}'s Cart : {1}", CustomerName, itemsAddedToShoppingCart.ToString());
   57. }
   58. }
7. Now define a class named LoggedinCustomers.
8. Define a field “_customers” within the LoggedinCustomers class which contains a collection of logged in Customer objects. Defined a method named “AddCustomer” to add a customer into the collection object field. Defined a method named “” to get the list of customer objects stored in the collection object
   
   1. public class LoggedinCustomers
   2. {
   3. private readonly List<Customer> _customers = new List<Customer>();
   5. /// <summary>
   6. /// This method is to get the customer from loggedin customer collection based on the customer name
   7. /// </summary>
   8. /// <param name="customerName">Customer Name</param>
   9. /// <returns>An instance of customer</returns>
   10. public Customer GetCustomer(string customerName)
   11. {
   12. Customer customer = _customers.FirstOrDefault(x => x.CustomerName == customerName);
   13. return customer;
   14. }
   16. /// <summary>
   17. /// This method is to add customer into the loggedin customer collection
   18. /// </summary>
   19. /// <param name="customer">an instance of customer class</param>
   20. public void AddCustomer(Customer customer)
   21. {
   22. _customers?.Add(customer);
   23. }
   25. /// <summary>
   26. ///
   27. /// </summary>
   28. /// <returns></returns>
   29. public List<Customer> GetCustomers()
   30. {
   31. return _customers;
   32. }
   33. }

Now write a program that instantiates an instance of Customer class for different users whereas retrieves an existing instance of customer class from a list of logged in customers maintained. This way we will be able to create different instances of shopping cart per customer and add item into the shopping cart.

Code Snippet