Panoramica del ciclo di vita granulare

I grani Orleans usano un ciclo di vita osservabile (vedere Orleans Ciclo di vita) per l'attivazione e la disattivazione ordinate. In questo modo, la logica granulare, i componenti di sistema e la logica dell'applicazione devono essere avviati e arrestati in modo ordinato durante l'attivazione e la raccolta granulari.

FASI

Di seguito sono riportate le fasi predefinite del ciclo di vita della granularità.

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: prima fase del ciclo di vita di una granularità.
• SetupState: imposta lo stato di granularità, prima dell'attivazione. Per i grani con stato, questa è la fase in cui IStorage<TState>.State viene caricato dallo spazio di archiviazione, quando IStorage.RecordExists è true.
• Activate: fase in cui vengono chiamati Grain.OnActivateAsync e Grain.OnDeactivateAsync.
• Last: ultima fase del ciclo di vita di una granularità.

Anche se il ciclo di vita della granularità verrà usato durante l'attivazione della granularità, poiché i grani non vengono sempre disattivati durante alcuni casi di errore (ad esempio arresti anomali del silo), le applicazioni non devono basarsi sul ciclo di vita della granularità sempre in esecuzione durante le disattivazioni della granularità.

Partecipazione al ciclo di vita granulare

La logica dell'applicazione può partecipare con il ciclo di vita di una granularità in due modi:

• Il livello di granularità può partecipare al ciclo di vita.
• I componenti possono accedere al ciclo di vita tramite il contesto di attivazione granulare (vedere IGrainContext.ObservableLifecycle).

• Il livello di granularità può partecipare al ciclo di vita.
• I componenti possono accedere al ciclo di vita tramite il contesto di attivazione granulare (vedere IGrainActivationContext.ObservableLifecycle).

Una granularità partecipa sempre al ciclo di vita, quindi la logica dell'applicazione può essere introdotta eseguendo l'override del metodo di partecipazione.

Partecipazione di esempio

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

Nell'esempio precedente Grain<TGrainState> esegue l'override del metodo Grain.Participate per indicare al ciclo di vita di chiamare il metodo OnSetupState durante la fase GrainLifecycleStage.SetupState del ciclo di vita.

I componenti creati durante la costruzione di una granularità possono anche prendere parte al ciclo di vita, senza l'aggiunta di una logica di granularità speciale. Poiché il contesto della granularità (IGrainContext), incluso il ciclo di vita della granularità (IGrainContext.ObservableLifecycle), viene creato prima della creazione della granularità, qualsiasi componente inserito nella granularità dal contenitore può partecipare al ciclo di vita della granularità.

I componenti creati durante la costruzione di una granularità possono anche prendere parte al ciclo di vita, senza l'aggiunta di una logica di granularità speciale. Poiché il contesto di attivazione della granularità (IGrainActivationContext), incluso il ciclo di vita della granularità (IGrainActivationContext.ObservableLifecycle), viene creato prima della creazione della granularità, qualsiasi componente inserito nella granularità dal contenitore può partecipare al ciclo di vita della granularità.

Partecipazione, creazione e attivazione di esempio

Il componente seguente partecipa al ciclo di vita della granularità quando viene creato usando la funzione factory Create(...). Questa logica potrebbe esistere nel costruttore del componente, ma rischia di aggiungere il componente al ciclo di vita prima che venga completamente costruito, che potrebbe non essere sicuro.

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
    }
}

Registrando il componente di esempio nel contenitore del servizio usando la funzione factory Create(...), qualsiasi granularità costruita con il componente come dipendenza avrà il componente che partecipa al ciclo di vita senza alcuna logica speciale nel livello di granularità.

Registrare il componente nel contenitore

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

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

Granularità con componente come dipendenza

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

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