Loosely coupling composite object nodes and their dependencies

Question

Lets say I have a set of conditional requirements that can be nested inside of each other in a tree like structure, but all of the requirements need to communicate with different subsystems to find out if they are fulfilled. For instance one requirement might check if a certain inventory item exists, one might check an object for a certain attribute, one might check an event system to see if a certain event has fired etc. How could you model this so that you can traverse the tree as a part-whole hierarchy but also allow each node to communicate with the subsystem it needs to?

Answer 1

It seems like you should model the aggregation and later use dependency injection (see What is dependency injection?) to require whichever object that should fulfill the desired functionalities.

Each node would be like a domain model.

Something like this:

public class A
{
    // You inject some service IServiceX
    public A(IServiceX serviceX) 
    {
        ServiceX = serviceX;
    }

    private IServiceX ServiceX { get; }

    // B is associated to A
    public B B { get; set; }

    // So you can do some stuff calling the whole ServiceX
    public void DoStuff()
    {
         ServiceX.DoWhatever();
    }
}

public class B 
{
    public B(IServiceY serviceY) 
    {
        ServiceY = serviceY;
    }

    private IServiceY ServiceY { get; }

    // C is associated to B
    public C C { get; set; }

    public void DoStuff()
    {
         ServiceY.DoWhatever();
    }
}

public class C
{    
    public C(IServiceZ serviceZ) 
    {
        IServiceZ = serviceZ;
    }

    private IServiceZ IServiceZ { get; }

    public void DoStuff()
    {
         IServiceZ.DoWhatever();
    }
}

Obviously, you could inject more than a service into some of these aggregates. Since each aggregate gets associated with other one, you should be able to traverse the tree too.