Orleans Vue d’ensemble du cycle de vie

Certains Orleans comportements sont suffisamment complexes pour exiger le démarrage et l’arrêt ordonnés. Les composants avec ces comportements incluent les grains, les silos et les clients. Pour résoudre ce problème, Orleans a introduit un modèle de cycle de vie de composant général. Ce modèle se compose d’un cycle de vie observable, responsable de la signalisation des étapes de démarrage et d’arrêt d’un composant, et des observateurs du cycle de vie, chargés d’effectuer des opérations de démarrage ou d’arrêt à des étapes spécifiques.

Pour plus d’informations, consultez cycle de vie grain et cycle de vie silo.

Cycle de vie observable

Les composants nécessitant un démarrage et un arrêt ordonnés peuvent utiliser un cycle de vie observable. Cela permet à d’autres composants d’observer le cycle de vie et de recevoir des notifications lorsqu’une étape spécifique est atteinte pendant le démarrage ou l’arrêt.

public interface ILifecycleObservable
{
    IDisposable Subscribe(
        string observerName,
        int stage,
        ILifecycleObserver observer);
}

L'appel de souscription inscrit un observateur pour notifier lorsqu'une étape est atteinte lors du démarrage ou de l'arrêt du système. Le nom de l’observateur est utilisé à des fins de création de rapports. L’étape indique à quel point dans la séquence de démarrage/d’arrêt l’observateur reçoit une notification. Chaque phase de cycle de vie est observable. Tous les observateurs sont avertis lorsque la phase est atteinte pendant le démarrage et l’arrêt. Les étapes commencent par ordre croissant et s’arrêtent dans l’ordre décroissant. L’observateur peut se désabonner en supprimant l’objet jetable retourné.

Observateur de cycle de vie

Les composants qui doivent participer au cycle de vie d’un autre composant doivent fournir des hooks pour leurs comportements de démarrage et d’arrêt et s’abonner à une phase spécifique d’un cycle de vie observable.

public interface ILifecycleObserver
{
    Task OnStart(CancellationToken ct);
    Task OnStop(CancellationToken ct);
}

ILifecycleObserver.OnStart et ILifecycleObserver.OnStop sont tous deux appelés quand l'étape abonnée est atteinte pendant le démarrage ou l'arrêt.

Services publics

Pour plus de commodité, les fonctions d’assistance existent pour les modèles d’utilisation courants du cycle de vie.

Extensions

Les fonctions d'extension sont disponibles pour s'abonner à un cycle de vie observable, sans nécessiter que le composant s'abonnant implémente ILifecycleObserver. Au lieu de cela, le système permet aux composants de transmettre des fonctions lambda ou des fonctions membres qui seront appelées aux étapes auxquelles ils sont abonnés.

IDisposable Subscribe(
    this ILifecycleObservable observable,
    string observerName,
    int stage,
    Func<CancellationToken, Task> onStart,
    Func<CancellationToken, Task> onStop);

IDisposable Subscribe(
    this ILifecycleObservable observable,
    string observerName,
    int stage,
    Func<CancellationToken, Task> onStart);

Les fonctions d’extension similaires permettent d’utiliser des arguments de type générique au lieu du nom d’observateur.

IDisposable Subscribe<TObserver>(
    this ILifecycleObservable observable,
    int stage,
    Func<CancellationToken, Task> onStart,
    Func<CancellationToken, Task> onStop);

IDisposable Subscribe<TObserver>(
    this ILifecycleObservable observable,
    int stage,
    Func<CancellationToken, Task> onStart);

Participation au cycle de vie

Certains points d’extensibilité ont besoin d’un moyen de reconnaître quels composants sont intéressés par la participation à un cycle de vie. Une interface de marqueur de participant au cycle de vie sert cet objectif. Vous trouverez plus d’informations sur son utilisation lors de l’exploration des cycles de vie des silos et des grains.

public interface ILifecycleParticipant<TLifecycleObservable>
    where TLifecycleObservable : ILifecycleObservable
{
    void Participate(TLifecycleObservable lifecycle);
}

Exemple :

À partir des Orleans tests de cycle de vie, vous trouverez ci-dessous un exemple de composant qui participe à un cycle de vie observable à plusieurs étapes.

enum TestStages
{
    Down,
    Initialize,
    Configure,
    Run,
};

class MultiStageObserver : ILifecycleParticipant<ILifecycleObservable>
{
    public Dictionary<TestStages,bool> Started { get; } = new();
    public Dictionary<TestStages, bool> Stopped { get; } = new();

    private Task OnStartStage(TestStages stage)
    {
        Started[stage] = true;

        return Task.CompletedTask;
    }

    private Task OnStopStage(TestStages stage)
    {
        Stopped[stage] = true;

        return Task.CompletedTask;
    }

    public void Participate(ILifecycleObservable lifecycle)
    {
        lifecycle.Subscribe<MultiStageObserver>(
            (int)TestStages.Down,
            _ => OnStartStage(TestStages.Down),
            _ => OnStopStage(TestStages.Down));

        lifecycle.Subscribe<MultiStageObserver>(
            (int)TestStages.Initialize,
            _ => OnStartStage(TestStages.Initialize),
            _ => OnStopStage(TestStages.Initialize));

        lifecycle.Subscribe<MultiStageObserver>(
            (int)TestStages.Configure,
            _ => OnStartStage(TestStages.Configure),
            _ => OnStopStage(TestStages.Configure));

        lifecycle.Subscribe<MultiStageObserver>(
            (int)TestStages.Run,
            _ => OnStartStage(TestStages.Run),
            _ => OnStopStage(TestStages.Run));
    }
}