Visão geral do ciclo de vida dos grãos

Orleans os grãos usam um ciclo de vida observável (consulte Orleans Ciclo de vida) para ativação e desativação ordenadas. Isso permite que a lógica de grãos, os componentes do sistema e a lógica do aplicativo iniciem e parem de forma ordenada durante a ativação e a coleta de grãos.

Estágios

Os estágios predefinidos do ciclo de vida do grão são os seguintes:

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: Primeira etapa do ciclo de vida de um grão.
• SetupState: Configure o estado do grão antes da ativação. Para grãos com estado, este é o estágio onde Orleans carrega IStorage<TState>.State do armazenamento se IStorage.RecordExists for true.
• Activate: Estágio onde Orleans chama Grain.OnActivateAsync e Grain.OnDeactivateAsync.
• Last: Última etapa do ciclo de vida de um grão.

Embora Orleans use o ciclo de vida do grão durante a ativação do grão, os grãos nem sempre são desativados em alguns casos de erro (como avarias de silo). Portanto, os aplicativos não devem depender do ciclo de vida do grão sempre executado durante as desativações do grão.

Participação no ciclo de vida dos grãos

A lógica do aplicativo pode participar do ciclo de vida de um grão de duas maneiras:

Um grão sempre participa de seu ciclo de vida, de modo que a lógica de aplicação pode ser introduzida substituindo o método participante.

Exemplo de participação

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

No exemplo anterior, Grain<TGrainState> substitui o método Grain.Participate para indicar ao ciclo de vida que deve chamar o seu método OnSetupState durante a fase GrainLifecycleStage.SetupState do ciclo de vida.

Exemplo: Participação de componentes

O componente a seguir participa do ciclo de vida do grão quando criado usando sua função Create(...)de fábrica. Essa lógica pode existir no construtor do componente, mas corre o risco de adicionar o componente ao ciclo de vida antes de ser totalmente construído, o que pode não ser seguro.

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

Ao registrar o componente de exemplo no contêiner de serviço usando sua Create(...) função de fábrica, qualquer grão construído com o componente como uma dependência faz com que o componente participe de seu ciclo de vida sem exigir qualquer lógica especial no próprio grão.

Registrar componente no contêiner

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

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

Grão com dependência de componente

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

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