Přehled životního cyklu odstupňovaného cyklu

Orleans pro objednanou aktivaci a deaktivaci používají pozorovatelný životní cyklus (viz Orleans životní cyklus). To umožňuje spustit a zastavit logiku odstupňované logiky, systémové komponenty a logiku aplikace seřazeným způsobem během aktivace a shromažďování odstupňovaného intervalu.

FÁZE

Předdefinované fáze životního cyklu se řídí následujícími fázemi.

public static class GrainLifecycleStage
{
    public const int First = int.MinValue;
    public const int SetupState = 1_000;
    public const int Activate = 2_000;
    public const int Last = int.MaxValue;
}

• First: První fáze životního cyklu zrnka.
• SetupState: Před aktivací nastavte stav agregačního intervalu. U stavových zrn je to fáze, ve které IStorage<TState>.State se načítají z úložiště, kdy IStorage.RecordExists je true.
• Activate: Fáze, kde Grain.OnActivateAsync a Grain.OnDeactivateAsync jsou volána.
• Last: Poslední fáze životního cyklu zrnka.

I když se životní cyklus zrnitosti použije během aktivace zrnitosti, protože se během některých chybových případů neaktivují vždy (například chybová ukončení sil), aplikace by se neměly spoléhat na životní cyklus zrnitého intervalu, který se vždy spouští během deaktivace agregačního intervalu.

Zapojení životního cyklu odstupňované

Logika aplikace se může účastnit životního cyklu zrnit dvěma způsoby:

• Zrno se může účastnit jeho životního cyklu.
• Komponenty mají přístup k životnímu cyklu prostřednictvím kontextu aktivace odstupňovaného intervalu (viz IGrainContext.ObservableLifecycle).

• Zrno se může účastnit jeho životního cyklu.
• Komponenty mají přístup k životnímu cyklu prostřednictvím kontextu aktivace odstupňovaného intervalu (viz IGrainActivationContext.ObservableLifecycle).

Agregační cyklus se vždy účastní svého životního cyklu, takže logiku aplikace lze zavést přepsáním metody participování.

Příklad účasti

public override void Participate(IGrainLifecycle lifecycle)
{
    base.Participate(lifecycle);
    lifecycle.Subscribe(
        this.GetType().FullName,
        GrainLifecycleStage.SetupState,
        OnSetupState);
}

V předchozím příkladu přepíše metodu Grain.Participate tak, Grain<TGrainState> aby řekl životnímu cyklu, aby volal jeho OnSetupState metodu během GrainLifecycleStage.SetupState fáze životního cyklu.

Komponenty vytvořené během výstavby zrnitosti se mohou účastnit životního cyklu i bez přidání zvláštní logiky zrnitosti. Vzhledem k tomu, že kontext zrnitosti (IGrainContextvčetně životního cykluIGrainContext.ObservableLifecycle zrnka) se vytvoří před vytvořením agregačního intervalu, může se jakákoli komponenta vložená do zrnka kontejnerem účastnit životního cyklu zrnka.

Komponenty vytvořené během výstavby zrnitosti se mohou účastnit životního cyklu i bez přidání zvláštní logiky zrnitosti. Vzhledem k tomu, že se kontext aktivace agregačního intervalu (IGrainActivationContextvčetně životního cykluIGrainActivationContext.ObservableLifecycle zrnka) vytvoří před vytvořením agregačního intervalu, můžou se do životního cyklu zrnit všechny komponenty vložené do kontejneru.

Příklad účasti, vytváření a aktivace

Následující komponenta se při vytváření pomocí funkce Create(...)továrny účastní životního cyklu zrnitosti . Tato logika může existovat v konstruktoru komponenty, ale že riskuje, že komponenta přidaná do životního cyklu před tím, než je zcela sestavená, což nemusí být bezpečné.

public class MyComponent : ILifecycleParticipant<IGrainLifecycle>
{
    public static MyComponent Create(IGrainContext context)
    {
        var component = new MyComponent();
        component.Participate(context.ObservableLifecycle);
        return component;
    }

    public void Participate(IGrainLifecycle lifecycle)
    {
        lifecycle.Subscribe<MyComponent>(GrainLifecycleStage.Activate, OnActivate);
    }

    private Task OnActivate(CancellationToken ct)
    {
        // Do stuff
    }
}

public class MyComponent : ILifecycleParticipant<IGrainLifecycle>
{
    public static MyComponent Create(IGrainActivationContext context)
    {
        var component = new MyComponent();
        component.Participate(context.ObservableLifecycle);
        return component;
    }

    public void Participate(IGrainLifecycle lifecycle)
    {
        lifecycle.Subscribe<MyComponent>(GrainLifecycleStage.Activate, OnActivate);
    }

    private Task OnActivate(CancellationToken ct)
    {
        // Do stuff
    }
}

Když zaregistrujete ukázkovou komponentu v kontejneru služby pomocí své Create(...) funkce továrny, jakákoli agregace sestavená komponentou jako závislost bude mít komponentu, která se účastní svého životního cyklu, bez jakékoli zvláštní logiky v agregačním intervalu.

Registrace komponenty v kontejneru

services.AddTransient<MyComponent>(sp =>
    MyComponent.Create(sp.GetRequiredService<IGrainContext>());

services.AddTransient<MyComponent>(sp =>
    MyComponent.Create(sp.GetRequiredService<IGrainActivationContext>());

Agregační interval s komponentou jako závislostí

public class MyGrain : Grain, IMyGrain
{
    private readonly MyComponent _component;

    public MyGrain(MyComponent component)
    {
        _component = component;
    }
}