Ποια μηχανισμοί βοηθούν στην τήρηση της αρχής της…

The Dependency Inversion Principle (DIP) is adhered to through several interconnected mechanisms:

Abstractions:
- Interfaces and abstract classes define contracts, not concrete implementations. High-level modules depend on these abstractions, not on low-level concrete classes.

**Dependency Injection (DI):

Instead of a class creating its dependencies directly, they are passed to it from outside. This allows easy replacement of dependency implementations without changing the class code.

C# syntax for constructor injection:

public class HighLevelModule
{
    private readonly ILowLevelDependency _dependency; // Dependency on abstraction

    public HighLevelModule(ILowLevelDependency dependency) // Injection via constructor
    {
        _dependency = dependency;
    }

    public void PerformAction()
    {
        _dependency.Execute(); // Using dependency via abstraction
    }
}

C# syntax for property injection:

public class AnotherHighLevelModule
{
    public ILowLevelDependency Dependency { get; set; } // Injection via property

    public void PerformAction()
    {
        Dependency?.Execute(); // Using dependency via abstraction
    }
}

C# syntax for method injection:

public class YetAnotherHighLevelModule
{
    public void PerformAction(ILowLevelDependency dependency) // Injection via method
    {
        dependency.Execute(); // Using dependency via abstraction
    }
}

IoC Containers (Inversion of Control Containers):

Frameworks that automate the process of managing dependencies and injection. They handle creating class instances and resolving their dependencies according to configured rules.

Example of using a popular IoC container (e.g., StructureMap):

// Registering dependency
// container.Configure(cfg =>
// {
//     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Register abstraction and its concrete implementation
//     cfg.For<HighLevelModule>().Use<HighLevelModule>();
// });

// Getting an instance of the class with dependencies resolved
// var highLevelModule = container.GetInstance<HighLevelModule>();
// highLevelModule.PerformAction();

Factories:

Classes responsible for creating instances of other classes. They can hide the details of creating specific implementations and return abstractions.

C# example syntax for using a factory:

public interface ILowLevelDependencyFactory
{
    ILowLevelDependency Create();
}

public class LowLevelDependencyFactory : ILowLevelDependencyFactory
{
    public ILowLevelDependency Create()
    {
        return new ConcreteLowLevelDependency(); // Creating a specific implementation
    }
}

public class HighLevelModuleWithFactory
{
    private readonly ILowLevelDependency _dependency;

    public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Injecting factory
    {
        _dependency = factory.Create(); // Using factory to create dependency
    }

    public void PerformAction()
    {
        _dependency.Execute();
    }
}

Law of Demeter (Principle of Least Knowledge):
- Although not a direct mechanism of DIP, adhering to this principle (talking only to your immediate "friends") often reduces direct dependencies and facilitates the application of DIP.

Ποια μηχανισμοί βοηθούν στην τήρηση της αρχής της αντιστροφής των εξαρτήσεων;