Vue d’ensemble du cycle de vie des grains

Orleans les grains utilisent un cycle de vie observable (voir Orleans Cycle de vie) pour l’activation et la désactivation ordonnées. Cela permet à la logique grain, aux composants système et à la logique d’application de démarrer et d’arrêter de manière ordonnée pendant l’activation et la collecte des grains.

Étapes

Les étapes prédéfinies du cycle de vie des grains sont les suivantes :

public static class GrainLifecycleStage
{
    public const int First = int.MinValue;
    public const int SetupState = 1_000;
    public const int Activate = 2_000;
    public const int Last = int.MaxValue;
}

• First: Première étape du cycle de vie d’un grain.
• SetupState: configurez l’état du grain avant l’activation. Pour les grains avec état, il s'agit de l'étape où Orleans charge IStorage<TState>.State depuis le stockage si IStorage.RecordExists est true.
• Activate: Étape où Orleans appelle Grain.OnActivateAsync et Grain.OnDeactivateAsync.
• Last: Dernière étape du cycle de vie d’un grain.

Bien que Orleans utilise le cycle de vie des grains lors de l'activation, les grains ne sont pas toujours désactivés dans certains cas d'erreur (tels que les pannes de silo). Par conséquent, les applications ne doivent pas s'appuyer sur le cycle de vie du grain qui est systématiquement exécuté lors des désactivations de grain.

Participation au cycle de vie des grains

La logique d’application peut participer au cycle de vie d’un grain de deux manières :

Un grain participe toujours à son cycle de vie, de sorte que la logique d’application peut être introduite en substituant la méthode de participation.

Exemple de participation

public override void Participate(IGrainLifecycle lifecycle)
{
    base.Participate(lifecycle);
    lifecycle.Subscribe(
        this.GetType().FullName,
        GrainLifecycleStage.SetupState,
        OnSetupState);
}

Dans l’exemple précédent, Grain<TGrainState> remplace la Grain.Participate méthode pour indiquer au cycle de vie d’appeler sa OnSetupState méthode pendant l’étape GrainLifecycleStage.SetupState du cycle de vie.

Exemple : Participation des composants

Le composant suivant participe au cycle de vie du grain lors de sa création à l’aide de sa fonction Create(...)de fabrique. Cette logique peut exister dans le constructeur du composant, mais cela risque d’ajouter le composant au cycle de vie avant qu’il ne soit entièrement construit, ce qui peut ne pas être sûr.

public class MyComponent : ILifecycleParticipant<IGrainLifecycle>
{
    public static MyComponent Create(IGrainContext context)
    {
        var component = new MyComponent();
        component.Participate(context.ObservableLifecycle);
        return component;
    }

    public void Participate(IGrainLifecycle lifecycle)
    {
        lifecycle.Subscribe<MyComponent>(GrainLifecycleStage.Activate, OnActivate);
    }

    private Task OnActivate(CancellationToken ct)
    {
        // Do stuff
    }
}

public class MyComponent : ILifecycleParticipant<IGrainLifecycle>
{
    public static MyComponent Create(IGrainActivationContext context)
    {
        var component = new MyComponent();
        component.Participate(context.ObservableLifecycle);
        return component;
    }

    public void Participate(IGrainLifecycle lifecycle)
    {
        lifecycle.Subscribe<MyComponent>(GrainLifecycleStage.Activate, OnActivate);
    }

    private Task OnActivate(CancellationToken ct)
    {
        // Do stuff
    }
}

En inscrivant l’exemple de composant dans le conteneur de services à l’aide de sa Create(...) fonction de fabrique, tout grain construit avec le composant en tant que dépendance permet au composant de participer à son cycle de vie sans nécessiter de logique spéciale dans le grain lui-même.

Inscrire un composant dans un conteneur

services.AddTransient<MyComponent>(sp =>
    MyComponent.Create(sp.GetRequiredService<IGrainContext>());

services.AddTransient<MyComponent>(sp =>
    MyComponent.Create(sp.GetRequiredService<IGrainActivationContext>());

Grain avec un composant comme dépendance

public class MyGrain : Grain, IMyGrain
{
    private readonly MyComponent _component;

    public MyGrain(MyComponent component)
    {
        _component = component;
    }
}