Orleans přehled životního cyklu

Některá Orleans chování jsou dostatečně složitá, že potřebují uspořádané spuštění a vypnutí. Mezi komponenty s takovým chováním patří zrnka, sila a klienti. Abychom to vyřešili, zavedli jsme obecný model životního cyklu komponent. Tento model se skládá z pozorovatelného životního cyklu, který je zodpovědný za signalizaci ve fázích spuštění a vypnutí komponenty a pozorovatelů životního cyklu, kteří jsou zodpovědní za provádění operací spouštění nebo vypnutí v konkrétních fázích.

Další informace najdete v tématu Životní cyklus zrnitosti 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, který ostatním komponentám umožňuje sledovat životní cyklus a přijímat oznámení o dosažení fáze během spuštění nebo vypnutí.

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

Volání přihlášení k odběru zaregistruje pozorovatele pro oznámení, když dojde k dosažení fáze při spuštění nebo zastavení. Jméno pozorovatele je určené pro účely hlášení. Fáze označená v okamžiku, kdy bude pozorovatel upozorněn na sekvenci spuštění/vypnutí. Každá fáze životního cyklu je pozorovatelná. Všichni pozorovatelé budou upozorněni na dosažení fáze při spuštění a zastavení. Fáze jsou spuštěny vzestupně a zastaveny v sestupném pořadí. Pozorovatel se může odhlásit tím, že zruší vrácenou jednorázovou verzi.

Pozorovatel životního cyklu

Komponenty, které se musí podílet na životním 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 volají se, když se fáze přihlásí k odběru během spuštění nebo vypnutí.

Nástroje

Pro usnadnění používání byly vytvořeny pomocné funkce pro běžné vzory použití životního cyklu.

Rozšíření

Pro přihlášení k odběru pozorovatelného životního cyklu existují funkce rozšíření, které nevyžadují, aby součást odběru implementoval ILifecycleObserver. Místo toho umožňují komponentám předávat funkce lambda nebo členů, 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í použití argumentů obecného typu místo názvu pozorovatele.

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. Pro tento účel bylo zavedeno rozhraní značek účastníků životního cyklu. Další informace o tom, jak se to bude používat při zkoumání životního cyklu sil a zrnitosti.

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

Příklad

Z našich testů životního cyklu níže je příkladem komponenty, která se účastní pozorovatelného životního cyklu ve více fázích životního cyklu.

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