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);

        }

    }

}