Как отслеживать изменения в БД?

Отслеживание изменений в базе данных: методы и подходы

Отслеживание изменений в базе данных — критически важная задача для многих приложений, включая аудит, синхронизацию данных, кеширование и event-driven архитектуру. В экосистеме C# Backend существует несколько подходов, которые можно разделить на инструментальные (на уровне СУБД) и программные (на уровне приложения).

Инструментальные методы (уровень СУБД)

Эти методы реализуются непосредственно в базе данных и обычно более эффективны.

1. Триггеры и таблицы аудита

Создание триггеров на таблицы для записи изменений в отдельные аудита-таблицы. Это классический подход.

-- Пример триггера в SQL Server
CREATE TRIGGER trg_Employees_Audit
ON Employees
AFTER INSERT, UPDATE, DELETE
AS
BEGIN
    INSERT INTO AuditLog (TableName, RecordId, Action, OldData, NewData, ChangedBy, ChangedAt)
    SELECT 'Employees',
           ISNULL(i.Id, d.Id),
           CASE WHEN i.Id IS NOT NULL AND d.Id IS NOT NULL THEN 'UPDATE'
                WHEN i.Id IS NOT NULL THEN 'INSERT'
                ELSE 'DELETE' END,
           (SELECT * FROM deleted FOR JSON PATH),
           (SELECT * FROM inserted FOR JSON PATH),
           SYSTEM_USER,
           GETDATE()
    FROM inserted i
    FULL OUTER JOIN deleted d ON i.Id = d.Id;
END;

Преимущества:

• Независимость от приложения
• Гарантированная запись всех изменений
• Высокая производительность на уровне БД

Недостатки:

• Сложность миграций и сопровождения
• Привязка к конкретной СУБД
• Может снижать производительность при частых изменениях

2. Системные таблицы и функции CDC

Современные СУБД предлагают встроенные механизмы:

• SQL Server Change Data Capture (CDC) и Change Tracking
• PostgreSQL Logical Replication и LISTEN/NOTIFY
• MySQL Binary Logs

// Пример использования SQL Server CDC в C#
using (var connection = new SqlConnection(connectionString))
{
    var command = @"
        SELECT * FROM cdc.fn_cdc_get_all_changes_dbo_Employees(
            @from_lsn, @to_lsn, 'all update old');
    ";
    
    using (var cmd = new SqlCommand(command, connection))
    {
        cmd.Parameters.AddWithValue("@from_lsn", lastProcessedLSN);
        cmd.Parameters.AddWithValue("@to_lsn", sys.fn_cdc_get_max_lsn());
        
        connection.Open();
        using (var reader = cmd.ExecuteReader())
        {
            while (reader.Read())
            {
                // Обработка изменений
                var operation = reader["__$operation"];
                var id = reader["Id"];
                // ... логика обработки
            }
        }
    }
}

3. Темпоральные таблицы

SQL Server 2016+ и другие СУБД поддерживают темпоральные таблицы для автоматического хранения истории.

-- Создание темпоральной таблицы
CREATE TABLE Employees
(
    Id INT PRIMARY KEY,
    Name NVARCHAR(100),
    Salary DECIMAL,
    ValidFrom DATETIME2 GENERATED ALWAYS AS ROW START,
    ValidTo DATETIME2 GENERATED ALWAYS AS ROW END,
    PERIOD FOR SYSTEM_TIME (ValidFrom, ValidTo)
)
WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = dbo.EmployeesHistory));

Программные методы (уровень приложения)

Эти методы реализуются в коде приложения и обеспечивают большую гибкость.

1. Паттерн Unit of Work с отслеживанием изменений

В Entity Framework Core используется Change Tracker, который автоматически отслеживает изменения сущностей.

public class AuditService
{
    private readonly MyDbContext _context;
    
    public async Task SaveChangesWithAuditAsync(string userId)
    {
        var auditEntries = new List<AuditEntry>();
        
        foreach (var entry in _context.ChangeTracker.Entries())
        {
            if (entry.State == EntityState.Modified)
            {
                var auditEntry = new AuditEntry
                {
                    EntityName = entry.Entity.GetType().Name,
                    EntityId = entry.Property("Id").CurrentValue.ToString(),
                    Action = "UPDATE",
                    ChangedBy = userId,
                    ChangedAt = DateTime.UtcNow,
                    OldValues = entry.OriginalValues.ToObject(),
                    NewValues = entry.CurrentValues.ToObject()
                };
                auditEntries.Add(auditEntry);
            }
            // Аналогично для добавления и удаления
        }
        
        await _context.SaveChangesAsync();
        await _context.AuditEntries.AddRangeAsync(auditEntries);
        await _context.SaveChangesAsync();
    }
}

