Polimorfismo nel framework Reliable ActorsPolymorphism in the Reliable Actors framework

Il framework Reliable Actors consente di creare attori usando molte delle tecniche usate per la progettazione orientata agli oggetti.The Reliable Actors framework allows you to build actors using many of the same techniques that you would use in object-oriented design. Una di queste tecniche è il polimorfismo, che consente a tipi e interfacce di ereditare da più elementi padre generalizzati.One of those techniques is polymorphism, which allows types and interfaces to inherit from more generalized parents. L'ereditarietà nel framework Reliable Actors in genere segue il modello .NET con alcuni vincoli aggiuntivi.Inheritance in the Reliable Actors framework generally follows the .NET model with a few additional constraints. In caso di Java/Linux, segue il modello Java.In case of Java/Linux, it follows the Java model.

InterfacceInterfaces

Per il framework Reliable Actors è necessario definire almeno un'interfaccia da implementare attraverso il tipo di attore.The Reliable Actors framework requires you to define at least one interface to be implemented by your actor type. Questa interfaccia viene utilizzata per generare una classe proxy che può essere utilizzata dai client per comunicare con gli attori.This interface is used to generate a proxy class that can be used by clients to communicate with your actors. Le interfacce possono ereditare da altre interfacce, purché ogni interfaccia implementata da un tipo di attore e tutte le relative entità principali derivino da IActor (C#) o da Actor (Java).Interfaces can inherit from other interfaces as long as every interface that is implemented by an actor type and all of its parents ultimately derive from IActor(C#) or Actor(Java) . IActor (C#) e Actor (Java) sono le interfacce di base definite dalla piattaforma per gli attori rispettivamente nei framework .NET e Java.IActor(C#) and Actor(Java) are the platform-defined base interfaces for actors in the frameworks .NET and Java respectively. Pertanto, l'esempio di polimorfismo classico che utilizza le forme può apparire nel seguente modo:Thus, the classic polymorphism example using shapes might look something like this:

Gerarchia delle interfacce per gli attori della forma

TipiTypes

È inoltre possibile creare una gerarchia di tipi di attore, derivati dalla classe Attore di base fornita dalla piattaforma.You can also create a hierarchy of actor types, which are derived from the base Actor class that is provided by the platform. Nel caso delle forme può essere presente un tipo Shape (C#) o ShapeImpl (Java) di base.In the case of shapes, you might have a base Shape(C#) or ShapeImpl(Java) type:

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

I sottotipi di Shape (C#) o ShapeImpl (Java) possono eseguire l'override dei metodi dalla base.Subtypes of Shape(C#) or ShapeImpl(Java) can override methods from the base.

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

Si noti l’attributo ActorService nel tipo di attore.Note the ActorService attribute on the actor type. Questo attributo indica al framework Reliable Actors che deve creare automaticamente un servizio per l'hosting di attori di questo tipo.This attribute tells the Reliable Actor framework that it should automatically create a service for hosting actors of this type. In alcuni casi, si potrebbe creare un tipo di base progettato esclusivamente per la condivisione delle funzionalità con dei sottotipi e che non verrà mai usato per creare un'istanza di attori concreti.In some cases, you may wish to create a base type that is solely intended for sharing functionality with subtypes and will never be used to instantiate concrete actors. In questi casi, è necessario usare la parola chiave abstract per indicare che non si creerà mai un attore basato su quel tipo.In those cases, you should use the abstract keyword to indicate that you will never create an actor based on that type.

Passaggi successiviNext steps