Visão geral do ciclo de vida de 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 granulação, os componentes do sistema e a lógica do aplicativo iniciem e interrompam de maneira ordenada durante a ativação e a coleta de grãos.

Estágios

Os estágios predefinidos do ciclo de vida de grãos 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: primeiro estágio no ciclo de vida de um grão.
• SetupState: configure o estado de grãos antes da ativação. Para grãos com estado, este é o estágio em que 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 no ciclo de vida de um grão.

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

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

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

• Os grãos podem participar de seu próprio ciclo de vida.
• Os componentes podem acessar o ciclo de vida por meio do contexto de ativação de grãos (consulte IGrainContext.ObservableLifecycle).

• Os grãos podem participar de seu próprio ciclo de vida.
• Os componentes podem acessar o ciclo de vida por meio do contexto de ativação de grãos (consulte IGrainActivationContext.ObservableLifecycle).

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

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 instruir o ciclo de vida a chamar seu método OnSetupState durante a fase GrainLifecycleStage.SetupState do ciclo de vida.

Componentes criados durante a construção de um grão também podem participar do ciclo de vida sem adicionar nenhuma lógica de grão especial. Como Orleans cria o contexto do grão (IGrainContext), incluindo seu ciclo de vida (IGrainContext.ObservableLifecycle), antes de criar o grão, qualquer componente injetado no grão pelo contêiner pode participar do ciclo de vida do grão.

Componentes criados durante a construção de um grão também podem participar do ciclo de vida sem adicionar nenhuma lógica de grão especial. Como Orleans cria o contexto de ativação do grão (IGrainActivationContext), incluindo seu ciclo de vida (IGrainActivationContext.ObservableLifecycle), antes de criar o grão, qualquer componente injetado no grão pelo contêiner pode participar do ciclo de vida do grão.

Exemplo: participação do componente

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 isso 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 tem o componente participando de seu ciclo de vida sem a necessidade de nenhuma 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 componente como dependência

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

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