Anemic domain models and domain services injection

Question

The anemic domain model is described as an anti-pattern in domain driven design by Martin Fowler. To have business logic on the domain models often domain services are used. But injecting domain services into domain models is considered harmful by Vaughn Vernon (see "Implementing Domain-Driven Design, Page 387).

In my opinion those opinions are contradictory, is this true? How can both points be considered?

Is it really rich domain model with domain services injected vs. anemic domain model and normal domain services?

Answer 1

An anemic model is simply a data container. It doesn't contain behavior. (This might actually be considered a good thing in the functional paradigm.) The opposite of an anemic model is not a model injected full of domain services. You're describing two extremes -- both are bad.

If you have an anemic model, you're not fully embracing what OOP offers. If you start injecting services into those models, you're likely injecting concerns that don't belong there. Either that or your model is more anemic than you think. Why else would you need the service other than it provides something that's required but missing? (Missing might mean anemic.)

Avoiding both "tells" leads to stronger design. Do you have something in a service that a model needs? Maybe it should be moved to the model. If not, maybe you should reconsider your concerns. A model's behavior should work inside the model. It should mainly (if not only) concern itself with members. But remember, there will still be things that work on or with the model. For example, models shouldn't be opening TCP connections or listening for UI events, even if they're somehow involved. That's someone else's responsibility and that someone never belongs inside the model.

Answer 2

It's not contradictory. Both proponents would like you to put your actual code in the domain object itself.

ie.

public class Order
{
    private string status = "not bought";
    public void Buy()
    {
        this.status = "bought";
    }
}

vs ADM

public class Order
{
    public string Status = "not bought";
}

public class BuyingService
{
    public Order Buy(Order order)
    {
         Order o = new Order();
         o.status = "bought";
         return o;
    }
}

vs injected services

public class Order
{
    public Order(IBuyingService bs)
    {
        _bs = bs;
    }
    private IbuyingService _bs;
    private string status = "not bought";
    public void Buy()
    {
        this.status = _bs.Buy();
    }
}

public class BuyingService : IBuyingService
{
    public string Buy()
    {
         return = "bought";
    }
}

Frankly though each approach has pluses and minuses. The one you choose is largely a matter of personal preference