How to find a dirty property in Entity Framework 4.0

In the new Entity Framwork release, Microsoft finally added support for POCO or Persistance Ignorent (PI) objects. It's now possible to generate Proxies for my POCO's. This has the advantage that the change tracking is automatically done for me.

In my daily work, I often feel the need to find out if a property is dirty, before I let the ObjectContext save my changes. For example, when a customers address property is dirty, I want to create an AddressChange record. In EF4, there's a method ObjectStateEntry.GetModifiedProperties(). This method returns an IEnumerable of strings that contain the propertynames which are changed.

Assume we have the following code:

using (DBTestOrdersContext ctx = new DBTestOrdersContext())
{
   ctx.ContextOptions.LazyLoadingEnabled = true;
   ctx.ContextOptions.ProxyCreationEnabled = true;

   Order order = ctx.GetObjectById<Order>(1);
   order.OrderNumber += 1;
}

I think we can assume that the OrderNumber property is dirty now. So let's write a method that finds a dirty property:

private bool IsDirtyPropertyNotWorking(ObjectContext ctx, object entity, string propertyName)
{
   ObjectStateEntry entry;
   if (ctx.ObjectStateManager.TryGetObjectStateEntry(entity, out entry))
   {
       IEnumerable changedNames = entry.GetModifiedProperties();

       return changedNames.Any(x => x == propertyName);
   }
   return false;
}

I expected this method to return true for my OrderNumber property, but unfortunately, nothing is what it seems in EF4. It seems that we first have to call ObjectContext.DetectChanges() before it shows up in the ObjectStateEntry.GetModifiedProperties() list.

private bool IsDirtyPropertyWorking(ObjectContext ctx, object entity, string propertyName)
{
   ObjectStateEntry entry;
   if (ctx.ObjectStateManager.TryGetObjectStateEntry(entity, out entry))
   {
       ctx.DetectChanges();

       IEnumerable<string> changedNames = entry.GetModifiedProperties();

       return changedNames.Any(x => x == propertyName);
   }
   return false;
}

Microsoft admits that ObjectContext.DetectChanges can be a very expensive operation, because the complete ObjectContext has to be 'scanned' for modifications. Another disadvantage is that changes on all other entities in my Context are also detected, and there are scenarios that I don't want that yet. So I decided to write an IsDirtyProperty method that does not have to call ObjectContext.DetectChanges():

private bool IsDirtyProperty(ObjectContext ctx, object entity, string propertyName)
{
   ObjectStateEntry entry;
   if (ctx.ObjectStateManager.TryGetObjectStateEntry(entity, out entry))
   {
       int propIndex = this.GetPropertyIndex(entry, propertyName);

       if (propIndex != -1)
       {
           var oldValue = entry.OriginalValues[propIndex];
           var newValue = entry.CurrentValues[propIndex];

           return !Equals(oldValue, newValue);
       }
       else
       {
           throw new ArgumentException(String.Format("Cannot find original value
                   for property '{0}' in entity entry '{1}'",
                   propertyName,
                   entry.EntitySet.ElementType.FullName));
       }
   }

   return false;
}


private int GetPropertyIndex(ObjectStateEntry entry, string propertyName)
{
   OriginalValueRecord record = entry.GetUpdatableOriginalValues();

   for (int i = 0; i <> record.FieldCount; i++)
   {
       FieldMetadata metaData = record.DataRecordInfo.FieldMetadata[i];
       if (metaData.FieldType.Name == propertyName)
       {
           return metaData.Ordinal;
       }
   }

   return -1;
}

Of course you can decide to make these Extension Methods on ObjectContext or ObjectStateEntry

Best regards
Harm Neervens