Qu'est-ce que l'AUS-2?

AUS-2, ou Gestion Asynchrone de l’État de la deuxième version, est un ensemble de modèles et de recommandations pour gérer l’état dans les applications asynchrones en C#. Il vise à simplifier le travail avec du code contenant de nombreuses opérations asynchrones et à assurer sa prévisibilité et sa stabilité. Les principes principaux d’AUS-2 incluent :

• Une séparation claire des responsabilités. L’état de l’application est séparé de la logique qui le modifie.
• Encapsulation des changements d’état. Les changements d’état se produisent uniquement via des actions ou commandes contrôlées.
• Nature asynchrone. Toutes les opérations de changement d’état et de traitement des influences externes sont considérées comme potentiellement asynchrones.
• Utilisation de structures de données thread-safe. Des structures de données résistantes à l’accès concurrent depuis différents threads sont utilisées.
• Orientation vers l’immuabilité. Autant que possible, des objets d’état immuables sont utilisés, ce qui facilite le suivi des changements et prévient les effets secondaires indésirables.

Les composants typiques d’une architecture suivant les principes d’AUS-2 peuvent être :

• État (State) : Objet(s) représentant l’état actuel de l’application ou d’une partie de celle-ci.
• Action (Action/Command) : Objet décrivant l’intention de changer l’état.
• Gestionnaire (Handler/Reducer) : Fonction ou objet qui reçoit l’état actuel et l’action, et retourne un nouvel état. C’est dans le gestionnaire que toute la logique de changement d’état se produit.

Avantages de l’utilisation d’AUS-2 :

• Meilleure testabilité. Grâce à une séparation claire et à l’encapsulation, la logique de changement d’état est facilement testable.
• Prévisibilité. Les changements d’état se produisent uniquement via des mécanismes définis, rendant le comportement de l’application plus compréhensible et prévisible.
• Facilité de débogage. Il est plus facile de suivre comment et pourquoi l’état de l’application a changé.
• Scalabilité. L’architecture se scale bien à mesure que la complexité de l’application augmente.

Exemple d’implémentation simple du principe (sans utiliser un framework complet) :

// État immuable
public record AppState(int Count);

// Type d’action
public record IncrementAction();

// Gestionnaire
public static class StateHandler
{
    public static AppState Handle(AppState currentState, IncrementAction action)
    {
        // Créer un nouvel état au lieu de modifier l’existant
        return new AppState(currentState.Count + 1);
    }
    // Autres gestionnaires pour d’autres types d’actions...
}

// Exemple d’utilisation (simplifié, sans considérer l’asynchronie ni la sécurité des threads dans cet exemple spécifique)
/*
AppState currentState = new AppState(0);
currentState = StateHandler.Handle(currentState, new IncrementAction());
Console.WriteLine(currentState.Count); // Affichera 1
*/

AUS-2 n’est pas une bibliothèque spécifique, mais plutôt un ensemble de principes qui peuvent être implémentés en utilisant différents modèles (par exemple, similaires à Redux) et bibliothèques dans l’écosystème .NET.