Orleans przegląd cyklu życia

Niektóre Orleans zachowania są wystarczająco złożone, że wymagają uporządkowanego uruchamiania i zamykania. Składniki, które charakteryzują się takimi zachowaniami, to granulki, silosy i klienci. Aby rozwiązać ten problem, Orleans wprowadzono ogólny wzorzec cyklu życia składnika. Ten wzorzec składa się z obserwowanego cyklu życia, odpowiedzialnego za sygnalizowanie etapów uruchamiania i zamykania składnika oraz obserwatorów cyklu życia odpowiedzialnych za wykonywanie operacji uruchamiania lub zamykania na określonych etapach.

Aby uzyskać więcej informacji, zobacz Cykl życia ziarna i Cykl życia silosu.

Obserwowany cykl życia

Składniki wymagające uporządkowanego uruchamiania i zamykania mogą korzystać z obserwowalnego cyklu życia. Dzięki temu inne składniki mogą obserwować cykl życia i otrzymywać powiadomienia po osiągnięciu określonego etapu podczas uruchamiania lub zamykania.

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

Wywołanie funkcji subskrypcji rejestruje obserwatora, aby powiadomić, kiedy osiągnięty zostanie etap uruchamiania lub zamykania. Nazwa obserwatora jest używana do celów raportowania. Etap wskazuje, w którym momencie w sekwencji uruchamiania/zamykania obserwator otrzymuje powiadomienie. Każdy etap cyklu życia można zaobserwować. Wszyscy obserwatorzy są powiadamiani o osiągnięciu etapu podczas uruchamiania i zamykania. Etapy zaczynają się w kolejności rosnącej i kończą w kolejności malejącej. Obserwator może anulować subskrypcję, usuwając zwrócony obiekt jednorazowy.

Obserwator cyklu życia

Składniki, które muszą uczestniczyć w cyklu życia innego składnika, powinny zapewniać punkty zaczepienia dla tych zachowań uruchamiania i zamykania oraz zarejestrować się na określony etap obserwowanego cyklu życia.

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

Zarówno ILifecycleObserver.OnStart , jak i ILifecycleObserver.OnStop są wywoływane po osiągnięciu subskrybowanego etapu podczas uruchamiania lub zamykania.

Usługi komunalne

Dla wygody funkcje pomocnicze są dostępne dla typowych wzorców użycia w cyklu życia.

Rozszerzenia

Funkcje rozszerzenia są dostępne do subskrybowania obserwowanego cyklu życia, które nie wymagają, aby subskrybujący komponent implementował ILifecycleObserver. Zamiast tego, pozwalają one składnikom przekazywać funkcje lambda lub funkcje członkowskie, które zostaną wywołane na subskrybowanych etapach.

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

Podobne funkcje rozszerzenia umożliwiają używanie argumentów typu ogólnego zamiast nazwy obserwatora.

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

Uczestnictwo w cyklu życia

Niektóre punkty rozszerzalności muszą mieć sposób na rozpoznanie, które komponenty są zainteresowane udziałem w cyklu życia. Interfejs znacznika uczestnika cyklu życia służy do tego celu. Więcej szczegółów na temat jego użycia opisano podczas eksplorowania cykli życia silosu i ziarna.

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

Przykład

Z testów Orleans cyklu życia poniżej znajduje się przykład składnika, który uczestniczy w cyklu życia, który można obserwować na różnych etapach.

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