Tutorial: Criar um aplicativo Orleans mínimo

Neste tutorial, siga as instruções passo a passo para criar as peças móveis fundamentais comuns à maioria dos Orleans aplicativos. Foi concebido para ser autónomo e minimalista.

Este tutorial não possui tratamento de erros apropriado e outro código essencial útil para um ambiente de produção. No entanto, ele deve ajudá-lo a obter uma compreensão prática da Orleans estrutura comum do aplicativo e permitir que você concentre seu aprendizado contínuo nas partes mais relevantes para você.

Pré-requisitos

• Visual Studio 2022 ou posterior
• SDK do .NET 8.0 ou posterior

Configuração do projeto

Para este tutorial, crie quatro projetos como parte da mesma solução:

• Biblioteca para conter as interfaces de grão.
• Biblioteca para incluir as classes de grãos.
• Aplicativo de console para hospedar o Silo.
• Aplicativo de console para hospedar o Cliente.

Criar a estrutura no Visual Studio

Substitua o código padrão pelo código fornecido para cada projeto.

1. Comece criando um projeto de Aplicativo de Console em uma nova solução. Chame o projeto Silo e nomeie a solução OrleansHelloWorld. Para obter mais informações sobre como criar um aplicativo de console, consulte Tutorial: Criar um aplicativo de console .NET usando o Visual Studio.
2. Adicione outro projeto de Aplicativo de Console e nomeie-o Client.
3. Adicione uma Biblioteca de Classes e nomeie-a GrainInterfaces. Para obter informações sobre como criar uma biblioteca de classes, consulte Tutorial: Criar uma biblioteca de classes .NET usando o Visual Studio.
4. Adicione outra Biblioteca de Classes e nomeie-a Grains.

Excluir arquivos de origem padrão

1. Exclua Class1.cs do Grains.
2. Exclua Class1.cs de GrainInterfaces.

Adicionar referências

1. Grains referencia GrainInterfaces.
2. Silo referências Grãos.
3. Cliente Referências GrainInterfaces.

Adicionar Orleans pacotes NuGet

Microsoft.Orleans.Server, Microsoft.Orleans.Client e Microsoft.Orleans.Sdk são metapacotes que trazem dependências que provavelmente precisarás no Silo e no cliente. Para obter mais informações sobre como adicionar referências de pacote, consulte dotnet package add ou Install and manage packages in Visual Studio using the NuGet Package Manager.

Definir uma interface de grão

No projeto GrainInterfaces , adicione um arquivo de código IHello.cs e defina a seguinte IHello interface:

namespace GrainInterfaces;

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

Definir uma classe de grãos

No projeto Grains , adicione um arquivo de código HelloGrain.cs e defina a seguinte classe:

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

Criar o silo

Para criar o projeto Silo, adicione código para inicializar um servidor que hospeda e executa os grãos — um silo. Use o provedor de clustering localhost, que permite executar tudo localmente sem depender de sistemas de armazenamento externos. Para obter mais informações, consulte Configuração de Desenvolvimento Local. Neste exemplo, execute um cluster com um único silo.

Adicione o seguinte código ao Program.cs do projeto 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();

O código anterior:

• Configura o IHost para utilizar o Orleans através do método UseOrleans.
• Especifica o uso do provedor de agrupamento localhost através do método UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
• Executa o host e aguarda que o processo termine ouvindo Ctrl+C ou SIGTERM.

Criar o cliente

Finalmente, configure um cliente para se comunicar com os grãos, conecte-o ao cluster (com um único silo) e invoque o grão. A configuração de clustering deve corresponder à usada para o silo. Para obter mais informações, consulte Clusters e 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();

Execute o aplicativo

Compile a solução e corra o Silo. Depois de receber a mensagem de confirmação de que o Silo está em execução, execute o Cliente.

Para iniciar o Silo a partir da linha de comando, execute o seguinte comando no diretório que contém o arquivo de projeto do Silo:

dotnet run

Você verá numerosas saídas ao iniciar o Silo. Depois de ver a seguinte mensagem, você está pronto para executar o cliente:

Application started. Press Ctrl+C to shut down.

No diretório do projeto do cliente, execute o mesmo comando da CLI do .NET em uma janela de terminal separada para iniciar o cliente:

dotnet run

Para obter mais informações sobre como executar aplicativos .NET, consulte dotnet run. Se você estiver usando o Visual Studio, poderá configurar vários projetos de inicialização.

Ver também

• Lista de pacotes Orleans
• Orleans guia de configuração
• Orleans melhores práticas