2. Паттерн Domain Events

В Domain-Driven Design изменения могут публиковаться как события.

public class Employee : Entity
{
    public string Name { get; private set; }
    
    public void UpdateName(string newName, string updatedBy)
    {
        if (Name != newName)
        {
            var oldName = Name;
            Name = newName;
            
            AddDomainEvent(new EmployeeUpdatedEvent(
                Id, oldName, newName, updatedBy, DateTime.UtcNow));
        }
    }
}

public class PublishDomainEventsInterceptor : SaveChangesInterceptor
{
    public override async ValueTask<InterceptionResult<int>> SavingChangesAsync(
        DbContextEventData eventData,
        InterceptionResult<int> result,
        CancellationToken cancellationToken = default)
    {
        var context = eventData.Context;
        
        if (context != null)
        {
            var entities = context.ChangeTracker.Entries<Entity>()
                .Select(e => e.Entity)
                .Where(e => e.DomainEvents.Any());
            
            var events = entities.SelectMany(e => e.DomainEvents).ToList();
            
            // Публикация событий в брокер сообщений
            foreach (var domainEvent in events)
            {
                await PublishToMessageBroker(domainEvent);
            }
            
            entities.ToList().ForEach(e => e.ClearDomainEvents());
        }
        
        return await base.SavingChangesAsync(eventData, result, cancellationToken);
    }
}

3. Outbox Pattern

Для гарантированной доставки событий о изменениях в распределенных системах.

public class OutboxService
{
    private readonly MyDbContext _context;
    
    public async Task ProcessChangesAsync()
    {
        await _context.Database.BeginTransactionAsync();
        
        try
        {
            // 1. Сохраняем изменения в основную БД
            var changes = GetChanges(); // Логика определения изменений
            await _context.SaveChangesAsync();
            
            // 2. Записываем события в Outbox таблицу
            var outboxMessages = changes.Select(c => new OutboxMessage
            {
                Id = Guid.NewGuid(),
                Type = c.GetType().Name,
                Data = JsonSerializer.Serialize(c),
                CreatedAt = DateTime.UtcNow,
                ProcessedAt = null
            });
            
            await _context.OutboxMessages.AddRangeAsync(outboxMessages);
            await _context.SaveChangesAsync();
            
            // 3. Коммит транзакции
            await _context.Database.CommitTransactionAsync();
            
            // 4. Фоновая задача отправляет события из Outbox
        }
        catch
        {
            await _context.Database.RollbackTransactionAsync();
            throw;
        }
    }
}

Критерии выбора подхода

При выборе метода отслеживания изменений следует учитывать:

1. Требования к производительности

   • CDC и Change Tracking обычно быстрее триггеров
   • Программные методы добавляют накладные расходы

2. Сложность реализации и сопровождения

   • Темпоральные таблицы требуют меньше кода
   • Кастомные решения гибче, но сложнее в поддержке

3. Архитектурные требования

   • Микросервисы: Domain Events + Outbox Pattern
   • Монолит: Entity Framework Change Tracker
   • Высокие требования к аудиту: триггеры или CDC

4. Тип изменений

   • Только факт изменения: Change Tracking
   • Полные данные "до" и "после": CDC или триггеры

Лучшие практики

• Всегда добавляйте контекст: Кто, когда и почему изменил данные
• Реализуйте очистку старых записей: Аудиторские данные могут расти очень быстро
• Тестируйте производительность: Нагрузочное тестирование обязательно
• Используйте асинхронную обработку: Для минимизации влияния на основную бизнес-логику
• Рассмотрите готовые решения: MediatR для событий, Audit.NET для аудита

В современных C# Backend приложениях я чаще всего рекомендую комбинированный подход: Entity Framework Change Tracker для бизнес-логики приложения + CDC или Outbox Pattern для интеграции с другими системами. Это обеспечивает баланс между производительностью, поддерживаемостью и гибкостью архитектуры.