Tutoriel : Créer une application Orleans minimale

Dans ce tutoriel, suivez les instructions pas à pas pour créer les éléments dynamiques fondamentaux communs à la plupart des applications Orleans. Il est conçu pour être autonome et minimaliste.

Ce tutoriel ne dispose pas de la gestion des erreurs appropriée et d’autres code essentiels utiles pour un environnement de production. Toutefois, il doit vous aider à acquérir une compréhension pratique de la structure d’application commune Orleans et vous permettre de concentrer votre apprentissage continu sur les parties les plus pertinentes pour vous.

Conditions préalables

• Visual Studio 2022 ou version ultérieure
• Sdk .NET 8.0 ou version ultérieure

Configuration du projet

Pour ce tutoriel, créez quatre projets dans le cadre de la même solution :

• Bibliothèque pour héberger les interfaces de grain.
• Bibliothèque pour contenir les classes de grain.
• Application console pour héberger le Silo.
• Application console pour héberger le client.

Créer la structure dans Visual Studio

Remplacez le code par défaut par le code fourni pour chaque projet.

1. Commencez par créer un projet d’application console dans une nouvelle solution. Appelez le projet Silo et nommez la solution OrleansHelloWorld. Pour plus d’informations sur la création d’une application console, consultez Tutoriel : Créer une application console .NET à l’aide de Visual Studio.
2. Ajoutez un autre projet d’application console et nommez-le Client.
3. Ajoutez une bibliothèque de classes et nommez-la GrainInterfaces. Pour plus d’informations sur la création d’une bibliothèque de classes, consultez Tutoriel : Créer une bibliothèque de classes .NET à l’aide de Visual Studio.
4. Ajoutez une autre bibliothèque de classes et nommez-la Grains.

Supprimer les fichiers sources par défaut

1. Supprimez Class1.cs de Grains.
2. Supprimez Class1.cs de GrainInterfaces.

Ajouter des références

1. Références GrainsGrainInterfaces.
2. Silo fait référence à Grains.
3. Références ClientGrainInterfaces.

Ajouter des packages NuGet Orleans

Microsoft.Orleans.Server, Microsoft.Orleans.Clientet Microsoft.Orleans.Sdk sont des métapackages qui apportent des dépendances dont vous aurez probablement besoin sur le silo et le client. Pour plus d’informations sur l’ajout de références de package, consultez dotnet package add or Install and manage packages in Visual Studio using the NuGet Package Manager.

Définir une interface de grain

Dans le projet GrainInterfaces , ajoutez un fichier de code IHello.cs et définissez l’interface suivante IHello :

namespace GrainInterfaces;

public interface IHello : IGrainWithIntegerKey
{
    ValueTask<string> SayHello(string greeting);
}

Définir une classe de grain

Dans le projet Grains , ajoutez un fichier de code HelloGrain.cs et définissez la classe suivante :

using GrainInterfaces;
using Microsoft.Extensions.Logging;

namespace Grains;

public class HelloGrain : Grain, IHello
{
    private readonly ILogger _logger;

    public HelloGrain(ILogger<HelloGrain> logger) => _logger = logger;

    ValueTask<string> IHello.SayHello(string greeting)
    {
        _logger.LogInformation("""
            SayHello message received: greeting = "{Greeting}"
            """,
            greeting);
        
        return ValueTask.FromResult($"""

            Client said: "{greeting}", so HelloGrain says: Hello!
            """);
    }
}

Créer le silo

Pour créer le projet Silo, ajoutez du code pour initialiser un serveur qui héberge et exécute les grains, un silo. Utilisez le fournisseur de clustering localhost, qui permet d’exécuter tout localement sans dépendre des systèmes de stockage externes. Pour plus d’informations, consultez Configuration du développement local. Dans cet exemple, exécutez un cluster avec un seul silo.

Ajoutez le code suivant à Program.cs du projet Silo :

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

IHostBuilder builder = Host.CreateDefaultBuilder(args)
    .UseOrleans(silo =>
    {
        silo.UseLocalhostClustering()
            .ConfigureLogging(logging => logging.AddConsole());
    })
    .UseConsoleLifetime();

using IHost host = builder.Build();

await host.RunAsync();

Code précédent :

• Configure le IHost pour utiliser Orleans avec la méthode UseOrleans.
• Spécifie l’utilisation du fournisseur de clustering localhost avec la UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String) méthode.
• Exécute le host et attend la fin du processus en surveillant Ctrl+C ou SIGTERM.

Créer le client

Enfin, configurez un client pour communiquer avec les grains, connectez-le au cluster (avec un seul silo) et appelez le grain. La configuration de clustering doit correspondre à celle utilisée pour le silo. Pour plus d’informations, consultez Clusters et clients.

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.DependencyInjection;
using GrainInterfaces;

IHostBuilder builder = Host.CreateDefaultBuilder(args)
    .UseOrleansClient(client =>
    {
        client.UseLocalhostClustering();
    })
    .ConfigureLogging(logging => logging.AddConsole())
    .UseConsoleLifetime();

using IHost host = builder.Build();
await host.StartAsync();

IClusterClient client = host.Services.GetRequiredService<IClusterClient>();

IHello friend = client.GetGrain<IHello>(0);
string response = await friend.SayHello("Hi friend!");

Console.WriteLine($"""
    {response}

    Press any key to exit...
    """);

Console.ReadKey();

await host.StopAsync();

Exécuter l’application

Générez la solution et exécutez le silo. Après avoir reçu le message de confirmation indiquant que le Silo est en cours d’exécution, exécutez le client.

Pour démarrer le silo à partir de la ligne de commande, exécutez la commande suivante à partir du répertoire contenant le fichier projet du silo :

dotnet run

Vous verrez de nombreux résultats lors du démarrage de Silo. Après avoir vu le message suivant, vous êtes prêt à exécuter le client :

Application started. Press Ctrl+C to shut down.

À partir du répertoire du projet client, exécutez la même commande CLI .NET dans une fenêtre de terminal distincte pour démarrer le client :

dotnet run

Pour plus d’informations sur l’exécution d’applications .NET, consultez dotnet run. Si vous utilisez Visual Studio, vous pouvez configurer plusieurs projets de démarrage.

Voir aussi

• Liste des packages Orleans
• guide de configuration Orleans
• Orleans meilleures pratiques