Orleans Lebenszyklusübersicht

Einige Orleans Verhaltensweisen sind so komplex, dass sie einen geordneten Start und ein geordnetes Herunterfahren erfordern. Komponenten mit solchen Verhaltensweisen umfassen Getreide, Silos und Kunden. Um dies zu beheben, hat Orleans ein allgemeines Komponentenlebenszyklusmuster eingeführt. Dieses Muster besteht aus einem feststellbaren Lebenszyklus, der für Signalisierungsphasen des Start- und Herunterfahrens einer Komponente verantwortlich ist, sowie Lebenszyklusbeobachter, die für das Ausführen von Start- oder Herunterfahren-Vorgängen in bestimmten Phasen verantwortlich sind.

Weitere Informationen finden Sie unter Grain-Lebenszyklus und Silo-Lebenszyklus.

Beobachtbarer Lebenszyklus

Komponenten, die ein geordnetes Starten und Herunterfahren benötigen, können einen feststellbaren Lebenszyklus verwenden. Dadurch können andere Komponenten den Lebenszyklus beobachten und Benachrichtigungen empfangen, wenn eine bestimmte Phase beim Starten oder Herunterfahren erreicht wird.

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

Der Abonnementaufruf registriert einen Beobachter, um Benachrichtigungen zu erhalten, wenn beim Starten oder Herunterfahren eine Phase erreicht wird. Der Name des Beobachters wird für Berichtszwecke verwendet. Die Phase gibt an, an welchem Punkt in der Start-/Herunterfahren-Sequenz der Beobachter eine Benachrichtigung empfängt. Jede Lebenszyklusstufe ist feststellbar. Alle Beobachter werden benachrichtigt, wenn die Stufe während des Startens und Herunterfahrens erreicht wird. Stufen beginnen in aufsteigender Reihenfolge und beenden in absteigender Reihenfolge. Der Beobachter kann sich abmelden, indem er das zurückgegebene einwegobjekt entsorget.

Lebenszyklusbeobachter

Komponenten, die am Lebenszyklus einer anderen Komponente beteiligt sein müssen, sollten Hooks für deren Inbetriebnahme und Stilllegung bereitstellen und sich an einer bestimmten Phase eines beobachtbaren Lebenszyklus registrieren.

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

Sowohl ILifecycleObserver.OnStart als auch ILifecycleObserver.OnStop werden aufgerufen, wenn die registrierte Phase beim Starten oder Herunterfahren erreicht wird.

Versorgungsdienste

Aus Gründen der Einfachheit sind Hilfsfunktionen für allgemeine Lebenszyklusnutzungsmuster vorhanden.

Erweiterungen

Erweiterungsfunktionen stehen zur Verfügung, um einen beobachtbaren Lebenszyklus zu abonnieren, für den die abonnierende Komponente nicht ILifecycleObserver implementieren muss. Stattdessen erlauben diese Komponenten das Übergeben von Lambda- oder Memberfunktionen, die in den vorgesehenen Phasen aufgerufen werden.

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

Ähnliche Erweiterungsfunktionen ermöglichen die Verwendung generischer Typargumente anstelle des Beobachternamens.

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

Lebenszyklusbeteiligung

Einige Erweiterbarkeitspunkte benötigen eine Möglichkeit, um zu erkennen, welche Komponenten daran interessiert sind, an einem Lebenszyklus teilzunehmen. Zu diesem Zweck dient eine Lebenszyklus-Teilnehmermarkierungsschnittstelle. Weitere Details zur Verwendung werden bei der Erkundung von Silo- und Getreidelebenszyklen behandelt.

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

Beispiel

Orleans Im Folgenden finden Sie ein Beispiel für eine Komponente, die an einem feststellbaren Lebenszyklus in mehreren Phasen teilnimmt.

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