Round #242

Add auditing via SaveChanges override that captures before/after state

To add auditing via `SaveChanges` override in Entity Framework Core, you can capture the before and after state of entities by overriding the `SaveChanges` method in your `DbContext` class. Here's an example implementation: ```csharp using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; public class MyDbContext : DbContext { public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) { // Get the current date and time var now = DateTime.UtcNow; // Get the entries that have been modified var entries = ChangeTracker.Entries() .Where(e => e.Entity != null && (e.State == EntityState.Added || e.State == EntityState.Modified || e.State == EntityState.Deleted)); // Iterate over the entries foreach (var entry in entries) { // Get the entity type var entityType = entry.Entity.GetType(); // Get the entity's properties var properties = entityType.GetProperties(); // Get the entity's primary key var primaryKey = entityType.GetProperties().FirstOrDefault(p => p.GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.KeyAttribute), true).Any()); // Get the entity's ID var entityId = primaryKey.GetValue(entry.Entity); // Get the entity's current state var currentState = entry.CurrentValues.ToObject(); // Get the entity's original state var originalState = entry.OriginalValues.ToObject(); // Create an audit log entry var auditLogEntry = new AuditLogEntry { EntityId = entityId, EntityType = entityType.Name, EntityName = entry.Entity.ToString(), ChangedBy = "Your Application", // Replace with the actual user ChangedDate = now, ChangeType = entry.State.ToString(), OriginalState = originalState, CurrentState = currentState }; // Add the audit log entry to the database AuditLogEntries.Add(auditLogEntry); } // Save the changes var result = await base.SaveChangesAsync(cancellationToken); // Return the result return result; } public DbSet<AuditLogEntry> AuditLogEntries { get; set; } } public class AuditLogEntry { public int Id { get; set; } public object EntityId { get; set; } public string EntityType { get; set; } public string EntityName { get; set; } public string ChangedBy { get; set; } public DateTime ChangedDate { get; set; } public string ChangeType { get; set; } public object OriginalState { get; set; } public object CurrentState { get; set; } } ``` In this example, the `SaveChangesAsync` method is overridden to capture the before and after state of entities. The `ChangeTracker` is used to get the entries that have been modified, and then the `CurrentValues` and `OriginalValues` properties are used to get the current and original state of each entity. An `AuditLogEntry` object is created for each modified entity, and then added to the database. Note that this is a basic example, and you may need to modify it to fit your specific requirements. For example, you may want to add additional information to the `AuditLogEntry` object, such as the user who made the change, or the IP address of the machine that made the change. Also, you will need to configure the `AuditLogEntries` DbSet in the `OnModelCreating` method: ```csharp protected override void OnModelCreating(ModelBuilder modelBuilder) { modelBuilder.Entity<AuditLogEntry>().ToTable("AuditLogEntries"); } ``` You can also use a library like `EntityFrameworkCore.Audit` to simplify the auditing process. You can also use `IMutableEntityType` to get the entity type and `IProperty` to get the entity's properties. You can also use `JsonSerializer` to serialize the `OriginalState` and `CurrentState` objects to JSON. You can also use a separate database for auditing, to keep the audit logs separate from the main database. You can also use a message queue like RabbitMQ or Azure Service Bus to send the audit logs to a separate service for processing. You can also use a cloud-based auditing service like AWS CloudTrail or Google Cloud Audit Logs. It's also important to note that auditing can have a performance impact, so you should consider the trade-offs and optimize the auditing process accordingly.

```csharp using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; // Define an audit log entity public class AuditLog { public int Id { get; set; } public string TableName { get; set; } public string EntityId { get; set; } public string EntityType { get; set; } public string ChangedBy { get; set; } public DateTime ChangedDate { get; set; } public string ChangeType { get; set; } public string OldValues { get; set; } public string NewValues { get; set; } } // Define the DbContext with auditing public class AuditingDbContext : DbContext { public DbSet<AuditLog> AuditLogs { get; set; } public AuditingDbContext(DbContextOptions<AuditingDbContext> options) : base(options) { } public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) { var auditEntries = OnBeforeSaveChanges(); var result = await base.SaveChangesAsync(cancellationToken); await OnAfterSaveChanges(auditEntries); return result; } public override int SaveChanges() { var auditEntries = OnBeforeSaveChanges(); var result = base.SaveChanges(); OnAfterSaveChanges(auditEntries).Wait(); return result; } private List<Dictionary<string, object>> OnBeforeSaveChanges() { var auditEntries = new List<Dictionary<string, object>>(); foreach (var entry in ChangeTracker.Entries().Where(e => e.State == EntityState.Added || e.State == EntityState.Modified || e.State == EntityState.Deleted)) { var auditEntry = new Dictionary<string, object> { { "EntityName", entry.Entity.GetType().Name }, { "EntityId", entry.Entity }, { "State", entry.State }, { "OldValues", entry.OriginalValues }, { "NewValues", entry.CurrentValues } }; auditEntries.Add(auditEntry); } return auditEntries; } private async Task OnAfterSaveChanges(List<Dictionary<string, object>> auditEntries) { foreach (var auditEntry in auditEntries) { var entityName = (string)auditEntry["EntityName"]; var entityId = auditEntry["EntityId"].ToString(); var state = (EntityState)auditEntry["State"]; var oldValues = (ValueTuple<string, object>[])auditEntry["OldValues"]; var newValues = (ValueTuple<string, object>[])auditEntry["NewValues"]; var auditLog = new AuditLog { TableName = entityName, EntityId = entityId, EntityType = entityName, ChangedBy = "System", // Replace with actual user ChangedDate = DateTime.Now, ChangeType = state.ToString(), OldValues = oldValues != null ? string.Join(", ", oldValues.Select(v => $"{v.Item1}: {v.Item2}")) : null, NewValues = newValues != null ? string.Join(", ", newValues.Select(v => $"{v.Item1}: {v.Item2}")) : null }; AuditLogs.Add(auditLog); } await SaveChangesAsync(); } } ``` This implementation provides a basic auditing mechanism for the DbContext. It captures the before and after state of entities during SaveChanges and logs the changes to the AuditLogs DbSet. Here's an explanation of how it works: 1. **OnBeforeSaveChanges**: This method is called before SaveChanges is executed. It iterates over the ChangeTracker entries and creates a dictionary for each entry, capturing the entity name, ID, state, old values, and new values. 2. **OnAfterSaveChanges**: This method is called after SaveChanges is executed. It iterates over the audit entries created in OnBeforeSaveChanges and creates an AuditLog entity for each entry. The AuditLog entity captures the table name, entity ID, entity type, changed by, changed date, change type, old values, and new values. 3. **SaveChangesAsync** and **SaveChanges**: These methods override the base SaveChanges methods to call OnBeforeSaveChanges and OnAfterSaveChanges. To use this auditing mechanism, you can create a DbContext that inherits from AuditingDbContext and add the AuditLogs DbSet to it. Then, you can use the SaveChanges or SaveChangesAsync methods as usual, and the auditing mechanism will capture the changes and log them to the AuditLogs DbSet. Example usage: ```csharp public class MyDbContext : AuditingDbContext { public MyDbContext(DbContextOptions<MyDbContext> options) : base(options) { } public DbSet<MyEntity> MyEntities { get; set; } } public class MyEntity { public int Id { get; set; } public string Name { get; set; }