Inversion of control - Part 1

When an object of a type depends on an object of another type we say that the types are coupled. This is because change in one can lead to a change in second. This will hamper the extensibility and modification in design. In a more complex system lot of classes interact with each other and this will lead to a very brittle design. Let's take an example:


   class Program
    {
        static void Main(string[] args)
        {
            List<Employee> employees = new List<Employee>();
            EmployeeController employeeController = new EmployeeController();
            employees = employeeController.GetAllEmployees();
        }
    }


Program depends on EmployeeController to fetch Employee(s). 


Inversion of control


Logically Inversion means rearrangement. As we have seen in the previous example that Program is controlling EmployeeController and this control is actually coupling them. Inversion of control is object-oriented practice via which we can decouple the classes by providing the implementation (EmployeeController) at runtime (instead of compile time) via abstraction.


This helps in following ways:-
1. Reduces the coupling in the system.
2. Makes sure that we "Program to an interface and not to the implementation".
3. Allows the implementation to be changed without impacting the consumer.
4. Every module can be developed independent of each other.
5. Allows a module to be a cohesive unit and concentrate on the responsibilities assigned to it.
6. Modules do not assume about the functioning of other modules but rely on the contract (Interface).


and many more.


Simpler explanation


Previous example assigns EmployeeController object statically to Program. In place of this IoC (inversion of control) uses an assembler to instantiate the object and assign it to the consumer. Even if we use an assembler Program still need to be aware of EmployeeController. Instead of this if we can make EmployeeController's contract available to Program it can delegate the task to the implementation (EmployeeCotroller) via it. In general Interfaces and (sometimes) abstract classes are used as the contract. Now the assembler assigns the EmployeeController object wrapped in the abstraction to Program and thus the implementation can change without impacting the consumer.


Dependency Injection


Dependency Injection is the mechanism using which we can assign the object to the consumer or we can achieve IoC by binding the objects at run time. We can also use Service Locator to provide IoC. We will discuss Service Locator in a future post. 


Types of Dependency Injection


There are three common forms of dependency injection:
1. Constructor Injection
2. Setter Injection
3. Interface-based injection


We will discuss the implementation of DI in future posts.