Dela via

Komma åt, spara och ta bort reliable actors-tillstånd

  • Artikel

Reliable Actors är entrådade objekt som kan kapsla in både logik och tillstånd och underhålla tillståndet på ett tillförlitligt sätt. Varje aktörsinstans har en egen tillståndshanterare: en ordlisteliknande datastruktur som lagrar nyckel/värde-par på ett tillförlitligt sätt. Tillståndshanteraren är en omslutning runt en tillståndsprovider. Du kan använda den för att lagra data oavsett vilken beständighetsinställning som används.

Tillståndshanterarens nycklar måste vara strängar. Värden är generiska och kan vara valfri typ, inklusive anpassade typer. Värden som lagras i tillståndshanteraren måste vara seriellt för datakontrakt eftersom de kan överföras via nätverket till andra noder under replikeringen och kan skrivas till disk, beroende på en aktörs inställning för tillståndsbeständighet.

Tillståndshanteraren exponerar vanliga ordlistemetoder för att hantera tillstånd, liknande dem som finns i Reliable Dictionary.

Mer information finns i metodtips för att hantera aktörstillstånd.

Åtkomsttillstånd

Tillstånd nås via tillståndshanteraren via nyckel. State Manager-metoder är alla asynkrona eftersom de kan kräva disk-I/O när aktörer har kvarhållna tillstånd. Vid första åtkomst cachelagras tillståndsobjekt i minnet. Upprepa åtkomståtgärdernas åtkomstobjekt direkt från minnet och returnera synkront utan att orsaka disk-I/O eller asynkrona omkostnader för kontextväxling. Ett tillståndsobjekt tas bort från cacheminnet i följande fall:

  • En aktörsmetod genererar ett ohanterat undantag när det hämtar ett objekt från tillståndshanteraren.
  • En aktör återaktiveras, antingen efter att ha inaktiverats eller efter ett fel.
  • Tillståndsproviderns sidor tillstånd till disk. Det här beteendet beror på implementeringen av tillståndsprovidern. Standardtillståndsprovidern för inställningen Persisted har det här beteendet.

