.net Event Sourcing Example

INFLUENCESMAG.ORG

5 min read

·

Jun 03, 2024

27

Share

Découvrez le Event Sourcing avec .NET : Un exemple pratique

Le Event Sourcing est un modèle de conception d'applications qui consiste à enregistrer toutes les modifications d'un état comme une séquence d'événements. Au lieu de stocker l'état actuel, on enregistre tous les événements qui ont mené à cet état.

Pourquoi le Event Sourcing ?

• Auditabilité : Les événements conservent un historique complet de toutes les modifications, permettant un audit facile.
• Résilience : On peut facilement reconstruire l'état à partir des événements, ce qui rend l'application plus résistante aux erreurs et aux pannes.
• Parallélisme : Les événements peuvent être traités en parallèle, ce qui améliore les performances.
• Flexibilité : On peut modifier facilement le comportement de l'application en ajoutant de nouveaux événements ou en modifiant le traitement des événements existants.

Un exemple simple avec .NET

Prenons l'exemple d'une application de gestion de tâches. Chaque tâche est représentée par une série d'événements :

• TaskCreated: Création d'une nouvelle tâche avec un titre et une description.
• TaskAssigned: Affectation d'une tâche à un utilisateur.
• TaskCompleted: Marquage d'une tâche comme terminée.

public class Task
{
    private readonly List _events = new List();

    public Guid Id { get; }
    public string Title { get; private set; }
    public string Description { get; private set; }
    public string Assignee { get; private set; }
    public bool IsCompleted { get; private set; }

    public Task(Guid id, string title, string description)
    {
        Id = id;
        Title = title;
        Description = description;
        Apply(new TaskCreated(id, title, description));
    }

    public void Assign(string assignee)
    {
        Apply(new TaskAssigned(Id, assignee));
    }

    public void Complete()
    {
        Apply(new TaskCompleted(Id));
    }

    private void Apply(TaskEvent @event)
    {
        _events.Add(@event);
        @event.Apply(this);
    }

    public void ReplayEvents()
    {
        foreach (var @event in _events)
        {
            @event.Apply(this);
        }
    }
}

public abstract class TaskEvent
{
    public Guid TaskId { get; }

    protected TaskEvent(Guid taskId)
    {
        TaskId = taskId;
    }

    public abstract void Apply(Task task);
}

public class TaskCreated : TaskEvent
{
    public string Title { get; }
    public string Description { get; }

    public TaskCreated(Guid taskId, string title, string description) : base(taskId)
    {
        Title = title;
        Description = description;
    }

    public override void Apply(Task task)
    {
        task.Title = Title;
        task.Description = Description;
    }
}

public class TaskAssigned : TaskEvent
{
    public string Assignee { get; }

    public TaskAssigned(Guid taskId, string assignee) : base(taskId)
    {
        Assignee = assignee;
    }

    public override void Apply(Task task)
    {
        task.Assignee = Assignee;
    }
}

public class TaskCompleted : TaskEvent
{
    public TaskCompleted(Guid taskId) : base(taskId)
    {
    }

    public override void Apply(Task task)
    {
        task.IsCompleted = true;
    }
}

Ce code illustre comment les événements sont utilisés pour modifier l'état d'une tâche. Chaque événement est un objet immuable qui décrit une modification spécifique. Les événements sont stockés dans une liste et peuvent être utilisés pour reconstruire l'état de la tâche à tout moment.

Conclusion

Le Event Sourcing est un modèle de conception puissant qui offre de nombreux avantages pour le développement d'applications .NET. Il permet de créer des applications plus auditable, résilientes et flexibles. Bien que le concept puisse sembler complexe au premier abord, il est possible de l'implémenter de manière simple et efficace.