Tag: choose

I have a few objects that should communicate between each other. I also want to have my code unit tested.
I am questioning how I should handle their communication:

• Should I make one instantiate the other one?
• Should I pass one in the constructor of the other one?
• Should I make them communicate via events/a observable pattern?

What criteria should I use to choose between those options?

To illustrate this, let me give an example for each one of those approaches:

Example of one object instantiating another one

Code Sample:

public class Restaurant
{
    private Kitchen _kitchen;

    public Restaurant()
    {
        this._kitchen = new Kitchen();
    }

    public void Prepare(Order order)
    {
        foreach(Meal meal in order.Meals)
            this._kitchen.Cook(meal);
    }
}

public class Kitchen
{
    public void Cook(Meal meal)
    {
         // cooking magic goes here
    }

}

public class App
{
    public void Main()
    {
        Restaurant restaurant = new Restaurant();

        restaurant.Prepare(new Order());
    }
}

Pros:

• App does not know about Kitchen

Cons:

• Unit testing Restaurant now requires testing for the behavior produced by Kitchen

Example using dependency injection via constructor

Code Sample:

public class Restaurant
{
    private ICooker _cooker;

    public Restaurant(ICooker cooker)
    {
        this._cooker = cooker;
    }

    public void Prepare(Order order)
    {
        foreach(Meal meal in order.Meals)
            this._cooker.Cook(meal);
    }
}

public class Kitchen: ICooker
{
    public void Cook(Meal meal)
    {
         // cooking magic goes here
    }

}

public interface ICooker
{
    void Cook(Meal meal);
}

public class App
{
    public void Main()
    {
        Kitchen kitchen = new Kitchen();
        Restaurant restaurant = new Restaurant(kitchen);

        restaurant.Prepare(new Order());
    }
}

Pros

• Kitchen can be unit tested separately from Restaurant.
• Inversion of control

Cons:

• App now has to know how to instantiate Kitchen.
• There is still some coupling between Restaurant and Kitchen.
• Mocking is necessary when unit testing Restaurant

Example using dependency via events

public class Restaurant
{
    public event Action<Meal> Cooked;

    public void Prepare(Order order)
    {
        foreach(Meal meal in order.Meals)
            this.Cooked?.Invoke(meal);

    }
}

public class Kitchen
{
    public void Cook(Meal meal)
    {
         // cooking magic goes here
    }

}

public class App
{
    public void Main()
    {
        Kitchen kitchen = new Kitchen();
        Restaurant restaurant = new Restaurant();

        restaurant.MealCooked += kitchen.Cook;

        restaurant.Prepare(new Order());
    }
}

Pros:

• Removes the necessity of mocking when unit testing Restaurant
• Makes Restaurant and Kitchen really decoupled.

Cons:

• App not only has to know how to instantiate Kitchen but also has to connect the related events and listeners.

Question

Is there a preferable approach? What criteria should I use to choose between those options?