Why is it useful and how we can implement it ?

By applying DI ( Dependency injection )  we avoid creating a hard-coded dependency in our classes.

For example, let’s consider the situation where we implement a simple logging system which logs to a text file

We would write a class called FileLogger which could look like this :

public class FileLogger
{
    public LogMessage(string message)
    {
           //some logging code
    }
}

We use it in our code, let’s imagine we have a class which needs to log something :

public class WorkClass
{
     //some properties and methods

     public WorkClass()
     {
           //some code for this constructor
     }

     public void DoesSomethingAndLogs()
     {
            FileLogger fileLogger = new FileLogger();
            filelogger.LogMessage("a message");
     }
}

What we have now is a class with a hard-coded dependency. Why is this bad ?

Well, let’s imagine some real life scenarios. For example, what happens if later on we want to change the logging method from file to database, or we want to unit test the code.

We need a method of being able to tell the system which logging system to use, preferably without us having to go in and modify any code. Just imagine you work on a big project with lots of classes, all of them using logging. The last thing you want is go and change all of them should you decide to log to the database for example.

In order to accomplish this, we need to change the code a little so that we achieve a clear separation of concerns.

Step 1. Code against an interface.

First we create an interface for our logging system :

public interface ILogger
{
      void LogMessage(string message)
}

Step 2. Write an implementation of this interface which writes to files :

public FileLogger : ILogger
{
    LogMessage(string message)
    {
          //some code which writes the message to a text file
    }
}

Step 3 Re-write our WorkClass to use the interface and use DI in the process :

public class WorkClass
{
     ILogger logger;
     //some otherproperties and methods

    public WorkClass(ILogger logger)
    {
         this.logger = logger;
    }

    public ILogger GetLogger()
    {
        return this.logger;
    }

     public void DoesSomethingAndLogs()
     {            
            this.logger.LogMessage("a message");
     }
}

We have now used DI, the constructor takes an interface as a parameter, which could be any implementation of the ILogger interface.

The point is that now we don’t have a hard-coded dependency anymore. We can change the implementation, we can unit test it etc.

In another article we will look at how to set a specific interface implementation to be used by all our classes in the entire project.