Singleton Design Pattern In C# - Part Three (Static vs Singleton)

Introduction

In this series on learning singleton pattern, we learned lazy initialization and eager initialization with practical examples. We also learned why it is necessary to make the singleton class sealed with the sealed keyword. In this article, I’ll try to explain the differences between static and singleton class. We will also see where to use static class and where to use singleton classes. Following are the links to the previous two articles of the series.

We’ll not discuss in detail what static class is but rather focus more on the differences between singleton and static class. Following are the point to point differences between a static class and singleton pattern.

1. Singleton is an object creational design pattern and is designed following some guidelines to ensure it returns only one object of its class whereas static is a reserved keyword in C# which is used before class or method to make it static.
2. Singleton classes or design pattern can contain static as well as non-static members whereas if a class is marked static, it only should contain static members. For e.g. if a class is static, it should have static methods, static properties and static variables only.
3. Singleton methods could be passed as a reference to other methods or objects as a parameter but static members could not be passed as a reference.
4. Singleton objects could be created in a way where they support disposal; that means they could be disposed of.
5. Singleton objects are stored on heap whereas static objects are stored on the stack.
6. Singleton objects can be cloned.
7. Singleton promotes code re-usability and code-sharing and could implement interfaces as well. Singleton can inherit from other classes and promotes inheritance and have better control of object state whereas a static class cannot inherit its instance members.
8. Singleton class could be designed in a way where it can leverage lazy initialization or asynchronous initialization and is taken into consideration directly by CLR whereas static class is firstly initialized at the time of its first load.
9. Static classes cannot contain instance constructors and cannot be instantiated whereas the singleton classes have private instance constructor.

Static Class Implementation

Let’s do some practical implementation to understand in more detail. Open the solution we created in the last article or a new one and add a new project of console application type and name it as StaticClasses.



Now suppose we have a requirement in our project to create a utility class that holds the area of various shapes; for e.g. let’s consider that the class contains the formulas to calculate the area of circle, square, rectangle and triangle. We are very much sure that the formula to calculate the area of the geometrical shapes always remains the same and is based on what input parameters we pass; for example a rectangle is the length of the rectangle multiplied by the width of the rectangle and that of a square is square of the length of the side. Since the area always remains the same, we can achieve this functionality with the help of a static class and static methods. So, create a class named Areas and make it static in the StaticClasses console application.



Now, let’s create static methods for calculating the area of circle, rectangle, square, and triangle.