Tutorial: Hola mundo

Esta introducción se vincula a la aplicación de ejemplo Hola mundo.

Los conceptos principales de Orleans implican un silo, un cliente y uno o varios granos. La creación de una aplicación de Orleans implica configurar el silo, configurar el cliente y escribir los granos.

Configurar el silo

Configure silos mediante programación, usando ISiloBuilder y varias clases de opciones complementarias. Puede encontrar una lista de todas las opciones en Lista de clases de opciones.

public static async Task SiloMain(string[] args)
{
    await Host.CreateDefaultBuilder(args)
        .UseOrleans(siloBuilder =>
        {
            siloBuilder.UseLocalhostClustering()
                .Configure<ClusterOptions>(options =>
                {
                    options.ClusterId = "dev";
                    options.ServiceId = "HelloWorldApp";
                })
                .Configure<EndpointOptions>(
                    options => options.AdvertisedIPAddress = IPAddress.Loopback)
                .ConfigureLogging(logging => logging.AddConsole());
        })
        .RunConsoleAsync();
}

El código anterior:

  • Crea un generador de hosts predeterminado.
  • Llama UseOrleans para configurar el silo.
  • Usa la agrupación en clústeres de localhost para el desarrollo local.
  • Configura los identificadores de clúster y de servicio.
  • Configura el punto de conexión para escuchar en bucle invertido.
  • Agrega registro en consola.

Configure silos mediante programación, usando ISiloHostBuilder y varias clases de opciones complementarias. Puede encontrar una lista de todas las opciones en Lista de clases de opciones.

static async Task<ISiloHost> StartSilo(string[] args)
{
    var siloHostBuilder = new SiloHostBuilder()
        .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 = siloHostBuilder.Build();
    await host.StartAsync();

    return host;
}
Opción Se usa para
.UseLocalhostClustering() Configura el cliente para conectarse a un silo en el host local.
ClusterOptions ClusterId es el nombre del Orleans clúster; debe ser el mismo para el silo y el cliente para que puedan comunicarse. ServiceId es el identificador que se usa para la aplicación y no debe cambiar entre implementaciones.
EndpointOptions Indica al silo dónde escuchar. En este ejemplo, use loopback.
Opción Se usa para
ConfigureApplicationParts Agrega el ensamblado de interfaz y clase de grano como elementos de aplicación a la aplicación de Orleans. Esto no es necesario en Orleans 7.0+ ya que los generadores de origen controlan esto automáticamente.

Después de cargar las configuraciones, compile el host y, a continuación, inícielo de forma asincrónica.

Configurar el cliente

De forma similar al silo, configure el cliente a través de IClientBuilder y una colección similar de clases de opciones.

public static async Task ClientMain(string[] args)
{
    using IHost host = Host.CreateDefaultBuilder(args)
        .UseOrleansClient(clientBuilder =>
        {
            clientBuilder.UseLocalhostClustering()
                .Configure<ClusterOptions>(options =>
                {
                    options.ClusterId = "dev";
                    options.ServiceId = "HelloWorldApp";
                });
        })
        .ConfigureLogging(logging => logging.AddConsole())
        .Build();

    await host.StartAsync();

    var client = host.Services.GetRequiredService<IClusterClient>();
    Console.WriteLine("Client successfully connected to silo host");

    await DoClientWork(client);

    await host.StopAsync();
}

El código anterior:

  • Crea un generador de hosts predeterminado.
  • Llama UseOrleansClient para configurar el cliente.
  • Usa la agrupación en clústeres de localhost para conectarse al silo local.
  • Configura los identificadores de clúster y servicio para que coincidan con el silo.
  • Inicia el host y recupera el IClusterClient del proveedor de servicios.

De forma similar al silo, configure el cliente a través de IClientBuilder y una colección similar de clases de opciones.

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 connected to silo host");
    return client;
}

private static async Task<bool> RetryFilter(Exception exception)
{
    if (exception.GetType() != typeof(SiloUnavailableException))
    {
        Console.WriteLine($"Cluster client failed to connect to cluster with unexpected error. Exception: {exception}");
        return false;
    }
    _attempt++;
    Console.WriteLine($"Cluster client attempt {_attempt} of 5 failed to connect to cluster. Exception: {exception}");
    if (_attempt > 5)
    {
        return false;
    }
    await Task.Delay(TimeSpan.FromSeconds(4));
    return true;
}
Opción Se usa para
.UseLocalhostClustering() Igual que para el silo
ClusterOptions Igual que para el silo

Busque una guía más detallada para configurar el cliente en la sección Configuración de cliente de la Guía de configuración .

Escribir un grano

Los granos son los primitivos clave del modelo de programación de Orleans. Son los bloques de creación de una Orleans aplicación, que sirven como unidades atómicas de aislamiento, distribución y persistencia. Los granos son objetos que representan entidades de aplicación. Al igual que en la programación de Object-Oriented clásica, un grano encapsula el estado de una entidad y codifica su comportamiento en la lógica de código. Los granos pueden contener referencias entre sí e interactuar invocando métodos expuestos a través de interfaces.

Obtenga más información sobre ellos en la sección Granos de la Orleans documentación.

Este es el cuerpo principal del código del grano Hola mundo:

public class HelloGrain : Orleans.Grain, IHello
{
    private readonly ILogger<HelloGrain> _logger;

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

    Task<string> IHello.SayHello(string greeting)
    {
        _logger.LogInformation("SayHello message received: greeting = '{Greeting}'", greeting);
        return Task.FromResult($"You said: '{greeting}', I say: Hello!");
    }
}

Una clase de grano implementa una o varias interfaces de grano. Para obtener más información, consulte la sección Granos .

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

Cómo funcionan juntas las partes

Este modelo de programación se basa en el concepto básico de programación distribuida Object-Oriented. Inicie la ISiloHost primera. A continuación, inicie el OrleansClient programa. El Main método de OrleansClient llama al método que inicia el cliente, StartClientWithRetries(). Pase el cliente al método 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");
}

En este punto, OrleansClient crea una referencia al IHello grano y llama a su método SayHello() a través de la interfaz IHello. Esta llamada activa el grano en el silo. OrleansClient envía un saludo al grano activado. El grano devuelve el saludo como una respuesta a OrleansClient, que a continuación lo muestra en la consola.

Ejecutar la aplicación de ejemplo

Para ejecutar la aplicación de ejemplo, consulte el archivo Léame.

  • Last updated on