Esercitazione: Creare un'applicazione Orleans minima

Articolo
07/03/2024

In questa esercitazione è possibile seguire istruzioni dettagliate per creare parti fondamentali comuni alla maggior parte delle applicazioni Orleans. È progettata per essere indipendente e minimalista.

Questa esercitazione non include una gestione degli errori appropriata e altro codice essenziale che sarebbe utile per un ambiente di produzione. Tuttavia, dovrebbe essere utile per ottenere una comprensione pratica della struttura di app comune per Orleans e consentire di concentrare l'apprendimento continuo sulle parti più rilevanti per ogni utente.

Prerequisiti

Impostazione progetto

Per questa esercitazione verranno creati quattro progetti come parte della stessa soluzione:

Libreria per contenere le interfacce dei grani.
Libreria per contenere le classi dei grani.
App console per ospitare il silo.
App console per ospitare il client.

Creare la struttura in Visual Studio

Sostituire il codice predefinito con il codice specificato per ogni progetto.

Per iniziare, creare un progetto di app console in una nuova soluzione. Chiamare il progetto Silo e denominare la soluzione OrleansHelloWorld. Per altre informazioni sulla creazione di un'app console, vedere Esercitazione: Creare un'applicazione console .NET con Visual Studio.
Aggiungere un altro progetto di app console e denominarlo Client.
Aggiungere una libreria di classi e denominarla GrainInterfaces. Per informazioni sulla creazione di una libreria di classi, vedere Esercitazione: Creare una libreria di classi .NET con Visual Studio.
Aggiungere un'altra libreria di classi e denominarla Grains.

Eliminare i file di origine predefiniti

Eliminare Class1.cs da Grains.
Eliminare Class1.cs da GrainInterfaces.

Aggiungere riferimenti

Grains fa riferimento a GrainInterfaces.
Silo fa riferimento a Grains.
Client fa riferimento a GrainInterfaces.

Aggiungere i pacchetti NuGet di Orleans

Project	Pacchetto NuGet
Silo	`Microsoft.Orleans.Server` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Client	`Microsoft.Orleans.Client` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Interfacce dei grani	`Microsoft.Orleans.Sdk`
Intervalli	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.Server, Microsoft.Orleans.Client e Microsoft.Orleans.Sdk sono metapacchetti che rendono disponibili le dipendenze più probabilmente necessarie per silo e client. Per altre informazioni sull'aggiunta di riferimenti ai pacchetti, vedere dotnet add package o Installare e gestire i pacchetti in Visual Studio con Gestione pacchetti NuGet.

Definire un'interfaccia dei grani

Nel progetto GrainInterfaces aggiungere un file di codice IHello.cs e definire l'interfaccia IHello seguente nel file:

namespace GrainInterfaces;

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

Definire una classe di grani

Nel progetto Grains aggiungere un file di codice HelloGrain.cs e definire la classe seguente nel file:

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!
            """);
    }
}

Creare il silo

Per creare il progetto Silo, aggiungere il codice per inizializzare un server che ospita ed esegue i grani, ovvero un silo. Si usa il provider di clustering localhost, che consente di eseguire tutto in locale, senza una dipendenza da sistemi di archiviazione esterni. Per ulteriori informazioni, vedere Configurazione di sviluppo locale. In questo esempio si esegue un cluster con un singolo silo.

Aggiungere il codice seguente a Program.cs del progetto 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();

Il codice precedente:

Configura IHost per l'uso di Orleans con il metodo UseOrleans.
Specifica che deve essere usato il provider di clustering localhost con il metodo UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
Esegue host e attende che il processo venga terminato, restando in ascolto di CTRL+C o SIGTERM.

Creare il client

Infine, è necessario configurare un client per comunicare con i grani, connetterlo al cluster (che contiene un singolo silo) e richiamare il grano. La configurazione del clustering deve corrispondere a quella usata per il silo. Per altre informazioni, vedere Cluster e client

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

Eseguire l'applicazione

Compilare la soluzione ed eseguire il silo. Dopo aver visualizzato il messaggio di conferma che il silo è in esecuzione, eseguire il client.

Per avviare il silo dalla riga di comando, eseguire il comando seguente dalla directory contenente il file di progetto del silo:

dotnet run

Verranno visualizzati numerosi output come parte dell'avvio del silo. Dopo aver visualizzato il messaggio seguente, si è pronti per eseguire il client:

Application started. Press Ctrl+C to shut down.

Dalla directory del progetto del client eseguire lo stesso comando dell'interfaccia della riga di comando di .NET in una finestra del terminale separata per avviare il client:

dotnet run

Per altre informazioni sull'esecuzione di app .NET, vedere dotnet run. Se si usa Visual Studio, è possibile configurare più progetti di avvio.

Condividi tramite