What is Dependency Injection?
Dependency injection eliminates tight coupling between objects to make both the objects and
applications that use them more flexible, reusable, and easier to test. It facilitates the creation of
loosely coupled objects and their dependencies. The basic idea behind Dependency Injection is that
you should isolate the implementation of an object from the construction of objects on which it
depends. Dependency Injection is a form of the Inversion of Control Pattern where a factory
object carries the responsibility for object creation and linking. The factory object ensures
loose coupling between the objects and promotes seamless testability.
Advantages and Disadvantages of Dependency Injection
The primary advantages of dependency injection are:
Loose coupling
Centralized configuration
Easily testable
Code becomes more testable because it abstracts and isolates class dependencies.
However, the primary drawback of dependency injection is that wiring instances together can
become a nightmare if there are too many instances and many dependencies that need to be
addressed
Dependency Injection
Dependency Injection (DI) is a software design pattern that allows 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.
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.
We can modify this code by the DI different ways. We have following different ways to implement
DI :
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.
1. Public interface IService
2. {
3. Void Serve();
4. }
5.
6. Public class Service : IService
7. {
8. Public void Serve()
9. {
10. Console.WriteLine("Service Called");
11. //To Do: Some Stuff
12. }
13. }
14.
15. Public class Client
16. {
17. Private IService _service;
18.
19. Public Client(IService service)
20. {
21. this._service = service;
22. }
23.
24. Public void Start()
25. {
26. Console.WriteLine("Service Started");
27. this._service.Serve();
28. //To Do: Some Stuff
29. }
30. }
31. Class Program
32. {
33. Static void Main(string[] args)
34. {
35. Client client = new Client(new Service());
36. client.Start();
37. Console.ReadKey();
38. }
39. }
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:
1. knowing the types of each IService
2. according to the request, feed the abstract IService to the Client
Property injection
1. Also called Setter injection.
2. Used when a class has optional dependencies, or where the implementations may need to be
swapped. Different logger implementations could be used this way.
3. May require checking for a provided implementation throughout the class (need to check for null
before using it).
4. Does not require adding or modifying constructors.
1. Public interface IService
2. {
3. Void Serve();
4. }
5.
6. Public class Service : IService
7. {
8. Public void Serve()
9. {
10. Console.WriteLine("Service Called");
11. //To Do: Some Stuff
12. }
13. }
14.
15. Public class Client
16. {
17. Private IService _service;
18.
19. Public IService Service
20. {
21. set
22. {
23. this._service = value;
24. }
25. }
26.
27. Public void Start()
28. {
29. Console.WriteLine("Service Started");
30. this._service.Serve();
31. //To Do: Some Stuff
32. }
33. }
34. Class Program
35. {
36. Static void Main(string[] args)
37. {
38. Client client = new Client();
39. client.Service = new Service();
40. client.Start();
41.
42. Console.ReadKey();
43. }
44. }
Method injection
1. Inject the dependency into a single method, for use by that method.
2. Could be useful where the whole class does not need the dependency, just the one method.
3. Generally uncommon, usually used for edge cases.
1. Public interface IService
2. {
3. Void Serve();
4. }
5.
6. Public class Service : IService
7. {
8. Public void Serve()
9. {
10. Console.WriteLine("Service Called");
11. //To Do: Some Stuff
12. }
13. }
14.
15. Public class Client
16. {
17. Private IService _service;
18.
19. Public void Start(IService service)
20. {
21. this._service = service;
22. Console.WriteLine("Service Started");
23. this._service.Serve();
24. //To Do: Some Stuff
25. }
26. }
27. Class Program
28. {
29. Static void Main(string[] args)
30. {
31. Client client = new Client();
32. client.Start(new Service());
33.
34. Console.ReadKey();
35. }
36. }
Key points about DI
1. Reduces class coupling
2. Increases code reusing
3. Improves code maintainability
4. Improves application testing
