Dependency Inversion Principle

The Dependency Inversion Principle (DIP) is one of the five principles of object-oriented design known as SOLID. It states that high-level modules should not depend on low-level modules. Both should depend on abstractions. Furthermore, abstractions should not depend on details; details should depend on abstractions.

• High-level modules: These are modules that contain complex logic or business rules.
• Low-level modules: These are modules that provide utility or perform specific tasks.
• Abstractions: Interfaces or abstract classes that define a contract for behavior.
• Dependency Injection: A technique used to implement DIP, allowing a class to receive its dependencies from an external source rather than creating them itself.

class ILogger {
    void Log(string message);
}

class FileLogger : ILogger {
    public void Log(string message) {
        // Code to log message to a file
    }
}

class DatabaseLogger : ILogger {
    public void Log(string message) {
        // Code to log message to a database
    }
}

class UserService {
    private readonly ILogger _logger;

    public UserService(ILogger logger) {
        _logger = logger;
    }

    public void CreateUser(string username) {
        // Logic to create a user
        _logger.Log($"User {username} created.");
    }
}

// Usage
ILogger logger = new FileLogger();
UserService userService = new UserService(logger);
userService.CreateUser("JohnDoe");
            

• Always program to an interface, not an implementation.
• Use Dependency Injection to manage dependencies.
• Avoid tight coupling between high-level and low-level modules.
• Favor composition over inheritance where possible.
• Keep abstractions simple and cohesive.