Tutoriel : Hello world

Cette vue d’ensemble est liée à l’exemple d’application Hello World.

Les principaux concepts d’Orleans impliquent un silo, un client, et un ou plusieurs grains. La création d’une application Orleans implique la configuration du silo, la configuration du client et l’écriture des grains.

Configurer le silo

Configurez des silos par programmation via ISiloBuilder et plusieurs classes d’options supplémentaires. Vous trouverez une liste de toutes les options dans Liste des classes d’options.

static async Task<ISiloHost> StartSilo(string[] args)
{
    var builder = Host.CreateApplicationBuilder(args)
        UseOrleans(c =>
        {
            c.UseLocalhostClustering()
                .Configure<ClusterOptions>(options =>
                {
                    options.ClusterId = "dev";
                    options.ServiceId = "HelloWorldApp";
                })
                .Configure<EndpointOptions>(
                    options => options.AdvertisedIPAddress = IPAddress.Loopback)
                .ConfigureApplicationParts(
                    parts => parts.AddApplicationPart(typeof(HelloGrain).Assembly).WithReferences())
                .ConfigureLogging(logging => logging.AddConsole());
        });

    var host = builder.Build();
    await host.StartAsync();

    return host;
}

Choix	Utilisé pour
.UseLocalhostClustering()	Configure le client pour qu’il se connecte à un silo sur localhost.
ClusterOptions	ClusterId est le nom du Orleans cluster ; il doit être le même pour le silo et le client afin qu’ils puissent communiquer. ServiceId est l’ID utilisé pour l’application et ne doit pas changer entre les déploiements.
EndpointOptions	Indique au silo où écouter. Pour cet exemple, utilisez loopback.
ConfigureApplicationParts	Ajoute la classe de grain et l’assembly d’interface en tant que parties d’application à votre application Orleans.

Après le chargement des configurations, générez-le ISiloHost , puis démarrez-le de manière asynchrone.

Configurer le client

Comme pour le silo, configurez le client via IClientBuilder et une collection similaire de classes d’options.

static async Task<IClusterClient> StartClientWithRetries()
{
    attempt = 0;
    var client = new ClientBuilder()
        .UseLocalhostClustering()
        .Configure<ClusterOptions>(options =>
        {
            options.ClusterId = "dev";
            options.ServiceId = "HelloWorldApp";
        })
        .ConfigureLogging(logging => logging.AddConsole())
        .Build();

    await client.Connect(RetryFilter);
    Console.WriteLine("Client successfully connect to silo host");
    return client;
}

Choix	Utilisé pour
.UseLocalhostClustering()	Comme pour SiloHost
ClusterOptions	Comme pour SiloHost

Pour plus d’informations sur la configuration de votre client, consultez la section Configuration du client du Guide de configuration .

Écrire un mot

Les grains sont les primitives clés du modèle de programmation Orleans. Il s’agit des blocs de construction d’une Orleans application, servant d’unités atomiques d’isolation, de distribution et de persistance. Les grains sont des objets représentant des entités d’application. Tout comme dans la programmation Object-Oriented classique, un grain encapsule l’état d’une entité et encode son comportement dans la logique de code. Les grains peuvent contenir des références entre eux et interagir en appelant des méthodes exposées via des interfaces.

Pour en savoir plus sur eux, consultez la section Grains de la Orleans documentation.

Il s’agit du corps principal du code pour le grain Hello World :

namespace HelloWorld.Grains;

public class HelloGrain : Orleans.Grain, IHello
{
    Task<string> IHello.SayHello(string greeting)
    {
        logger.LogInformation($"SayHello message received: greeting = '{greeting}'");
        return Task.FromResult($"You said: '{greeting}', I say: Hello!");
    }
}

Une classe de grain implémente une ou plusieurs interfaces de grain. Pour plus d’informations, consultez la section Grains .

namespace HelloWorld.Interfaces;

public interface IHello : Orleans.IGrainWithIntegerKey
{
    Task<string> SayHello(string greeting);
}

Fonctionnement des parties ensemble

Ce modèle de programmation s’appuie sur le concept principal de la programmation distribuée de Object-Oriented. Démarrez la ISiloHost première. Ensuite, démarrez le OrleansClient programme. La méthode Main de OrleansClient appelle la méthode qui démarre le client, StartClientWithRetries(). Transmettez le client à la méthode DoClientWork().

static async Task DoClientWork(IClusterClient client)
{
    var friend = client.GetGrain<IHello>(0);
    var response = await friend.SayHello("Good morning, my friend!");
    Console.WriteLine($"\n\n{response}\n\n");
}

À ce stade, OrleansClient crée une référence au IHello grain et appelle sa SayHello() méthode via l’interface IHello . Cet appel active le grain dans le silo. OrleansClient envoie un message d’accueil au grain activé. Le grain renvoie le message d’accueil en réponse à OrleansClient, qui l’affiche ensuite sur la console.

Exécuter l’exemple d’application

Pour exécuter l’exemple d’application, reportez-vous au fichier Readme.