Implementation of Dependency Injection Pattern in C#
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.
For example, Suppose your Client
class needs to use aService
class component, then the best you can do is to make yourClient
IService
interface rather than aService
class. In this way, you can change the implementation of theService
class at any time (and for how many times you want) without breaking the host code.
We can modify this code by the DI different ways. We have following different ways to implement DI :
Constructor Injection
-
This is the most common DI.
-
Dependency Injection is done by supplying the DEPENDENCY through the class’s constructor when instantiating that class.
-
Injected component can be used anywhere within the class.
-
Should be used when the injected dependency is required for the class to function.
-
It addresses the most common scenario where a class requires one or more dependencies.
- publicinterface IService
- {
- voidServe();
- }
- publicclassService:IService
- {
- publicvoidServe()
- {
- Console.WriteLine("Service Called");
- //To Do: Some Stuff
- }
- }
- publicclassClient
- {
- privateIService _service;
- publicClient(IService service)
- {
- this._service = service;
- }
- publicvoidStart()
- {
- Console.WriteLine("Service Started");
- this._service.Serve();
- //To Do: Some Stuff
- }
- }
- classProgram
- {
- staticvoidMain(string[] args)
- {
- client =newClient(newService());
- client.Start();
- Console.ReadKey();
- }
- }
The Injection happens in the constructor, by passing the Service that implements the IService-Interface. The dependencies are assembled by a "Builder" and Builder responsibilities are as follows:
-
knowing the types of each IService
-
according to the request, feed the abstract IService to the Client
Property injection
-
Also called Setter injection.
-
Used when a class has optional dependencies, or where the implementations may need to be swapped. Different logger implementations could be used this way.
-
May require checking for a provided implementation throughout the class(need to check for null before using it).
-
Does not require adding or modifying constructors.
- publicinterface IService
- {
- voidServe();
- }
- publicclassService:IService
- {
- publicvoidServe()
- {
- Console.WriteLine("Service Called");
- //To Do: Some Stuff
- }
- }
- publicclassClient
- {
- privateIService _service;
- publicIServiceService
- {
- set
- {
- this._service = value;
- }
- }
- publicvoidStart()
- {
- Console.WriteLine("Service Started");
- this._service.Serve();
- //To Do: Some Stuff
- }
- }
- classProgram
- {
- staticvoidMain(string[] args)
- {
- Client client =newClient();
- client.Service=newService();
- client.Start();
- Console.ReadKey();
- }
- }
Method injection
-
Inject the dependency into a single method, for use by that method.
-
Could be useful where the whole class does not need the dependency, just the one method.
-
Generally uncommon, usually used for edge cases.
- publicinterface IService
- {
- voidServe();
- }
- publicclassService:IService
- {
- publicvoidServe()
- {
- Console.WriteLine("Service Called");
- //To Do: Some Stuff
- }
- }
- publicclassClient
- {
- privateIService _service;
- publicvoidStart(IService service)
- {
- this._service = service;
- Console.WriteLine("Service Started");
- this._service.Serve();
- //To Do: Some Stuff
- }
- }
- classProgram
- {
- staticvoidMain(string[] args)
- {
- Client client =newClient();
- client.Start(newService());
- Console.ReadKey();
- }
- }
Key points about DI
-
Reduces class coupling
-
Increases code reusing
-
Improves code maintainability
-
Improves application testing