Uma tarefa bastante recorrente durante o desenvolvimento de sistemas é a criação de rotinas de log. E o Entity Framework facilita a nossa vida quando temos de fazer isso.

Com o Entity Framework podemos criar uma customização que encapsule os comandos que serão enviados para o banco de dados e então adicionar uma lógica que gere os registros de log necessários para cada operação.

Esta customização é bastante simples de ser criada e basicamente se resume a sobrescrita do método SaveChanges dos nossos contextos de acesso a dados.

Logo abaixo é apresentado um exemplo de como essa customização pode ser feita.

1 – Crie a entidade de log.

A entidade de log utilizada seguirá a estrutura abaixo:

using System;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Xml.Serialization;

public class Log {

    private const string INSERT_ACTION = "Insert";
    private const string UPDATE_ACTION = "Update";
    private const string DELETE_ACTION = "Delete";

    public Log() {
        this.Date = DateTime.Now;
    }

    public int Id { get; set; }

    public string Action { get; set; }

    public string OriginalValues { get; set; }

    public string NewValues { get; set; }

    public DateTime Date { get; set; }

    public static Log CreateInsertLog(object newEntity) {
        Log log = new Log();

        log.Action = INSERT_ACTION;
        log.OriginalValues = null;
        log.NewValues = Serialize(newEntity);

        return log;
    }

    public static Log CreateDeleteLog(object newEntity) {
        Log log = new Log();

        log.Action = DELETE_ACTION;
        log.OriginalValues = Serialize(newEntity);
        log.NewValues = null;

        return log;
    }

    public static Log CreateUpdateLog(object originalEntity, object newEntity) {

        Log log = new Log();

        log.Action = UPDATE_ACTION;
        log.OriginalValues = Serialize(originalEntity);
        log.NewValues = Serialize(newEntity);

        return log;
    }

    private static string Serialize(object obj) {

        return SerializeJson(obj);
        //return SerializeXml(obj);
    }

    private static string SerializeXml(object obj) {

        XmlSerializer xs = new XmlSerializer(obj.GetType());
        using (MemoryStream buffer = new MemoryStream()) {
            xs.Serialize(buffer, obj);
            return ASCIIEncoding.ASCII.GetString(buffer.ToArray());
        }
    }

    private static string SerializeJson(object obj) {

        using (MemoryStream buffer = new MemoryStream()) {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(obj.GetType());
            ser.WriteObject(buffer, obj);
            return ASCIIEncoding.ASCII.GetString(buffer.ToArray());
        }
    }
}

Note que existem dois métodos de serialização, sendo que um deles gera os dados no formato XML e o outro no formato JSON. Esses métodos de serialização são necessários neste exemplo para demonstrar como os dados de log podem ser salvos no banco de dados. Criei dois métodos, pois o formato XML é o mais usado, mas o JSON é mais econômico (devido a suas características naturais) e ocupa menos espaço no banco de dados. Vale a pena testar e identificar qual se enquadra melhor ao seu cenário.

2 – Sobrescreva o método SaveChanges do seu contexto de dados.

Para assegurar que todas as operações serão logadas no banco de dados será preciso sobrescrever o método SaveChanges e adicionar um lógica de registro destes dados na tabela de log. A lógica necessária para isso, assim como a sobrescrita do método SaveChanges, são apresentadas logo abaixo.

using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;

public class DatabaseContext : DbContext {

    // Seus demais DbSets.
    // public DbSet<Entidade1> Logs { get; set; }
    // public DbSet<Entidade2> Logs { get; set; }
    // ...
    // public DbSet<EntidadeN> Logs { get; set; }
        
    public DbSet<Log> Logs { get; set; }

    public DatabaseContext() {

        Database.SetInitializer(new DropCreateDatabaseIfModelChanges<DatabaseContext>());
    }

    public override int SaveChanges() {
        // Detecta as alterações existentes na instância corrente do DbContext.
        this.ChangeTracker.DetectChanges();
        // Identifica as entidades que devem gerar registros em log.
        var entries = DetectEntries();
        // Cria lista para armazenamento temporário dos registros em log.
        List<Log> logs = new List<Log>(entries.Count());
        // Varre as entidades que devem gerar registros em log.
        foreach (var entry in entries) {
            // Cria novo registro de log.
            Log newLog = GetLog(entry);

            if (newLog != null)
                logs.Add(newLog);
        }
        // Adiciona os registros de log na fonte de dados.
        foreach (var item in logs) {
            this.Entry(item).State = EntityState.Added;
        }
        // Persiste as informações na fonte de dados.
        return base.SaveChanges();
    }

    /// <summary>
    /// Identifica quais entidades devem ser gerar registros de log.
    /// </summary>
    private IEnumerable<DbEntityEntry> DetectEntries() {
        return ChangeTracker.Entries().Where(e => (e.State == EntityState.Modified ||
                                                    e.State == EntityState.Added ||
                                                    e.State == EntityState.Deleted) &&
                                                    e.Entity.GetType() != typeof(Log));
    }

    /// <summary>
    /// Cria os registros de log.
    /// </summary>
    private Log GetLog(DbEntityEntry entry) {

        Log returnValue = null;

        if (entry.State == EntityState.Added) {
            returnValue = GetInsertLog(entry);
        } else if (entry.State == EntityState.Modified) {
            returnValue = GetUpdateLog(entry);
        } else if (entry.State == EntityState.Deleted) {
            returnValue = GetDeleteLog(entry);
        }

        return returnValue;
    }

    private Log GetInsertLog(DbEntityEntry entry) {

        return Log.CreateInsertLog(entry.Entity);
    }

    private Log GetDeleteLog(DbEntityEntry entry) {

        return Log.CreateDeleteLog(entry.Entity);
    }

    private Log GetUpdateLog(DbEntityEntry entry) {

        object originalValue = null;

        if (entry.OriginalValues != null)
            originalValue = entry.OriginalValues.ToObject();
        else
            originalValue = entry.GetDatabaseValues().ToObject();

        return Log.CreateUpdateLog(originalValue, entry.Entity);
    }
}

Espero que seja útil.

Por

MSc. Fernando Henrique Inocêncio Borba Ferreira

Microsoft Most Valuable Professional – Visual C#