是否有可能检测到EF6中实体的引用属性何时发生了变化？

Question

This seems to be a common problem but I cannot find any answer that makes sense to me.

I want to create an Audit system in an app using EF6. Detectng changes in simple properties is not a problem and creating an audit entry with the original values in just before the new values are saved is fine.

However I also need to track changes to reference properties, ie The country (which links to a different entity) has changed.

dbChangeTracker does not pick these changes up and even if it did there seems to be no way of getting at the original value.

Some people point in the direction of ObjectContext for a solution, but I cannot see how that will help. Any help?

Other people seem to indicate that I should put the FK property explicitly on the Entity, ie Country_Id.

Is that the solution?

All help greatly appreciated.

Cheers Mike

Answer 1

Implement a method for retrieving metadata information about certain property of EntityObject:

private static EdmMember GetEdmMember<TEntity>(this ObjectContext context, TEntity entityContainer, string propertyName)
 {
    EdmMember edmMember = null;
    EntityType entityType = context.MetadataWorkspace.GetItem<EntityType>(entityContainer.GetType().FullName, DataSpace.CSpace);
    IEnumerable<EdmMember> edmMembers = entityType.MetadataProperties.First(p => p.Name == "Members").Value as IEnumerable<EdmMember>;
    edmMember = edmMembers.FirstOrDefault(item => item.Name == propertyName);
    if (edmMember == null)
        throw new ArgumentException(
                            string.Format("Cannot find property metadata: property '{0}' in '{1}' entity object", propertyName, entityType.Name));
    return edmMember;
}

The MetadataWorkspace class is a central runtime API that you can use to interact with the Entity Data Model (EDM) metadata in the context of an application. For more information, see http://msdn.microsoft.com/en-us/library/bb387116%28v=vs.110%29.aspx

Next, implement the IsPropertyChanged method like this:

public static bool IsPropertyChanged<TEntity>(this ObjectContext context, TEntity entityContainer, string propertyName)
            where TEntity : IEntityWithKey, IEntityWithRelationships
{
    bool isModified = false;
    EdmMember edmMember = GetEdmMember(context, entityContainer, propertyName);

    switch (edmMember.BuiltInTypeKind)
    {
        case BuiltInTypeKind.NavigationProperty: /*navigation property*/
                        {
                            NavigationProperty navigationProperty = edmMember as NavigationProperty;
                            IRelatedEnd sourceRelatedEnd = entityContainer.RelationshipManager.GetRelatedEnd(navigationProperty.RelationshipType.FullName,
                                                                                                             navigationProperty.ToEndMember.Name) as IRelatedEnd;
                            EntityState state = (EntityState.Added | EntityState.Deleted);
                            IEnumerable<IGrouping<IRelatedEnd, ObjectStateEntry>> relationshipGroups = GetRelationshipsByRelatedEnd(context, entityContainer, state);
                            foreach (var relationshipGroup in relationshipGroups)
                            {
                                IRelatedEnd targetRelatedEnd = (IRelatedEnd)relationshipGroup.Key;
                                if (targetRelatedEnd.IsEntityReference()
                                    && targetRelatedEnd.IsRelatedEndEqual(sourceRelatedEnd))
                                {
                                    isModified = true;
                                    break;
                                }
                            }
                        } break;

        case BuiltInTypeKind.EdmProperty: /*scalar field*/
                        {
                            ObjectStateEntry containerStateEntry = null;
                            isModified = context.IsScalarPropertyModified(propertyName, entityContainer, out containerStateEntry);
                        } break;

        default:
                        {
                            throw new InvalidOperationException("Property type not supported");
                        }
    }

    return isModified;
}

and a method for scalar property changes tracking:

private static bool IsScalarPropertyModified(this ObjectContext context, string scalarPropertyName, IEntityWithKey entityContainer, out ObjectStateEntry containerStateEntry)
                {
                    bool isModified = false;
                    containerStateEntry = context.ObjectStateManager.GetObjectStateEntry(entityContainer.EntityKey);
                    IEnumerable<string> modifiedProperties = containerStateEntry.GetModifiedProperties();

                    string changedProperty = modifiedProperties.FirstOrDefault(element => (element == scalarPropertyName));
                    isModified = (null != changedProperty);

                    if (isModified) 
                    {
                        object originalValue = containerStateEntry.OriginalValues[changedProperty];
                        object currentValue = containerStateEntry.CurrentValues[changedProperty];
                        //sometimes property can be treated as changed even though you set the same value it had before
                        isModified = !object.Equals(originalValue, currentValue);
                    }

                    return isModified;
                }

Tracking scalar properties is simple, right. When you have foreign keys included in your entities you may always check if those have been changed (make sure FK fields in your objects remain in sync with navigation properties, which is often an issue). The navigation property case in the code above should give you an idea of implementation, well it should work in most cases.

PS. If you are working on implementation of audit system, interceptors introduced in EF 6.1 is what you may want to have a look at (just an idea) http://msdn.microsoft.com/en-US/data/jj556606#Interceptors

Answer 2

I would suggest that tracking changes to the FK properties at the time you save changes is sufficient. After all, if I were doing this I would be interested in change in how one entity relates to another. Here's a really simple implementation of that which assumes that all FK properties end with "Id" and are integers.

foreach (var entry in context.ChangeTracker.Entries())
{
    foreach (var prop in entry.Entity.GetType().GetProperties())
    {
        if (prop.Name.EndsWith("Id") && 
            !prop.PropertyType.IsAssignableFrom(typeof(int)) && 
            context.Entry(entry.Entity).Property(prop.Name).IsModified)
        {
            // Log things like old value and new:
            var propEntry = context.Entry(entry.Entity).Property(prop.Name);
            var currentValue = propEntry.CurrentValue;
            var oldValue = propEntry.OriginalValue;
        }

    }
}