Delen via

Polymorfisme in het Reliable Actors-framework

  • Artikel

Met het Reliable Actors-framework kunt u actoren bouwen met behulp van veel van dezelfde technieken die u zou gebruiken in objectgeoriënteerd ontwerp. Een van deze technieken is polymorfisme, waardoor typen en interfaces kunnen overnemen van meer gegeneraliseerde ouders. Overname in het Reliable Actors-framework volgt over het algemeen het .NET-model met enkele extra beperkingen. In het geval van Java/Linux volgt het Java-model.

Interfaces

Voor het Reliable Actors-framework moet u ten minste één interface definiëren die door uw actortype moet worden geïmplementeerd. Deze interface wordt gebruikt om een proxyklasse te genereren die door clients kan worden gebruikt om met uw actoren te communiceren. Interfaces kunnen overnemen van andere interfaces zolang elke interface die wordt geïmplementeerd door een actortype en alle bijbehorende bovenliggende elementen uiteindelijk zijn afgeleid van IActor(C#) of Actor(Java) . IActor(C#) en Actor(Java) zijn respectievelijk de platformgedefinieerde basisinterfaces voor actoren in de frameworks .NET en Java. Het klassieke polymorfismevoorbeeld met behulp van shapes ziet er ongeveer als volgt uit:

Interfacehiërarchie voor shape-actoren

Typen

U kunt ook een hiërarchie van actortypen maken, die zijn afgeleid van de basisklasse Actor die wordt geleverd door het platform. In het geval van shapes hebt u mogelijk een basistype Shape(C#) of 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();
}

Subtypen van Shape(C#) of ShapeImpl(Java) kunnen methoden van de basis overschrijven.

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

Noteer het ActorService kenmerk van het actortype. Dit kenmerk vertelt het Reliable Actor-framework dat het automatisch een service moet maken voor hostingactoren van dit type. In sommige gevallen wilt u mogelijk een basistype maken dat uitsluitend is bedoeld voor het delen van functionaliteit met subtypen en die nooit wordt gebruikt om concrete actoren te instantiëren. In die gevallen moet u het abstract trefwoord gebruiken om aan te geven dat u nooit een actor op basis van dat type gaat maken.

Volgende stappen