Dela via

Polymorfism i reliable actors-ramverket

  • Artikel

Med ramverket Reliable Actors kan du skapa aktörer med hjälp av många av de tekniker som du använder i objektorienterad design. En av dessa tekniker är polymorfism, vilket gör att typer och gränssnitt kan ärva från mer generaliserade föräldrar. Arv i Reliable Actors-ramverket följer vanligtvis .NET-modellen med några ytterligare begränsningar. När det gäller Java/Linux följer den Java-modellen.

Gränssnitt

Ramverket Reliable Actors kräver att du definierar minst ett gränssnitt som ska implementeras av din aktörstyp. Det här gränssnittet används för att generera en proxyklass som kan användas av klienter för att kommunicera med dina aktörer. Gränssnitt kan ärva från andra gränssnitt så länge varje gränssnitt som implementeras av en aktörstyp och alla dess föräldrar slutligen härleds från IActor (C#) eller Actor(Java) . IActor(C#) och Actor(Java) är plattformsdefinierade basgränssnitt för aktörer i ramverken .NET respektive Java. Det klassiska polymorfismexemplet med former kan därför se ut ungefär så här:

Gränssnittshierarki för formaktörer

Typer

Du kan också skapa en hierarki med aktörstyper som härleds från den grundläggande aktörsklassen som tillhandahålls av plattformen. När det gäller former kan du ha en bastyp Shape(C#) eller ShapeImpl(Java):

public abstract class Shape : Actor, IShape
{
    public abstract Task<int> GetVerticeCount();

    public abstract Task<double> GetAreaAsync();
}

public abstract class ShapeImpl extends FabricActor implements Shape
{
    public abstract CompletableFuture<int> getVerticeCount();

    public abstract CompletableFuture<double> getAreaAsync();
}

Undertyper av Shape(C#) eller ShapeImpl(Java) kan åsidosätta metoder från basen.

[ActorService(Name = "Circle")]
[StatePersistence(StatePersistence.Persisted)]
public class Circle : Shape, ICircle
{
    public override Task<int> GetVerticeCount()
    {
        return Task.FromResult(0);
    }

    public override async Task<double> GetAreaAsync()
    {
        CircleState state = await this.StateManager.GetStateAsync<CircleState>("circle");

        return Math.PI *
            state.Radius *
            state.Radius;
    }
}

@ActorServiceAttribute(name = "Circle")
@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
public class Circle extends ShapeImpl implements Circle
{
    @Override
    public CompletableFuture<Integer> getVerticeCount()
    {
        return CompletableFuture.completedFuture(0);
    }

    @Override
    public CompletableFuture<Double> getAreaAsync()
    {
        return (this.stateManager().getStateAsync<CircleState>("circle").thenApply(state->{
          return Math.PI * state.radius * state.radius;
        }));
    }
}

ActorService Observera attributet för aktörstypen. Det här attributet anger för Reliable Actor-ramverket att det automatiskt ska skapa en tjänst för värdaktörer av den här typen. I vissa fall kanske du vill skapa en bastyp som endast är avsedd för delning av funktioner med undertyper och aldrig kommer att användas för att instansiera konkreta aktörer. I sådana fall bör du använda nyckelordet abstract för att ange att du aldrig kommer att skapa en aktör baserat på den typen.

Nästa steg