Du kan hämta tillstånd med hjälp av en vanlig Get-åtgärd som genererar KeyNotFoundException(C#) eller NoSuchElementException(Java) om det inte finns någon post för nyckeln:

[StatePersistence(StatePersistence.Persisted)]
class MyActor : Actor, IMyActor
{
    public MyActor(ActorService actorService, ActorId actorId)
        : base(actorService, actorId)
    {
    }

    public Task<int> GetCountAsync()
    {
        return this.StateManager.GetStateAsync<int>("MyState");
    }
}

@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
class MyActorImpl extends FabricActor implements  MyActor
{
    public MyActorImpl(ActorService actorService, ActorId actorId)
    {
        super(actorService, actorId);
    }

    public CompletableFuture<Integer> getCountAsync()
    {
        return this.stateManager().getStateAsync("MyState");
    }
}

Du kan också hämta tillstånd med hjälp av en TryGet-metod som inte genererar om det inte finns någon post för en nyckel:

class MyActor : Actor, IMyActor
{
    public MyActor(ActorService actorService, ActorId actorId)
        : base(actorService, actorId)
    {
    }

    public async Task<int> GetCountAsync()
    {
        ConditionalValue<int> result = await this.StateManager.TryGetStateAsync<int>("MyState");
        if (result.HasValue)
        {
            return result.Value;
        }

        return 0;
    }
}

class MyActorImpl extends FabricActor implements  MyActor
{
    public MyActorImpl(ActorService actorService, ActorId actorId)
    {
        super(actorService, actorId);
    }

    public CompletableFuture<Integer> getCountAsync()
    {
        return this.stateManager().<Integer>tryGetStateAsync("MyState").thenApply(result -> {
            if (result.hasValue()) {
                return result.getValue();
            } else {
                return 0;
            });
    }
}

Spara tillstånd

Tillståndshanterarens hämtningsmetoder returnerar en referens till ett objekt i det lokala minnet. Om du ändrar det här objektet enbart i lokalt minne sparas det inte på ett lämpligt sätt. När ett objekt hämtas från tillståndshanteraren och ändras, måste det återställas till tillståndshanteraren för att sparas på ett säkert sätt.

Du kan infoga tillstånd med hjälp av en ovillkorlig uppsättning, vilket motsvarar syntaxen dictionary["key"] = value :

[StatePersistence(StatePersistence.Persisted)]
class MyActor : Actor, IMyActor
{
    public MyActor(ActorService actorService, ActorId actorId)
        : base(actorService, actorId)
    {
    }

    public Task SetCountAsync(int value)
    {
        return this.StateManager.SetStateAsync<int>("MyState", value);
    }
}

@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
class MyActorImpl extends FabricActor implements  MyActor
{
    public MyActorImpl(ActorService actorService, ActorId actorId)
    {
        super(actorService, actorId);
    }

    public CompletableFuture setCountAsync(int value)
    {
        return this.stateManager().setStateAsync("MyState", value);
    }
}

Du kan lägga till tillstånd med hjälp av en Lägg till-metod . Den här metoden genererar InvalidOperationException(C#) eller IllegalStateException(Java) när den försöker lägga till en nyckel som redan finns.

[StatePersistence(StatePersistence.Persisted)]
class MyActor : Actor, IMyActor
{
    public MyActor(ActorService actorService, ActorId actorId)
        : base(actorService, actorId)
    {
    }

    public Task AddCountAsync(int value)
    {
        return this.StateManager.AddStateAsync<int>("MyState", value);
    }
}

@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
class MyActorImpl extends FabricActor implements  MyActor
{
    public MyActorImpl(ActorService actorService, ActorId actorId)
    {
        super(actorService, actorId);
    }

    public CompletableFuture addCountAsync(int value)
    {
        return this.stateManager().addOrUpdateStateAsync("MyState", value, (key, old_value) -> old_value + value);
    }
}

Du kan också lägga till tillstånd med hjälp av en TryAdd-metod . Den här metoden genererar inte när den försöker lägga till en nyckel som redan finns.

[StatePersistence(StatePersistence.Persisted)]
class MyActor : Actor, IMyActor
{
    public MyActor(ActorService actorService, ActorId actorId)
        : base(actorService, actorId)
    {
    }

    public async Task AddCountAsync(int value)
    {
        bool result = await this.StateManager.TryAddStateAsync<int>("MyState", value);

        if (result)
        {
            // Added successfully!
        }
    }
}

@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
class MyActorImpl extends FabricActor implements  MyActor
{
    public MyActorImpl(ActorService actorService, ActorId actorId)
    {
        super(actorService, actorId);
    }

    public CompletableFuture addCountAsync(int value)
    {
        return this.stateManager().tryAddStateAsync("MyState", value).thenApply((result)->{
            if(result)
            {
                // Added successfully!
            }
        });
    }
}

I slutet av en aktörsmetod sparar tillståndshanteraren automatiskt alla värden som har lagts till eller ändrats av en infognings- eller uppdateringsåtgärd. En "spara" kan omfatta beständig till disk och replikering, beroende på vilka inställningar som används. Värden som inte har ändrats bevaras eller replikeras inte. Om inga värden har ändrats gör spara-åtgärden ingenting. Om det inte går att spara ignoreras det ändrade tillståndet och det ursprungliga tillståndet läses in igen.

Du kan också spara tillstånd manuellt genom att anropa SaveStateAsync metoden på aktörsbasen:

async Task IMyActor.SetCountAsync(int count)
{
    await this.StateManager.AddOrUpdateStateAsync("count", count, (key, value) => count > value ? count : value);

    await this.SaveStateAsync();
}

interface MyActor {
    CompletableFuture setCountAsync(int count)
    {
        this.stateManager().addOrUpdateStateAsync("count", count, (key, value) -> count > value ? count : value).thenApply();

        this.stateManager().saveStateAsync().thenApply();
    }
}

Ta bort tillstånd

Du kan ta bort tillståndet permanent från en aktörs tillståndshanterare genom att anropa metoden Ta bort . Den här metoden genererar KeyNotFoundException(C#) eller NoSuchElementException(Java) när den försöker ta bort en nyckel som inte finns.

[StatePersistence(StatePersistence.Persisted)]
class MyActor : Actor, IMyActor
{
    public MyActor(ActorService actorService, ActorId actorId)
        : base(actorService, actorId)
    {
    }

    public Task RemoveCountAsync()
    {
        return this.StateManager.RemoveStateAsync("MyState");
    }
}

@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
class MyActorImpl extends FabricActor implements  MyActor
{
    public MyActorImpl(ActorService actorService, ActorId actorId)
    {
        super(actorService, actorId);
    }

    public CompletableFuture removeCountAsync()
    {
        return this.stateManager().removeStateAsync("MyState");
    }
}

Du kan också ta bort tillståndet permanent med hjälp av metoden TryRemove . Den här metoden genererar inte när den försöker ta bort en nyckel som inte finns.

[StatePersistence(StatePersistence.Persisted)]
class MyActor : Actor, IMyActor
{
    public MyActor(ActorService actorService, ActorId actorId)
        : base(actorService, actorId)
    {
    }

    public async Task RemoveCountAsync()
    {
        bool result = await this.StateManager.TryRemoveStateAsync("MyState");

        if (result)
        {
            // State removed!
        }
    }
}

@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
class MyActorImpl extends FabricActor implements  MyActor
{
    public MyActorImpl(ActorService actorService, ActorId actorId)
    {
        super(actorService, actorId);
    }

    public CompletableFuture removeCountAsync()
    {
        return this.stateManager().tryRemoveStateAsync("MyState").thenApply((result)->{
            if(result)
            {
                // State removed!
            }
        });
    }
}

Nästa steg

Tillstånd som lagras i Reliable Actors måste serialiseras innan det skrivs till disken och replikeras för hög tillgänglighet. Läs mer om serialisering av aktörstyp.

Läs sedan mer om aktörsdiagnostik och prestandaövervakning.