Dependency Injection (DI) is a software design pattern that allow us to develop loosely coupled code. DI is a great way to reduce tight coupling between software components. DI also enables us to better manage future changes and other complexity in our software. The purpose of DI is to make code maintainable.

The Dependency Injection pattern uses a builder object to initialize objects and provide the required dependencies to the object means it allows you to “inject” a dependency from outside the class.

Key points about Dependency Injection
1. Reduces class coupling
2. Increases code reusing
3. Improves code maintainability
4. Improves application testing

For example, Suppose your Client class needs to use a Service class component, then the best you can do is to make your Client class aware of an IService interface rather than a Service class. In this way, you can change the implementation of the Service class at any time (and for how many times you want) without breaking the host code.

Constructor Injection
1. This is the most common DI.
2. Dependency Injection is done by supplying the DEPENDENCY through the class’s constructor when instantiating that class.
3. Injected component can be used anywhere within the class.
4. Should be used when the injected dependency is required for the class to function.
5. It addresses the most common scenario where a class requires one or more dependencies.

     public interface IService  
     {  
       void Serve();  
     }  
     public class Service : IService  
     {  
       public void Serve()  
       {  
         Console.WriteLine("Service Called");  
         //To Do: Some Stuff  
       }  
     }  
     public class Client  
     {  
       private IService _service;  
       public Client(IService service)  
       {  
         this._service = service;  
       }  
       public void Start()  
       {  
         Console.WriteLine("Service Started");  
         this._service.Serve();  
         //To Do: Some Stuff  
       }  
     }  
     class Program  
     {  
       static void Main(string[] args)  
       {  
         Client client = new Client(new Service());  
         client.Start();  
         Console.ReadKey();  
       }  
     }  

 public sealed class Singleton   
  {   
   // Thread safe Singleton with fully lazy instantiation   
   private Singleton()  
    {  
    }  
   public static Singleton Instance { get { return Nested.instance; } }  
    private class Nested  
    {  
      // Explicit static constructor to tell C# compiler  
      // not to mark type as beforefieldinit  
      static Nested()  
      {  
      }  
      internal static readonly Singleton instance = new Singleton();  
    }  
  }