Entity Framework 4.1 DbContext Override SaveChanges to Audit Property Change

Question

I am trying to implement a constrained 'audit log' of property changes to a properties in a set of classes. I have successfully found out how to set CreatedOn|ModifiedOn type properties, but am failing to find out how to 'find' the property that has been modified.

Example:

public class TestContext : DbContext
{
    public override int SaveChanges()
    {
        var utcNowAuditDate = DateTime.UtcNow;
        var changeSet = ChangeTracker.Entries<IAuditable>();
        if (changeSet != null)
            foreach (DbEntityEntry<IAuditable> dbEntityEntry in changeSet)
            {

                switch (dbEntityEntry.State)
                {
                    case EntityState.Added:
                        dbEntityEntry.Entity.CreatedOn = utcNowAuditDate;
                        dbEntityEntry.Entity.ModifiedOn = utcNowAuditDate;
                        break;
                    case EntityState.Modified:
                        dbEntityEntry.Entity.ModifiedOn = utcNowAuditDate;
                        //some way to access the name and value of property that changed here
                        var changedThing = SomeMethodHere(dbEntityEntry);
                        Log.WriteAudit("Entry: {0} Origianl :{1} New: {2}", changedThing.Name,
                                        changedThing.OrigianlValue, changedThing.NewValue)
                        break;
                }
            }
        return base.SaveChanges();
    }
}

So, is there a way to access the property that changed with this level of detail in EF 4.1 DbContext?

Slauma · Accepted Answer · 2011-09-07T14:23:47.240

Very, very rough idea:

foreach (var property in dbEntityEntry.Entity.GetType().GetProperties())
{
    DbPropertyEntry propertyEntry = dbEntityEntry.Property(property.Name);
    if (propertyEntry.IsModified)
    {
        Log.WriteAudit("Entry: {0} Original :{1} New: {2}", property.Name,
            propertyEntry.OriginalValue, propertyEntry.CurrentValue);
    }
}

I have no clue if this would really work in detail, but this is something I would try as a first step. Of course there could be more then one property which has changed, therefore the loop and perhaps multiple calls of WriteAudit.

The reflection stuff inside of SaveChanges could become a performance nightmare though.

Edit

Perhaps it is better to access the underlying ObjectContext. Then something like this is possible:

public class TestContext : DbContext
{
    public override int SaveChanges()
    {
        ChangeTracker.DetectChanges(); // Important!

        ObjectContext ctx = ((IObjectContextAdapter)this).ObjectContext;

        List<ObjectStateEntry> objectStateEntryList =
            ctx.ObjectStateManager.GetObjectStateEntries(EntityState.Added
                                                       | EntityState.Modified 
                                                       | EntityState.Deleted)
            .ToList();

       foreach (ObjectStateEntry entry in objectStateEntryList)
       {
           if (!entry.IsRelationship)
           {
               switch (entry.State)
               {
                   case EntityState.Added:
                       // write log...
                       break;
                   case EntityState.Deleted:
                       // write log...
                       break;
                   case EntityState.Modified:
                   {
                       foreach (string propertyName in
                                    entry.GetModifiedProperties())
                       {
                           DbDataRecord original = entry.OriginalValues;
                           string oldValue = original.GetValue(
                               original.GetOrdinal(propertyName))
                               .ToString();

                           CurrentValueRecord current = entry.CurrentValues;
                           string newValue = current.GetValue(
                               current.GetOrdinal(propertyName))
                               .ToString();

                           if (oldValue != newValue) // probably not necessary
                           {
                               Log.WriteAudit(
                                   "Entry: {0} Original :{1} New: {2}",
                                   entry.Entity.GetType().Name,
                                   oldValue, newValue);
                           }
                       }
                       break;
                   }
               }
           }
       }
       return base.SaveChanges();
    }
}

I've used this myself in EF 4.0. I cannot find a corresponding method to GetModifiedProperties (which is the key to avoid the reflection code) in the DbContext API.

Edit 2

Important: When working with POCO entities the code above needs to call DbContext.ChangeTracker.DetectChanges() at the beginning. The reason is that base.SaveChanges is called too late here (at the end of the method). base.SaveChanges calls DetectChanges internally, but because we want to analyze and log the changes before, we must call DetectChanges manually so that EF can find all modified properties and set the states in the change tracker correctly.

