Orleans Información general del ciclo de vida

Algunos Orleans comportamientos son lo suficientemente complejos que requieren el inicio y el apagado ordenados. Los componentes con estos comportamientos incluyen granos, silos y clientes. Para solucionar esto, Orleans introdujo un patrón de ciclo de vida de componentes general. Este patrón consta de un ciclo de vida observable, responsable de las fases de señalización del inicio y apagado de un componente, y observadores del ciclo de vida, responsables de realizar operaciones de inicio o apagado en fases específicas.

Para obtener más información, consulte Ciclo de vida de grano y Ciclo de vida del silo.

Ciclo de vida observable

Los componentes que necesitan el inicio y apagado ordenados pueden usar un ciclo de vida observable. Esto permite que otros componentes observen el ciclo de vida y reciban notificaciones cuando se alcanza una fase específica durante el inicio o el apagado.

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

La llamada de suscripción registra un observador para recibir notificaciones cuando se alcanza una etapa durante el inicio o apagado. El nombre del observador se usa con fines informativos. La fase indica en qué punto de la secuencia de inicio y apagado recibe la notificación el observador. Cada fase del ciclo de vida es observable. Todos los observadores reciben una notificación cuando se alcanza la etapa durante el inicio y el apagado del sistema. Las fases comienzan en orden ascendente y se detienen en orden descendente. El observador puede cancelar la suscripción eliminando el objeto descartable devuelto.

Observador del ciclo de vida

Los componentes que necesitan participar en el ciclo de vida de otro componente deben proporcionar enlaces para sus comportamientos de inicio y apagado y suscribirse a una fase específica de un ciclo de vida observable.

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

Tanto ILifecycleObserver.OnStart como ILifecycleObserver.OnStop se llaman cuando se alcanza la fase de suscripción durante el inicio o el apagado.

Utilidades

Para mayor comodidad, existen funciones auxiliares para patrones comunes de uso del ciclo de vida.

Extensiones

Las funciones de extensión están disponibles para suscribirse a un ciclo de vida observable que no requiere que el componente de suscripción implemente ILifecycleObserver. En su defecto, estos permiten que los componentes pasen lambdas o funciones miembro para ser llamadas en las fases suscritas.

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

Las funciones de extensión similares permiten usar argumentos de tipo genérico en lugar del nombre del 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);

Participación en el ciclo de vida

Algunos puntos de extensibilidad necesitan una manera de reconocer qué componentes están interesados en participar en un ciclo de vida. Una interfaz de marcador de participante del ciclo de vida sirve para este propósito. Se proporcionan más detalles sobre su uso al explorar los ciclos de vida del silo y del grano.

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

Ejemplo

A partir de las Orleans pruebas de ciclo de vida, a continuación se muestra un ejemplo de un componente que participa en un ciclo de vida observable en varias fases.

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