Partager via

Tutoriel : Créer une application Orleans minimale

  • Article

Dans ce tutoriel, vous suivez des instructions pas à pas pour créer des parties mobiles fondamentales communes à la plupart des applications Orleans. Il est conçu pour être autonome et minimaliste.

Ce didacticiel ne dispose pas de la gestion des erreurs appropriée et d’autres codes essentiels qui seraient utiles pour un environnement de production. Toutefois, il doit vous aider à comprendre la structure d’application commune pour Orleans et vous permettre de concentrer votre apprentissage continu sur les parties les plus pertinentes pour vous.

Conditions préalables

Configuration du projet

Pour ce tutoriel, vous allez créer 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 donné pour chaque projet.

  1. Commencez par créer un projet d’application console dans une nouvelle solution. Appelez le composant de 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 Grains GrainInterfaces.
  2. Silo fait référence à Grains.
  3. Références Client GrainInterfaces.

Ajouter des packages NuGet Orleans

Projet Package NuGet
Silo Microsoft.Orleans.Server
Microsoft.Extensions.Logging.Console
Microsoft.Extensions.Hosting
Client Microsoft.Orleans.Client
Microsoft.Extensions.Logging.Console
Microsoft.Extensions.Hosting
Interfaces de grain Microsoft.Orleans.Sdk
Céréales Microsoft.Orleans.Sdk
Microsoft.Extensions.Logging.Abstractions

Microsoft.Orleans.Server, Microsoft.Orleans.Client et 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 add package ou Installer et gérer des packages dans Visual Studio à l'aide du Gestionnaire de packages NuGet.

Définir une interface de grain

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

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. Vous utilisez le fournisseur de clustering localhost, qui vous permet d’exécuter tout localement, sans dépendance sur les systèmes de stockage externes. Pour plus d’informations, consultez Configuration du développement local. Dans cet exemple, vous 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 :

Créer le client

Enfin, vous devez configurer un client pour communiquer avec les grains, le connecter au cluster (avec un seul silo dans celui-ci) et appeler le grain. La configuration de clustering doit correspondre à celle que vous avez 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 obtenu 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 dans le cadre du démarrage du 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