Tutorial: Crear una aplicación mínima de Orleans

En este tutorial, siga las instrucciones paso a paso para crear las partes móviles fundamentales comunes a la mayoría Orleans de las aplicaciones. Está diseñado para ser autónomo y minimalista.

Este tutorial carece de control de errores adecuado y otro código esencial útil para un entorno de producción. Sin embargo, debe ayudarle a comprender de forma práctica la estructura de aplicaciones común Orleans y permitirle centrar el aprendizaje continuo en las partes más relevantes para usted.

Prerrequisitos

• Visual Studio 2022 o posterior
• SDK de .NET 8.0 o posterior

Configuración del proyecto

En este tutorial, cree cuatro proyectos como parte de la misma solución:

• Biblioteca para contener las interfaces de grano.
• Biblioteca que contiene las clases de granos.
• Aplicación de consola para hospedar el silo.
• Aplicación de consola para hospedar el cliente.

Creación de la estructura en Visual Studio

Reemplace el código predeterminado por el código proporcionado para cada proyecto.

1. Empiece por crear un proyecto de aplicación de consola en una nueva solución. Llame al proyecto Silo y asigne el nombre a la solución OrleansHelloWorld. Para obtener más información sobre cómo crear una aplicación de consola, consulte Tutorial: Creación de una aplicación de consola de .NET mediante Visual Studio.
2. Agregue otro proyecto de aplicación de consola y asígnele el nombre Client.
3. Agregue una biblioteca de clases y asígnele el nombre GrainInterfaces. Para obtener información sobre cómo crear una biblioteca de clases, consulte Tutorial: Creación de una biblioteca de clases de .NET mediante Visual Studio.
4. Agregue otra biblioteca de clases y asígnele el nombre Grains.

Eliminación de archivos de origen predeterminados

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

Agregar referencias

1. Granos hace referencia a GrainInterfaces.
2. Silo hace referencia a Granos.
3. Cliente hace referencia a GrainInterfaces.

Adición de paquetes NuGet de Orleans

Microsoft.Orleans.Server, Microsoft.Orleans.Client y Microsoft.Orleans.Sdk son metapaquetes que aportan dependencias que probablemente necesite en el silo y el cliente. Para obtener más información sobre cómo agregar referencias de paquete, vea dotnet package add o Instalar y gestionar paquetes en Visual Studio usando el Administrador de paquetes NuGet.

Definición de una interfaz de grano

En el proyecto GrainInterfaces , agregue un archivo de código IHello.cs y defina la siguiente IHello interfaz:

namespace GrainInterfaces;

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

Definición de una clase de grano

En el proyecto Granos , agregue un archivo de código HelloGrain.cs y defina la siguiente clase:

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

Creación del silo

Para crear el proyecto silo, agregue código para inicializar un servidor que hospede y ejecute los granos, un silo. Use el proveedor de agrupación en clústeres localhost, que permite ejecutar todo localmente sin depender de sistemas de almacenamiento externos. Para obtener más información, vea Configuración de Desarrollo Local. En este ejemplo, ejecute un clúster con un solo silo.

Agregue el código siguiente a Program.cs del proyecto 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();

El código anterior:

• Configura el objeto IHost para usar Orleans con el método UseOrleans.
• Especifica el uso del proveedor de agrupamiento en clústeres localhost con el método UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
• Ejecuta el host y espera a que el proceso finalice escuchando Ctrl+C o SIGTERM.

Creación del cliente

Por último, configure un cliente para que se comunique con los granos, conéctelo al clúster (con un solo silo) e invoque el grano. La configuración de agrupación en clústeres debe coincidir con la usada para el silo. Para obtener más información, consulte Clústeres y Clientes.

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

Ejecución de la aplicación

Compile la solución y ejecute el Silo. Después de recibir el mensaje de confirmación de que el silo se está ejecutando, ejecute el cliente.

Para iniciar el Silo desde la línea de comandos, ejecute el siguiente comando desde el directorio que contiene el archivo de proyecto de Silo:

dotnet run

Verá múltiples resultados como parte del inicio de Silo. Después de ver el mensaje siguiente, está listo para ejecutar el cliente:

Application started. Press Ctrl+C to shut down.

En el directorio del proyecto de cliente, ejecute el mismo comando de la CLI de .NET en una ventana de terminal independiente para iniciar el cliente:

dotnet run

Para obtener más información sobre cómo ejecutar aplicaciones .NET, consulte dotnet run. Si usa Visual Studio, puede configurar varios proyectos de inicio.

Consulte también

• Lista de paquetes de Orleans
• Orleans Guía de configuración
• Orleans procedimientos recomendados