Orleans přehled životního cyklu

Některá Orleans chování jsou dostatečně složitá, aby vyžadovala seřazené spuštění a vypnutí. Součástí s takovým chováním jsou zrno, sila a klienti. Abychom to vyřešili, Orleans zavedli jsme obecný model životního cyklu komponent. Tento model se skládá z pozorovatelného životního cyklu zodpovědného za signalizační fáze spuštění a vypnutí komponenty a pozorovatelů životního cyklu, kteří zodpovídají za provádění operací spuštění nebo vypnutí v konkrétních fázích.

Další informace najdete v tématu Životní cyklus obilí a Životní cyklus sila.

Pozorovatelný životní cyklus

Komponenty, které potřebují uspořádané spuštění a vypnutí, můžou používat pozorovatelný životní cyklus. To umožňuje ostatním komponentám sledovat životní cyklus a přijímat oznámení, když se během spuštění nebo vypnutí dosáhne určité fáze.

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

Funkce odběru zapíše pozorovatele pro oznámení v okamžiku, kdy během spuštění nebo vypnutí systému nebo aplikace dojde k dosažení fáze. Jméno pozorovatele se používá pro účely hlášení. Fáze označuje, v jakém okamžiku v sekvenci spuštění/vypnutí pozorovatel obdrží oznámení. Každá fáze životního cyklu je pozorovatelná. Všichni pozorovatelé jsou upozorněni, když během spuštění a vypnutí dojde k dosažení fáze. Fáze začínají vzestupně a zastavují se sestupně. Pozorovatel se může odhlásit likvidací vráceného uvolnitelného objektu.

Pozorovatel životního cyklu

Komponenty, které se potřebují účastnit životního cyklu jiné komponenty, musí poskytovat háky pro jejich chování při spuštění a vypnutí a přihlásit se k odběru konkrétní fáze pozorovatelného životního cyklu.

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

Obě ILifecycleObserver.OnStart a ILifecycleObserver.OnStop jsou volána při dosažení předplacené fáze během spuštění nebo vypnutí.

Veřejné služby

Pro pohodlí existují pomocné funkce pro běžné vzory použití životního cyklu.

Rozšíření

Funkce rozšíření jsou k dispozici pro přihlášení k odběru pozorovatelného životního cyklu bez nutnosti, aby se přihlašující komponenta musela implementovat ILifecycleObserver. Místo toho umožňují komponentám předávat lambda nebo členské funkce, které se mají volat v předplacených fázích.

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

Podobné rozšiřující funkce umožňují místo názvu pozorovatele používat argumenty obecného typu.

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

Účast na životním cyklu

Některé body rozšiřitelnosti potřebují způsob, jak rozpoznat, které komponenty se zajímají o účast v životním cyklu. K tomuto účelu slouží rozhraní značek účastníků životního cyklu. Další podrobnosti o jeho využití se proberou při zkoumání životních cyklů sil a obilí.

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

Příklad

Níže uvedené Orleans testy životního cyklu jsou příkladem komponenty, která se účastní pozorovatelného životního cyklu ve více fázích.

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