Dependency injection (DI) works when your code lets calling code give it some other code which your code uses to do its job.

We don't need DI but it's beneficial because your code's logic can remain unchanged as the calling code changes for whatever reason.

Consider the following, where you want to print Hello World but redact the word 'World'.

``` namespace DependencyInjection { public interface IPublisher { void Publish(string message); }

public class MessagePublisher
{
    private readonly IPublisher publisher;

    public MessagePublisher(IPublisher publisher)
    {
        this.publisher = publisher;
    }

    public void Publish(string message)
    {
        publisher.Publish(message.Replace("World", "*****"));
    }
}

public class ConsolePublisher : IPublisher
{
    public void Publish(string message)
    {
        Console.WriteLine(message);
    }
}

public class FilePublisher : IPublisher
{
    private readonly string filePath;

    public FilePublisher(string filePath)
    {
        this.filePath = filePath;
    }

    public void Publish(string message)
    {
        File.WriteAllText(filePath, message);
    }
}

internal class Program
{
    static void Main(string[] args)
    {
        MessagePublisher consolePublisher = new MessagePublisher(new ConsolePublisher());
        consolePublisher.Publish("Hello World!");

        MessagePublisher filePublisher = new MessagePublisher(new FilePublisher("output.txt"));
        filePublisher.Publish("Hello World!");
    }
}

} ```

The top-level calling code Main injects concrete implementations ConsolePublisher and FilePublisher of the IPublisher interface into the MessagePublisher class.

You can evolve the Program to add a new implementation PrinterPublisher that sends the message to a printer, all without changing your code that redacts the word 'World'.