Question

I am using the repository pattern to provide access to and saving of my aggregates.

The problem is the updating of aggregates which consist of a relationship of entities.

For example, take the Order and OrderItem relationship. The aggregate root is Order which manages its own OrderItem collection. An OrderRepository would thus be responsible for updating the whole aggregate (there would be no OrderItemRepository).

Data persistence is handled using Entity Framework 6.

Update repository method (DbContext.SaveChanges() occurs elsewhere):

public void Update(TDataEntity item)
{
    var entry = context.Entry<TDataEntity>(item);

    if (entry.State == EntityState.Detached)
    {
        var set = context.Set<TDataEntity>();

        TDataEntity attachedEntity = set.Local.SingleOrDefault(e => e.Id.Equals(item.Id));

        if (attachedEntity != null)
        {
            // If the identity is already attached, rather set the state values
            var attachedEntry = context.Entry(attachedEntity);
            attachedEntry.CurrentValues.SetValues(item);
        }
        else
        {
            entry.State = EntityState.Modified;
        }
    }
}

In my above example, only the Order entity will be updated, not its associated OrderItem collection.

Would I have to attach all the OrderItem entities? How could I do this generically?

Accepted Answer

Julie Lerman gives a nice way to deal with how to update an entire aggregate in her book Programming Entity Framework: DbContext.

As she writes:

When a disconnected entity graph arrives on the server side, the server will not know the state of the entities. You need to provide a way for the state to be discovered so that the context can be made aware of each entity’s state.

This technique is called painting the state.

There are mainly two ways to do that:

  • Iterate through the graph using your knowledge of the model and set the state for each entity
  • Build a generic approach to track state

The second option is really nice and consists in creating an interface that every entity in your model will implement. Julie uses an IObjectWithState interface that tells the current state of the entity:

 public interface IObjectWithState
 {
  State State { get; set; }
 }
 public enum State
 {
  Added,
  Unchanged,
  Modified,
  Deleted
 }

First thing you have to do is to set automatically to Unchanged every entities retrieved from the DB by hooking up an event adding a constructor in your Context class:

public YourContext()
{
 ((IObjectContextAdapter)this).ObjectContext
  .ObjectMaterialized += (sender, args) =>
 {
  var entity = args.Entity as IObjectWithState;
  if (entity != null)
  {
   entity.State = State.Unchanged;
  }
 };
}

Then change your Order and OrderItem classes to implement the IObjectWithState interface and call that ApplyChanges method accepting the root entity as parameter:

private static void ApplyChanges<TEntity>(TEntity root)
 where TEntity : class, IObjectWithState
{
 using (var context = new YourContext())
 {
  context.Set<TEntity>().Add(root);

  CheckForEntitiesWithoutStateInterface(context);

  foreach (var entry in context.ChangeTracker
  .Entries<IObjectWithState>())
  {
   IObjectWithState stateInfo = entry.Entity;
   entry.State = ConvertState(stateInfo.State);
  }
  context.SaveChanges();
 }
}

private static void CheckForEntitiesWithoutStateInterface(YourContext context)
{
 var entitiesWithoutState =
 from e in context.ChangeTracker.Entries()
 where !(e.Entity is IObjectWithState)
 select e;

 if (entitiesWithoutState.Any())
 {
  throw new NotSupportedException("All entities must implement IObjectWithState");
 }
}

Last but not least, do not forget to set the right state of your graph entites before calling ApplyChanges ;-) (you could even mix Modified and Deleted states within the same graph)

Julie proposes to go even further in his book:

you may find yourself wanting to be more granular with the way modified properties are tracked. Rather than marking the entire entity as modified, you might want only the properties that have actually changed to be marked as modified. In addition to marking an entity as modified, the client is also responsible for recording which properties have been modified. One way to do this would be to add a list of modified property names to the state tracking interface.

But as my answer is already too long, go read her book if you want to know more ;-)


Popular Answer

My opinionated (DDD specific) answer would be:

  1. Cut off the EF entities at the data layer.

  2. Ensure your data layer only returns domain entities (not EF entities).

  3. Forget about the lazy-loading and IQueryable() goodness (read: nightmare) of EF.

  4. Consider using a document database.

  5. Don't use generic repositories.

The only way I've found to do what you ask in EF is to first delete or deactivate all order items in the database that are a child of the order, then add or reactivate all order items in the database that are now part of your newly updated order.



Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Is this KB legal? Yes, learn why
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Is this KB legal? Yes, learn why