SOLID: Dependency Inversion Principle in C#

The Dependency Inversion Principle (DIP) is one of the five SOLID principles of software design. It states that high-level modules should not depend on low-level modules. Instead, both should depend on abstractions.

In C#, the Dependency Inversion Principle can be implemented through the use of interfaces. Interfaces define contracts that classes can implement, and this allows the high-level module to depend on the interface, rather than the specific implementation.

Let's take an example where we have two classes: HighLevelModule and LowLevelModule.

public class HighLevelModule
{
    private readonly LowLevelModule _lowLevelModule;

    public HighLevelModule()
    {
        _lowLevelModule = new LowLevelModule();
    }

    public void DoSomething()
    {
        _lowLevelModule.DoSomething();
    }
}

public class LowLevelModule
{
    public void DoSomething()
    {
        Console.WriteLine("LowLevelModule is doing something...");
    }
}

In this example, HighLevelModule depends on LowLevelModule, which violates the Dependency Inversion Principle. If we were to change the implementation of LowLevelModule, it would break the HighLevelModule class.

To fix this, we can use an interface to abstract the dependency between HighLevelModule and LowLevelModule. Let's create an interface called ILowLevelModule that defines the method DoSomething().

public interface ILowLevelModule
{
    void DoSomething();
}

Now, we can modify the LowLevelModule class to implement the ILowLevelModule interface.

public class LowLevelModule : ILowLevelModule
{
    public void DoSomething()
    {
        Console.WriteLine("LowLevelModule is doing something...");
    }
}

Next, we modify the HighLevelModule class to depend on the ILowLevelModule interface instead of the concrete LowLevelModule class.

public class HighLevelModule
{
    private readonly ILowLevelModule _lowLevelModule;

    public HighLevelModule(ILowLevelModule lowLevelModule)
    {
        _lowLevelModule = lowLevelModule;
    }

    public void DoSomething()
    {
        _lowLevelModule.DoSomething();
    }
}

Finally, we can create an instance of LowLevelModule and pass it to the HighLevelModule constructor.

var lowLevelModule = new LowLevelModule();
var highLevelModule = new HighLevelModule(lowLevelModule);

By implementing the Dependency Inversion Principle in this way, the HighLevelModule class is decoupled from the LowLevelModule class, and we can change the implementation of LowLevelModule without affecting the HighLevelModule class.

To summarize, the Dependency Inversion Principle states that high-level modules should depend on abstractions, rather than low-level modules. In C#, this can be implemented using interfaces to abstract dependencies between classes. By doing so, we can improve the flexibility and maintainability of our code.

SOLID: Dependency Inversion Principle in C#

Sign in with TechieClues