C# Design Patterns: Understanding and Implementing Singleton

welcome to this video in this video we are going to learn about implementing s design pattern in C okay so the contents of this video first of all we are going to look at the Singleton design pattern we are going to look at its key characteristics and how we can implement this in cop and last but not the least we are going to look at its pros cons and when to use it okay so what is a Singleton design pattern a Singleton design pattern ensures that a class has only one instance and provides a global access point to it meaning that you cannot create multiple instances of it there is always a one instance that's available throughout your application what is its purpose I mean it's useful for managing resources logging caching and thread pools among others basically controlling the object create there are certain use cases uh where you can use this single design pattern for example database connections configuration settings logging if you now if you just think you don't need to create multiple instances of any class when you are either using database connections you know maintaining the configuration setting or you might have created your own loggers we'll look at the key characteristics of any single design so so single Chanel when the it always ensures there is only one instance as I said earlier that patent guarantees that a class has only one instance during the life cycle of an application okay and Global access point provides a straight point of axis for different parts of an application to refer to the same and on top of it it provides Constructor control what you need to do is when you are creating a single design pattern you need to ensure that your Constructor is private and there is a static instance folder so here in the private Constructor so once you make this CL once you make your Constructor private so it restricts the object instantiation from outside the class and on the other hand the static instance holder which uses a static variable to hold the single instance of the class ensuring a centralized control now you also need to think about concurrent access controls so there are scenarios like multi-threading control thread save mechanism what happens if there are multiple threads try to uh access the same uh Singleton instance let's say you sp an application and there are multiple thread trying to uh just call your instance varable the static variable that holds an instance so that's not a threat save so what might happen is you might just end up creating more than one instance and each thre might end up working on its own instance so the best way is uh we need to ensure that it's dead safe and how do you do that we need to ensure that we Implement proper locks around object creation Now in this uh slide we are going to check how we can Implement uh single cop okay so the static instance a static instance variable which I discussed earlier will hold the instance that's going to be a single instance right here as you can see that we have declared a class single and we have declared a private Constructor which will ensure that there is no object creation and it always ensures that there is only one instance so the instance can be created only from within the class and that's totally controlled so nobody can call new Singleton because once you mark this class as once you mark this class Constructor as private you definitely cannot instantiate it okay now there was another casis that we discussed that uh having a static uh variable that will hold the instance of this class as you see that we created a variable private static single which is nothing but the same class instance here uh the variable here uh here what we're doing in the static method so we check for the instance variable if it is null then we are going to create uh single now so this is our basic approach as we just discussed uh that what happens in a multi- threaded environment this is not thread safe just imagine that there are two threads calling this G instance and they might just happen to create two different instances so what we do is we make use of a lock so here the lock will ensure that uh we the only uh it prevents multiple instances from being created in a multi-threaded environment so that's uh that's how lock has us here so because meaning that let's say there is one that has called this get instance and once blck is executed and while thread one is being executed uh so it ensures that the thread two cannot go and call this uh unless thread one is finished now once thread one is finished the thread two comes in it checks the instance is not null because uh earlier with the lock we ensured that thread one and thread two cannot happen to access this SP of code simultaneously now with this lock uh we ensure that uh we synchronized uh the access to this uh particular code with a lock okay so this helped us uh with resolving the issue where multi threaded in the multi-threaded environment now there is another thing uh that's called lady lazy uh initialization so here uh I mean you can use a lazy uh initialization to ensure that single instance creation only uh when needed so which ensures performance and threat safety so what you need to do is uh you need to uh Mark your uh read the static variable with the lay so this ensures that uh only when the single is being used then only uh we are going to uh create the instance meaning that unless the variable is used somewhere the instance is not going to be created so that's the benefit with a lazy initialization okay now we can we are going to evaluate the single 10 patter pros and cons so the pros as we discussed that of course it ures a single single instance uh meaning that we save memory by preting multiple instances useful for managing Shar resources and uh so in the Shar Resource Management uh I mean it's this is quite effective in managing caches logging Services various configuration settings so I mean if you just think from practical point of view like uh you you can Implement your cach a which effectively use a Singleton and there are multiple uh points in the application that's accessing the same cach with a single it and the same goes with logging and the configuration settings as well and in the cons we can see the global state issues and testing difficulties okay so what happens is when you are creating the Singleton uh design pattern I mean you are it's not that flexible and it's quite like L coupled and it makes testing uh quite difficult because uh you cannot easily mock things when you are creating the single instance so you cannot it's not it will not be that easy to write the unit test and that's how uh it makes little uh things little difficult and even from my past experience I have seen uh when you implement some uh something as uh a Singleton design pattern I mean it becomes quite complex to write your own unit test uh because not that flexible uh enough because uh you need to ensure that uh somehow you are able to inject things and mock things uh there's some difficulty over there uh with the singlet design pattern so here we'll also look at when to use this Singleton design pattern so where you when you want to provide uh I mean when you want to have controlled resource accesses and um so here like uh when a single instance is required for logging caching configuration control AIS is necessary then you can go with the sing Lon and uh but you know this should be definitely be avoided when high testing and design flexibility is required so throughout this video we have seen what is sing design pattern uh its characteristics where we discussed about the parid Constructor uh static variable which is holding the instance uh of the uh of the instance and uh we have also seen where uh the the use two cases where we can use a sing design pattern and it's pros and cons so I hope I made it very easy for you to understand the sing design pattern uh if you understood something about this uh just don't forget to like uh this video and just if you have got any feedback you can drop in uh your comments I really appreciate it thank you very much