Orleans Visão geral do ciclo de vida

Alguns Orleans comportamentos são suficientemente complexos para exigir inicialização e desligamento ordenados. Componentes com tais comportamentos incluem grãos, silos e clientes. Para resolver isso, Orleans introduziu um padrão geral de ciclo de vida do componente. Esse padrão consiste em um ciclo de vida observável, responsável por sinalizar os estágios de inicialização e desligamento de um componente, e observadores do ciclo de vida, responsáveis por executar operações de inicialização ou desligamento em estágios específicos.

Para obter mais informações, consulte Ciclo de vida do grão e ciclo de vida do silo.

Ciclo de vida observável

Os componentes que necessitam de arranque e encerramento ordenados podem utilizar um ciclo de vida observável. Isso permite que outros componentes observem o ciclo de vida e recebam notificações quando um estágio específico é atingido durante a inicialização ou o desligamento.

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

A chamada de assinatura registra um observador para notificação quando um estágio é atingido durante a inicialização ou desligamento. O nome do observador é usado para fins de relatório. O estágio indica em que ponto da sequência de inicialização/desligamento o observador recebe notificação. Cada estágio do ciclo de vida é observável. Todos os observadores são notificados quando o estágio é atingido durante a inicialização e o desligamento. Os estágios começam em ordem crescente e param em ordem decrescente. O observador pode cancelar a inscrição descartando o objeto descartável retornado.

Observador do ciclo de vida

Os componentes que precisam participar do ciclo de vida de outro componente devem fornecer ganchos para seus comportamentos de inicialização e desligamento e se inscrever em um estágio específico de um ciclo de vida observável.

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

Ambos ILifecycleObserver.OnStart e ILifecycleObserver.OnStop são chamados quando o estágio de inscrição é atingido durante a inicialização ou desligamento.

Serviços Públicos

Por conveniência, existem funções auxiliares para padrões comuns de uso do ciclo de vida.

Extensões

As funções de extensão estão disponíveis para assinar um ciclo de vida observável que não requer o componente subscritor para implementar ILifecycleObserver. Em vez disso, eles permitem que os componentes passem em lambdas ou funções de membro a serem chamadas nos estágios inscritos.

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);

Funções de extensão semelhantes permitem usar argumentos de tipo genéricos em vez do nome do observador.

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);

Participação no ciclo de vida

Alguns pontos de extensibilidade precisam de uma maneira de reconhecer quais componentes estão interessados em participar de um ciclo de vida. Uma interface para marcar participantes do ciclo de vida serve a esse propósito. Mais detalhes sobre seu uso são abordados ao explorar os ciclos de vida de silos e grãos.

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

Exemplo

A partir dos Orleans testes de ciclo de vida, abaixo está um exemplo de um componente que participa de um ciclo de vida observável em vários estágios.

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