Control chain with entity

Question

I have audit fields in each table (InsertedBy, InsertedDate, UpdateBy and UpdateDate), I am creating a solution to reduce redundancy before overriding savechange ():

public override int SaveChanges() { foreach (var entry in ChangeTracker.Entries().Where(e => e.State == System.Data.Entity.EntityState.Added || e.State == System.Data.Entity.EntityState.Modified)) { Auditing.ApplyAudit(entry, User); } return base.SaveChanges(); } public class Auditing { public static void ApplyAudit(DbEntityEntry entityEntry, int User) { Type type = entityEntry.Entity.GetType(); if (entityEntry.State.ToString() == "Added") { if (type.GetProperty("InsertedBy") != null) { entityEntry.Property("InsertedBy").CurrentValue = User; } if (type.GetProperty("InsertedDate") != null) { entityEntry.Property("InsertedDate").CurrentValue = DateTime.Now; } } else if (entityEntry.State.ToString() == "Modified") { if (type.GetProperty("InsertedBy") != null) { entityEntry.Property("InsertedBy").IsModified = false; } if (type.GetProperty("InsertedDate") != null) { entityEntry.Property("InsertedDate").IsModified = false; } if (type.GetProperty("UpdatedBy") != null) { entityEntry.Property("UpdatedBy").CurrentValue = User; } if (type.GetProperty("UpdatedDate") != null) { entityEntry.Property("UpdatedDate").CurrentValue = DateTime.Now; } } } } 

The question arises: does it use reflection in each object before changing or adding waste to memory and performance? if so, is there a best practice for this? is this another piece of code better in performance or just use reflection?

 public static void ApplyAudit(DbEntityEntry entityEntry, long User) { if (entityEntry.State.ToString() == "Added") { entityEntry.Property("InsertedBy").CurrentValue = User; entityEntry.Property("InsertedDate").CurrentValue = DateTime.Now; } else if (entityEntry.State.ToString() == "Modified") { entityEntry.Property("InsertedBy").IsModified = false; entityEntry.Property("InsertedDate").IsModified = false; entityEntry.Property("UpdatedBy").CurrentValue = User; entityEntry.Property("UpdatedDate").CurrentValue = DateTime.Now; } } 

is entityEntry.Property ("InsertedBy") uses reflection?

Answer 1

Reflection is slow (slow subjective), and if you want to avoid it, you need to get rid of such code, as shown below:

 Type type = entityEntry.Entity.GetType(); if (type.GetProperty("InsertedBy") != null) 

Even if this was not the case, the code above is still buggy, because the programmer may mistakenly write InsertBy instead of InsertedBy . This can be easily avoided using the compiler using the approach below.

Use the interface and implement it in all objects requiring audit.

 public interface IAuditable { string InsertedBy { get; set; } // ... other properties } public class SomeEntity : IAuditable { public string InsertedBy { get; set; } } public class Auditor<TAuditable> where TAuditable : IAuditable { public void ApplyAudit(TAuditable entity, int userId) { // No reflection and you get compiler support if (entity.InsertedBy == null) { // whatever } else { // whatever } } } 

As mentioned in the comments, you will get compiler support, and reflections are no longer used. I would take another step and not go through int userId . I will give the code to define userId and put it in this class. Thus, the class is self-sufficient, and clients do not need to provide it with this information.

Using:

 var e = new SomeEntity(); var auditor = new Auditor<SomeEntity>(); auditor.ApplyAudit(e, 1); // 1 is userId, I am just hardcoding for brevity 

Or use it out of context:

 public override int SaveChanges() { var auditables = ChangeTracker.Entries().Where(e => e.State == System.Data.Entity.EntityState.Added || e.State == System.Data.Entity.EntityState.Modified) .OfType<IAuditable>(); var auditor = new Auditor<IAuditable>(); foreach (var entry in auditables) { // 1 is userId, I am just hardcoding for brevity auditor.ApplyAudit(entry, 1); } return base.SaveChanges(); } 

This means that all entities that are subject to audit will need to implement the IAuditable interface. EF generates partial classes for your objects, but does not modify these partial classes, because the next time you run a custom tool, it will be destroyed.

Instead, create another incomplete class with the same name and implement IAuditable .

 public partial class SomeEntity : IAuditable {} 

An even better approach is to create a custom T4 template, so it creates a partial class with code : IAuditable . Please see this article to learn how to do this.