Status Reliable Actors openen, opslaan en verwijderen

Artikel
08/25/2024

Reliable Actors zijn objecten met één thread die zowel logica als status kunnen inkapselen en de status betrouwbaar kunnen onderhouden. Elk actorexemplaren heeft een eigen statusbeheerder: een woordenlijstachtige gegevensstructuur waarmee sleutel-waardeparen betrouwbaar worden opgeslagen. De statusbeheerder is een wrapper rond een statusprovider. U kunt deze gebruiken om gegevens op te slaan, ongeacht welke persistentie-instelling wordt gebruikt.

Statusbeheersleutels moeten tekenreeksen zijn. Waarden zijn algemeen en kunnen elk type zijn, inclusief aangepaste typen. Waarden die zijn opgeslagen in de statusbeheerder moeten serializeerbaar zijn omdat ze tijdens de replicatie via het netwerk naar andere knooppunten kunnen worden verzonden en naar schijf kunnen worden geschreven, afhankelijk van de statuspersistentie-instelling van een actor.

De statusbeheerder maakt algemene woordenlijstmethoden beschikbaar voor het beheren van de status, vergelijkbaar met die in Reliable Dictionary.

Zie best practices voor het beheren van de actorstatus voor meer informatie.

Toegangsstatus

De status wordt geopend via de statusmanager per sleutel. State Manager-methoden zijn allemaal asynchroon omdat ze mogelijk schijf-I/O vereisen wanneer actoren de status behouden hebben. Bij eerste toegang worden statusobjecten in de cache opgeslagen in het geheugen. Herhaal toegangsbewerkingen rechtstreeks vanuit het geheugen en keer synchroon terug zonder dat er sprake is van schijf-I/O of asynchrone contextoverschakeling. In de volgende gevallen wordt een statusobject uit de cache verwijderd:

Een actormethode genereert een niet-verwerkte uitzondering nadat een object is opgehaald uit de statusbeheerder.
Een actor wordt opnieuw geactiveerd nadat deze is gedeactiveerd of na een storing.
De status van de statusproviderpagina's op schijf. Dit gedrag is afhankelijk van de implementatie van de statusprovider. De standaardstatusprovider voor de Persisted instelling heeft dit gedrag.

U kunt de status ophalen met behulp van een standaard get-bewerking die (C#) of NoSuchElementException(Java) genereert KeyNotFoundExceptionals er geen vermelding bestaat voor de sleutel:

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

U kunt ook de status ophalen met behulp van een TryGet-methode die niet wordt gegenereerd als er geen vermelding bestaat voor een sleutel:

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

Status opslaan

De methoden voor het ophalen van statusbeheer retourneren een verwijzing naar een object in het lokale geheugen. Als u dit object alleen in het lokale geheugen wijzigt, wordt het niet duurzaam opgeslagen. Wanneer een object wordt opgehaald uit de statusbeheerder en wordt gewijzigd, moet het opnieuw worden geplaatst in de statusbeheerder om duurzaam te worden opgeslagen.

U kunt de status invoegen met behulp van een onvoorwaardelijke set. Dit is het equivalent van de dictionary["key"] = value syntaxis:

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

U kunt de status toevoegen met behulp van een methode Toevoegen . Deze methode genereert InvalidOperationException(C#) of IllegalStateException(Java) wanneer wordt geprobeerd een sleutel toe te voegen die al bestaat.

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

U kunt ook de status toevoegen met behulp van een TryAdd-methode . Deze methode genereert niet wanneer wordt geprobeerd een sleutel toe te voegen die al bestaat.

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

Aan het einde van een actormethode slaat de statusmanager automatisch alle waarden op die zijn toegevoegd of gewijzigd door een invoeg- of bijwerkbewerking. Een 'opslaan' kan bestaan uit persistent maken op schijf en replicatie, afhankelijk van de gebruikte instellingen. Waarden die niet zijn gewijzigd, worden niet behouden of gerepliceerd. Als er geen waarden zijn gewijzigd, doet de opslagbewerking niets. Als het opslaan mislukt, wordt de gewijzigde status verwijderd en wordt de oorspronkelijke status opnieuw geladen.

U kunt de status ook handmatig opslaan door de SaveStateAsync methode aan te roepen op de actorbasis:

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

Status verwijderen

U kunt de status permanent verwijderen uit de statusbeheerder van een actor door de methode Remove aan te roepen. Deze methode genereert KeyNotFoundException(C#) of NoSuchElementException(Java) wanneer wordt geprobeerd een sleutel te verwijderen die niet bestaat.

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

U kunt de status ook permanent verwijderen met behulp van de methode TryRemove . Deze methode genereert niet wanneer wordt geprobeerd een sleutel te verwijderen die niet bestaat.

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

Volgende stappen

De status die is opgeslagen in Reliable Actors, moet worden geserialiseerd voordat deze naar de schijf wordt geschreven en gerepliceerd voor hoge beschikbaarheid. Meer informatie over serialisatie van actortypen.

Hierna vindt u meer informatie over diagnostische gegevens van actor en prestatiebewaking.

Delen via

Status Reliable Actors openen, opslaan en verwijderen

Toegangsstatus

Status opslaan

Status verwijderen

Volgende stappen

Feedback

Aanvullende resources