Tutorial: Olá mundo

2025-05-29

Esta visão geral está ligada ao aplicativo de exemplo Hello World.

Os principais conceitos envolvem Orleans um silo, um cliente e um ou mais grãos. Criar um Orleans aplicativo envolve configurar o silo, configurar o cliente e escrever os grãos.

Configurar o silo

Configure silos programaticamente via ISiloBuilder e várias classes de opções suplementares. Você pode encontrar uma lista de todas as opções em Lista de classes de opções.

static async Task<ISiloHost> StartSilo(string[] args)
{
    var builder = Host.CreateApplicationBuilder(args)
        UseOrleans(c =>
        {
            c.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 = builder.Build();
    await host.StartAsync();

    return host;
}

Opção	Utilizado para
`.UseLocalhostClustering()`	Configura o cliente para se conectar a um silo no localhost.
`ClusterOptions`	`ClusterId` é o nome do Orleans cluster, deve ser o mesmo para o silo e o cliente para que eles possam se comunicar. `ServiceId` é a ID usada para o aplicativo e não deve ser alterada entre implantações.
`EndpointOptions`	Indica ao silo onde escutar. Para este exemplo, use `loopback`.
`ConfigureApplicationParts`	Adiciona a classe grain e o conjunto de interface como partes do aplicativo ao seu Orleans aplicativo.

Depois de carregar as configurações, crie ISiloHost e depois inicie-o de forma assíncrona.

Configurar o cliente

Semelhante ao silo, configure o cliente via IClientBuilder e uma coleção semelhante de classes de opção.

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

Opção	Utilizado para
`.UseLocalhostClustering()`	O mesmo que para `SiloHost`
`ClusterOptions`	O mesmo que para `SiloHost`

Encontre um guia mais detalhado para configurar seu cliente na seção Configuração do cliente do Guia de configuração.

Escreva um grão

Os grãos são os primitivos chave do Orleans modelo de programação. Eles são os blocos de construção de uma Orleans aplicação, servindo como unidades atômicas de isolamento, distribuição e persistência. Grãos são objetos que representam entidades de aplicação. Assim como na programação Object-Oriented clássica, um grão encapsula o estado de uma entidade e codifica seu comportamento na lógica de código. Os grãos podem conter referências uns aos outros e interagir invocando métodos expostos através de interfaces.

Leia mais sobre eles na seção Grãos da Orleans documentação.

Este é o corpo principal de código para o grão Hello World:

namespace HelloWorld.Grains;

public class HelloGrain : Orleans.Grain, IHello
{
    Task<string> IHello.SayHello(string greeting)
    {
        logger.LogInformation($"SayHello message received: greeting = '{greeting}'");
        return Task.FromResult($"You said: '{greeting}', I say: Hello!");
    }
}

Uma classe de grão implementa uma ou mais interfaces de grão. Para obter mais informações, consulte a seção Grãos .

namespace HelloWorld.Interfaces;

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

Como as peças funcionam juntas

Este modelo de programação baseia-se no conceito central de programação Object-Oriented distribuída. Comece o ISiloHost primeiro. Em seguida, inicie o programa OrleansClient. O Main método de OrleansClient chama o método que inicia o cliente, StartClientWithRetries(). Passe o cliente para o DoClientWork() método.

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

Neste ponto, OrleansClient cria uma referência ao IHello grão e chama seu SayHello() método através da IHello interface. Esta chamada ativa o grão no silo. OrleansClient envia uma saudação ao grão ativado. O programa devolve a saudação como uma resposta ao OrleansClient, que depois a exibe no console.

Executar o aplicativo de exemplo

Para executar o aplicativo de exemplo, consulte o Leiame.

Partilhar via