Skip to main content

SOLID (5/5) - Dependency inversion principle

Dependency inversion principle

In object-oriented design, the dependency inversion principle is a specific form of decoupling software modules. When following this principle, the conventional dependency relationships established from high-level, policy-setting modules to low-level, dependency modules are reversed, thus rendering high-level modules independent of the low-level module implementation details. The principle states:

  • High-level modules should not depend on low-level modules. Both should depend on abstractions (e.g., interfaces).
  • Abstractions should not depend on details. Details (concrete implementations) should depend on abstractions.
By dictating that both high-level and low-level objects must depend on the same abstraction, this design principle inverts the way some people may think about object-oriented programming.

The idea behind points A and B of this principle is that when designing the interaction between a high-level module and a low-level one, the interaction should be thought of as an abstract interaction between them. This not only has implications on the design of the high-level module, but also on the low-level one: the low-level one should be designed with the interaction in mind and it may be necessary to change its usage interface.

using System;
using System.Linq;
using System.Collections.Generic;

namespace dependencyinversion
{
    public enum Relationship { Parent, Child}

    public class Person
    {
        public string Name { get; set; }
    }

    public interface IRelationshipBrowser
    {
        IEnumerable<Person> FindAllChildrenOf(string name);       
    }

    public class Relationships : IRelationshipBrowser
    {
        private List<(Person, Relationship, Person)> relations
            = new List<(Person, Relationship, Person)>();

        public void AddParentAndChild(Person parent, Person child)
        {
            relations.Add((parent, Relationship.Parent, child));
            relations.Add((child, Relationship.Child, parent));
        }

        //public List<(Person, Relationship, Person)> Relations => relations;

        public IEnumerable<Person> FindAllChildrenOf(string name)
        {
            foreach (var r in relations.Where(
                x => x.Item1.Name == name &&
                    x.Item2 == Relationship.Parent))
            {
                yield return r.Item3;
            }
        }
    }

    public class Research
    {
        // public Research(Relationships relationships)
        // {
        //     var relations = relationships.Relations;

        //     foreach (var r in relations.Where(
        //         x => x.Item1.Name == "John" &&
        //             x.Item2 == Relationship.Parent))
        //     {
        //         Console.WriteLine($"John has a child called {r.Item3.Name}");
        //     }
        // }

        public Research(IRelationshipBrowser browser)
        {
            foreach (var person in browser.FindAllChildrenOf("John"))
            {
                Console.WriteLine($"John has a child called {person.Name}");
            }
        }

        static void Main(string[] args)
        {
            var parent = new Person { Name = "John"};
            var child1 = new Person { Name = "Chris"};
            var child2 = new Person { Name = "Mary"};

            var relationships = new Relationships();
            relationships.AddParentAndChild(parent, child1);
            relationships.AddParentAndChild(parent, child2);

            new Research(relationships);
        }
    }
}

Labels:

Comments

Post a Comment

Popular posts from this blog

Software Development

Software Development Agile Agile is an insurance policy for market changes. By designing your solution according to this methodology, your project remains flexible and is always ready for change. It is always better to correct the mistake early in the process. With this method, you keep your finger on the pulse of a dynamic market and changing user expectations. As a result, you can continuously adapt, change your strategy, and create a product that will be in demand by the target audience, even if preferences have changed during the development process. DevOps DevOps is one more way to optimize the development budget of your application. A key DevOps approach is that this practice and its culture allow team members to better interact with each other and the customer. The software development team and those responsible for the operation of the application share responsibilities clearly, and it helps you avoid shifting responsibilities from one team member to another. DevOps involves th...
Post a Comment
Read more

Fluent Builder Pattern

Fluent Builder Pattern Gamma Categorization: Creational Design Patten Summary: Extension of the Builder Pattern , that allows us to chain the operation calls. Problem examples We want to chain the operation calls for convenience purposes. Solution The methods now return the class itself. Sample Code Plese refer to the  Builder Pattern  article for the complete code. The main changes are made in the base abstract class of the ReportBuilder. public   abstract   class   ReportBuilder {      protected   Report   report ;      public   ReportBuilder   CreateReport ()     {          report  =  new   Report ();          return   this ;     }       public   ReportBuilder   SetHeader ( string   head...
Post a Comment
Read more

Facade Pattern

Facade Pattern  Gamma Categorization: Structural Design Pattern Summary: Provide a unified interface to a set of interfaces in a subsystem. Façade defines a higher-level interface that makes the subsystem easier to use. Sample Code Problem: We want a facade for our digital camera subsystems. public   class   DigitalCameraFacade {      ICamera   camera ;              IStorageManager   storageManager ;      INetworkManager   networkManager ;      public   DigitalCameraFacade ( ICamera   camera ,  IStorageManager   storageManager ,  INetworkManager   networkManager )     {          this . camera  =  camera ;                  ...
Post a Comment
Read more