Orleans livscykelöversikt

Vissa Orleans beteenden är tillräckligt komplexa för att de behöver ordnad start och avstängning. Vissa komponenter med sådana beteenden omfattar korn, silor och klienter. För att åtgärda detta har ett allmänt livscykelmönster för komponenter introducerats. Det här mönstret består av en observerbar livscykel som ansvarar för signalering i faser av en komponents start och avstängning samt livscykelobservatörer som ansvarar för att utföra start- eller avstängningsåtgärder i specifika steg.

Mer information finns i Kornlivscykel och Silo-livscykel.

Observerbar livscykel

Komponenter som behöver ordnad start och avstängning kan använda en observerbar livscykel som gör att andra komponenter kan observera livscykeln och få ett meddelande när en fas nås under start eller avstängning.

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

Prenumerationsanropet registrerar en övervakare för meddelande när ett steg nås när du startar eller stoppar. Observatörens namn är i rapporteringssyfte. Det stadium som anges vid vilken tidpunkt i start-/avstängningssekvensen som övervakaren kommer att meddelas. Varje fas i livscykeln kan observeras. Alla observatörer kommer att meddelas när fasen nås vid start och stopp. Faser startas i stigande ordning och stoppas i fallande ordning. Observatören kan avbryta prenumerationen genom att göra sig av med den returnerade disponibla.

Livscykelobservatör

Komponenter som behöver delta i en annan komponents livscykel måste tillhandahålla krokar för deras start- och avstängningsbeteenden och prenumerera på en specifik fas i en observerbar livscykel.

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

Både ILifecycleObserver.OnStart och ILifecycleObserver.OnStop anropas när fasen som prenumereras på nås under start/avstängning.

Verktyg

För enkelhetens skull har hjälpfunktioner skapats för vanliga användningsmönster för livscykeln.

Tillägg

Tilläggsfunktioner finns för att prenumerera på observerbar livscykel som inte kräver att den prenumererande komponenten implementerar ILifecycleObserver. I stället gör dessa att komponenter kan skickas i lambdas- eller medlemsfunktionen för att anropas i prenumerationsfaserna.

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

Liknande tilläggsfunktioner tillåter att allmänna typargument används i stället för observatörsnamnet.

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

Deltagande i livscykel

Vissa utökningspunkter behöver ett sätt att känna igen vilka komponenter som är intresserade av att delta i en livscykel. Ett gränssnitt för markör för livscykeldeltagare har introducerats för detta ändamål. Mer information om hur detta används beskrivs när du utforskar silo- och kornlivscykler.

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

Exempel

I våra livscykeltester är nedan ett exempel på en komponent som deltar i en observerbar livscykel i flera steg i livscykeln.

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