Zelfstudie: Hallo wereld

Dit overzicht is gekoppeld aan de Hallo wereld voorbeeldtoepassing.

De belangrijkste concepten zijn Orleans een silo, een client en een of meer korrels. Het maken van een Orleans app omvat het configureren van de silo, het configureren van de client en het schrijven van de korrels.

De silo configureren

Configureer silo's programmatisch via ISiloBuilder en verschillende aanvullende optieklassen. U vindt een lijst met alle opties in Lijst met optiesklassen.

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

De voorgaande code:

  • Maakt een standaard hostbuilder aan.
  • Roept UseOrleans aan om de silo te configureren.
  • Maakt gebruik van localhost-clustering voor lokale ontwikkeling.
  • Configureert de cluster- en service-IDs.
  • Hiermee configureert u het eindpunt om te luisteren op loopback.
  • Hiermee voegt u consolelogboekregistratie toe.

Configureer silo's programmatisch via ISiloHostBuilder en verschillende aanvullende optieklassen. U vindt een lijst met alle opties in Lijst met optiesklassen.

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;
}
Optie Gebruikt voor
.UseLocalhostClustering() Hiermee configureert u de client om verbinding te maken met een silo op de localhost.
ClusterOptions ClusterId is de naam voor het Orleans cluster; het moet hetzelfde zijn voor de silo en client, zodat ze kunnen communiceren. ServiceId is de id die wordt gebruikt voor de toepassing en mag niet worden gewijzigd in implementaties.
EndpointOptions Geeft aan waar de silo naar moet luisteren. Gebruik loopbackvoor dit voorbeeld .
Optie Gebruikt voor
ConfigureApplicationParts Voegt de grainklasse en interface-assembly toe als toepassingsonderdelen aan uw Orleans toepassing. Dit is niet nodig in Orleans 7.0+ omdat brongeneratoren dit automatisch verwerken.

Nadat u de configuraties hebt geladen, bouwt u de host en start u deze vervolgens asynchroon.

De client configureren

Net als bij de silo configureert u de client via IClientBuilder en een vergelijkbare verzameling optieklassen.

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

De voorgaande code:

  • Hiermee wordt een standaard host builder gemaakt.
  • Roept UseOrleansClient aan om de client te configureren.
  • Maakt gebruik van localhost-clustering om verbinding te maken met de lokale silo.
  • Hiermee configureert u de cluster- en service-id's zodat deze overeenkomen met de silo.
  • Start de host en haalt de IClusterClient van de serviceprovider op.

Net als bij de silo configureert u de client via IClientBuilder en een vergelijkbare verzameling optieklassen.

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;
}
Optie Gebruikt voor
.UseLocalhostClustering() Hetzelfde als voor de silo
ClusterOptions Hetzelfde als voor de silo

Zoek een uitgebreidere handleiding voor het configureren van uw client in de sectie Clientconfiguratie van de configuratiehandleiding.

Iets over een graan schrijven

Korrels zijn de belangrijkste primitieven van het Orleans programmeermodel. Dit zijn de bouwstenen van een Orleans toepassing, die fungeren als atomische isolatie-, distributie- en persistentie-eenheden. Korrels zijn objecten die toepassingsentiteiten vertegenwoordigen. Net als in klassieke Object-Oriented-programmering omsluit een grain de staat van een entiteit en codeert het het gedrag in codelogica. Korrels kunnen verwijzingen naar elkaar bevatten en communiceren door methoden aan te roepen die beschikbaar zijn via interfaces.

Meer informatie hierover vindt u in de sectie Grains van de Orleans documentatie.

Dit is de hoofdtekst van de code voor het Hallo wereld graan:

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

Een graanklasse implementeert een of meer graaninterfaces. Zie de sectie Grains voor meer informatie.

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

Hoe de onderdelen samenwerken

Dit programmeermodel is gebaseerd op het kernconcept van gedistribueerde Object-Oriented Programmeren. Start eerst de ISiloHost. Start vervolgens het OrleansClient programma. De Main methode van OrleansClient roept de methode aan die de client start, StartClientWithRetries(). Geef de client door aan de DoClientWork() Methode.

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

Op dit moment verwijst u naar het OrleansClient graan en roept u de IHello methode aan via de SayHello() interface. Deze aanroep activeert het graan in de silo. OrleansClient stuurt een begroeting naar het geactiveerde graan. De "grain" stuurt de begroeting als antwoord terug naar OrleansClient, waarna deze op de console wordt weergegeven.

De voorbeeld-app uitvoeren

Raadpleeg het leesmij-bestand om de voorbeeld-app uit te voeren.

  • Last updated on