Polimorfizmus a Reliable Actors keretrendszerben

A Reliable Actors keretrendszer lehetővé teszi, hogy az objektumorientált tervezéshez használt számos technikával hozzon létre aktorokat. Az egyik ilyen technika a polimorfizmus, amely lehetővé teszi, hogy a típusok és interfészek örököljenek az általánosabb szülőktől. A Reliable Actors keretrendszer öröklődése általában a .NET-modellt követi néhány további korlátozással. Java/Linux esetén a Java-modellt követi.

Interfészek

A Reliable Actors keretrendszerhez legalább egy felületet meg kell határoznia, amelyet az aktor típusa implementál. Ez az interfész egy proxyosztály létrehozásához használható, amelyet az ügyfelek használhatnak a szereplőkkel való kommunikációhoz. A felületek öröklődhetnek más felületekről mindaddig, amíg egy aktortípus által implementált összes felület és annak összes szülője végül az IActor(C#) vagy az Actor(Java) nyelvből származik. Az IActor(C#) és az Aktor(Java) a .NET és a Java keretrendszerben szereplő szereplők platform által definiált alapfelületei. Így az alakzatokat használó klasszikus polimorfizmus-példa a következőképpen nézhet ki:

Típusok

Létrehozhat egy aktortípusokból álló hierarchiát is, amely a platform által biztosított alap aktorosztályból származik. Alakzatok esetén alap (C#) vagy ShapeImpl(Java) típussal rendelkezhetShape:

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

A (C#) vagy ShapeImpla (Java) altípusai Shapefelülbírálhatják a metódusokat az alapból.

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

Jegyezze fel az ActorService aktortípus attribútumát. Ez az attribútum tájékoztatja a Reliable Actor keretrendszert, hogy automatikusan létre kell hoznia egy szolgáltatást az ilyen típusú szereplők üzemeltetéséhez. Bizonyos esetekben előfordulhat, hogy olyan alaptípust szeretne létrehozni, amely kizárólag a funkciók altípusokkal való megosztására szolgál, és soha nem használható konkrét szereplők példányosítására. Ezekben az esetekben a abstract kulcsszóval jelezheti, hogy az adott típus alapján soha nem hoz létre aktort.

Következő lépések

• Megtudhatja , hogyan használja a Reliable Actors keretrendszer a Service Fabric platformot a megbízhatóság, a skálázhatóság és a konzisztens állapot biztosításához.
• Ismerje meg az aktor életciklusát.