Ayende @ Rahien

Refunds available at head office

Limit your abstractions: Application Events–Proposed Solution #1

In my previous post, I explained why I really don’t the following.

image_thumb[3]

public class CargoInspectionServiceImpl : ICargoInspectionService 
{
  // code redacted for simplicity

 public override void InspectCargo(TrackingId trackingId)
 {
    Validate.NotNull(trackingId, "Tracking ID is required");

    Cargo cargo = cargoRepository.Find(trackingId);
    if (cargo == null)
    {
      logger.Warn("Can't inspect non-existing cargo " + trackingId);
      return;
    }

    HandlingHistory handlingHistory = handlingEventRepository.LookupHandlingHistoryOfCargo(trackingId);

    cargo.DeriveDeliveryProgress(handlingHistory);

    if (cargo.Delivery.Misdirected)
    {
      applicationEvents.CargoWasMisdirected(cargo);
    }

    if (cargo.Delivery.UnloadedAtDestination)
    {
      applicationEvents.CargoHasArrived(cargo);
    }

    cargoRepository.Store(cargo);
 }
}

Now, let us see one proposed solution for that. We can drop the IApplicationEvents.CargoHasArrived and IApplicationEvents.CargoWasMisdirected, instead creating the following:

public interface IHappenOnCargoInspection
{
   void Inspect(Cargo cargo);
}

We can have multiple implementations of this interface, such as this one:

public class MidirectedCargo : IHappenOnCargoInspection
{
   public void Inspect(Cargo cargo)
   {
        if(cargo.Delivery.Misdirected == false)
             return;

        // code to handle misdirected cargo.
   }
}

In a similar fashion, we would have a CargoArrived implementation, and the ICargoInspectionService would be tasked with managing the implementation of IHappenOnCargoInspection, probably through a container. Although I would probably replace it with something like:

container.ExecuteOnAll<IHappenOnCargoInspection>(i=>i.Inspect(cargo));

All in all, it is a simple method, but it means that now the responsibility to detect and act is centralized in each cargo inspector implementation. If the detection of misdirected cargo is changed, we know that there is just one place to make that change. If we need a new behavior, for example, for late cargo, we can do that by introducing a new class, which implement the interface. That gives us the Open Closed Principle.

This is better, but I still don’t like it. There are better methods than that, but we will discuss them in another post.

Comments

Frank Quednau
02/07/2012 08:32 AM by
Frank Quednau

That's all fine and such, but you haven't limited your abstractions, you sliced the system differently. I admit it is a more favorable structure for the reasons you state, alas your code also has abstractions. in fact every time you extract a method or introduce a new class you are introducing an abstraction.

Hence I would say it is not about limiting your abstractions, it is about choosing the correct ones.

Ryan Heath
02/07/2012 08:38 AM by
Ryan Heath

One thing what we miss from the original code is the sequence of event handling. I do not know if it is really important but your (current) solution doesn't safeguard for those situations.

// Ryan

jjchiw
02/07/2012 11:58 AM by
jjchiw

This is like the Chain of Responsability pattern....

Rafal
02/07/2012 12:04 PM by
Rafal

I don't understand one thing: why do you insist on having the Inspect(Cargo) method? It's unclear who should call it and when and it also shouldn't be called multiple times or event duplication will occur (and it looks innocent and safe to inspect a cargo as many times as you want). Why the event logic isn't triggered by actual cargo events occuring, for example by information about cargo being delivered/lost/mis-delivered/and so on and instead you are relying on analyzing event history during inspection?

Mani
02/07/2012 12:26 PM by
Mani

Not sure where the responsibility is pushed to now. Could we have bit more of this code snippet

Craig Wilson
02/07/2012 01:14 PM by
Craig Wilson

Yeah, not sure this is the correct method. Events should get raised from inside entities/aggregates when it makes sense, not services. In this particular case, there is already a place to raise these 2 events; cargo.DeriveDeliveryProgress.

Ultimately though, when looking at this, I believe the abstractions are just wrong. We shouldn't need to call DeriveDeliveryProgress to figure out that the cargo was misdirected. It seems there are some missing concepts in here. Alas, I'm not a domain expert so I can't say for sure, but this whole bit of code seems odd.

Ayende Rahien
02/07/2012 09:21 PM by
Ayende Rahien

Rafal, Baby steps, I am doing this one step at a time.

Comments have been closed on this topic.