There are possible situations where the code can work without calling DetectChanges, for example if DbContext/DbSet methods like Add or Remove are used after the last property modifications are made since these methods also call DetectChanges internally. But if for instance an entity is just loaded from DB, a few properties are changed and then this derived SaveChanges is called, automatic change detection would not happen before base.SaveChanges, finally resulting in missing log entries for modified properties.

I've updated the code above accordingly.

This works, but it seems that all properties are modified according to this. Will investigate further, but fine for original question. I think this gives me what I need. — James Pogran, Jun 01 '11 at 18:32
This does not work for me. The old values are always empty. Is this working only for POCO and 4.1 and up? — Jonx, Feb 06 '12 at 22:06
@Jonx: Yes, it's EF 4.1 (`DbContext`) and POCO. You can do something similar though for <= EF 4.0 (`ObjectContext`), the only difference is that you don't overwrite `SaveChanges` but implement an event handler (`OnSavingChanges` or similar, I don't remember exactly). — Slauma, Feb 07 '12 at 21:20

score 7 · Answer 2 · answered May 27 '11 at 20:32

7

You can use the methods Slauma suggests but instead of overriding the SaveChanges() method, you can handle the SavingChanges event for a much easier implementation.

answered May 27 '11 at 20:32

Jay

6,224
4
20
23

Oh, good point. Actually, my code snippet above comes from a `SavingChanges` handler, I forgot that. But why does it make things easier? Isn't it basically the same what you need to do to write the log? – Slauma May 27 '11 at 20:45
It makes it easier if you needed to add to it, instead of modifying your override, you can just add a handler. You also don't have to worry about passing on the original functionality, which I believe is missing from your example. The objects would never actually get saved. If you simply wrote a handler you wouldn't have to worry about that. – Jay May 27 '11 at 20:51
True, thanks, I forgot to call `SaveChanges` of the base class (added now). (It was because I copied the main parts of the snippet from my actual `SavingChanges` handler.) – Slauma May 27 '11 at 20:58
For an example see here... How to: Execute Business Logic When Saving Changes http://msdn.microsoft.com/en-us/library/cc716714.aspx – Jonx Feb 06 '12 at 21:18
I'm trying to get the fields that are defined when EntityState is Added and similarly the fields that are used when EntityState is Deleted but GetModifiedProperties doesn't contain anything. One could surely use reflection to get it but is there a better way? – howardlo Aug 18 '15 at 17:26
@hlo You can use the `DbContext.Entry(object)` method to grab the entity's change tracking information, which contains a `State` property. – Jay Aug 19 '15 at 17:41

Vland · Answer 3 · 2013-01-05T00:56:31.623

I really like Slauma's solution. I usually prefer to keep track of the modified table and records primary key(s) tho. This is a very simple method you can use to do that, calling getEntityKeys(entry)

    public static string getEntityKeys(ObjectStateEntry entry)
    {
        return string.Join(", ", entry.EntityKey.EntityKeyValues
                                .Select(x => x.Key + "=" + x.Value));
    }

score 1 · Answer 4 · edited May 23 '17 at 11:53

1

It seems Slauma's answer does not audit changes to inner properties of a complex type property.

If this is a problem for you, my answer here might be helpful. If the property is a complex one and it has changed I serialise the whole complex property into the audit log record. It's not the most efficient solution but it's not too bad and it gets the job done.

edited May 23 '17 at 11:53

Community

1
1

answered Nov 18 '11 at 14:03

dan

2,378
18
17

That might be because complex types are not proxied, ref https://blog.oneunicorn.com/2012/03/13/secrets-of-detectchanges-part-4-binary-properties-and-complex-types/ – Tim Abell Jun 01 '16 at 12:28

score 0 · Answer 5 · edited May 10 '13 at 11:16

0

See Using Entity Framework 4.1 DbContext Change Tracking for Audit Logging.

With DbEntityEntry. Detail audit for add, remove, modify

edited May 10 '13 at 11:16

Taky

5,284
1
20
29

answered May 10 '13 at 10:51

Khurshid Rustamov

9
2

1

Whilst this may theoretically answer the question, [it would be preferable](http://meta.stackexchange.com/q/8259) to include the essential parts of the answer here, and provide the link for reference. – vonbrand May 10 '13 at 11:11

Entity Framework 4.1 DbContext Override SaveChanges to Audit Property Change

5 Answers5

Linked