Självstudie: Skapa ett minimalt Orleans program

Artikel
07/03/2024

I den här självstudien följer du stegvisa instruktioner för att skapa grundläggande rörliga delar som är gemensamma för de flesta Orleans program. Den är utformad för att vara fristående och minimalistisk.

Den här självstudien saknar lämplig felhantering och annan viktig kod som skulle vara användbar för en produktionsmiljö. Det bör dock hjälpa dig att få en praktisk förståelse för den gemensamma appstrukturen för och göra det möjligt för Orleans dig att fokusera din fortsatta inlärning på de delar som är mest relevanta för dig.

Förutsättningar

Projektinställningar

I den här självstudien ska du skapa fyra projekt som en del av samma lösning:

Bibliotek som ska innehålla korngränssnitten.
Bibliotek som ska innehålla kornklasserna.
Konsolapp som värd för Silo.
Konsolapp som värd för klienten.

Skapa strukturen i Visual Studio

Ersätt standardkoden med den kod som anges för varje projekt.

Börja med att skapa ett konsolappprojekt i en ny lösning. Anropa projektdelens silo och ge lösningen OrleansHelloWorldnamnet . Mer information om hur du skapar en konsolapp finns i Självstudie: Skapa ett .NET-konsolprogram med Hjälp av Visual Studio.
Lägg till ett annat Konsolappsprojekt och ge det Clientnamnet .
Lägg till ett klassbibliotek och ge det GrainInterfacesnamnet . Information om hur du skapar ett klassbibliotek finns i Självstudie: Skapa ett .NET-klassbibliotek med Visual Studio.
Lägg till ett annat klassbibliotek och ge det Grainsnamnet .

Ta bort standardkällfiler

Ta bort Class1.cs från Korn.
Ta bort Class1.cs från GrainInterfaces.

Lägga till referenser

Korn refererar till GrainInterfaces.
Silo refererar till Korn.
Klienten refererar till GrainInterfaces.

Lägga till Orleans NuGet-paket

Projekt	NuGet-paket
Silo	`Microsoft.Orleans.Server` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Klient	`Microsoft.Orleans.Client` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Gränssnitt för korn	`Microsoft.Orleans.Sdk`
Korn	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.Server, Microsoft.Orleans.Client och Microsoft.Orleans.Sdk är metapaket som ger beroenden som du troligen behöver på Silo och klienten. Mer information om hur du lägger till paketreferenser finns i dotnet add package or Install and manage packages in Visual Studio using the NuGet Package Manager (Lägg till paket eller Installera och hantera paket i Visual Studio med Hjälp av NuGet Package Manager).

Definiera ett kornigt gränssnitt

I projektet GrainInterfaces lägger du till en IHello.cs kodfil och definierar följande IHello gränssnitt i det:

namespace GrainInterfaces;

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

Definiera en kornklass

I grains-projektet lägger du till en HelloGrain.cs kodfil och definierar följande klass i den:

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

Skapa Silo

Om du vill skapa Silo-projektet lägger du till kod för att initiera en server som är värd för och kör kornen – en silo. Du använder klustringsprovidern localhost, som gör att du kan köra allt lokalt, utan beroende av externa lagringssystem. Mer information finns i Konfiguration av lokal utveckling. I det här exemplet kör du ett kluster med en enda silo i det.

Lägg till följande kod i Program.cs för Silo-projektet :

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

Koden ovan:

Konfigurerar IHost att använda Orleans med UseOrleans -metoden.
Anger att localhost-klustringsprovidern ska användas med UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String) metoden .
host Kör och väntar på att processen ska avslutas genom att lyssna efter Ctrl+C eller .SIGTERM

Skapa klienten

Slutligen måste du konfigurera en klient för kommunikation med kornen, ansluta den till klustret (med en enda silo i) och anropa kornet. Klustringskonfigurationen måste matcha den du använde för silon. Mer information finns i Kluster och klienter

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

Kör appen

Skapa lösningen och kör Silo. När du har fått bekräftelsemeddelandet om att Silo körs kör du klienten.

Starta Silo från kommandoraden genom att köra följande kommando från katalogen som innehåller Silos projektfil:

dotnet run

Du ser många utdata som en del av starten av Silo. När du har sett följande meddelande är du redo att köra klienten:

Application started. Press Ctrl+C to shut down.

Från klientprojektkatalogen kör du samma .NET CLI-kommando i ett separat terminalfönster för att starta klienten:

dotnet run

Mer information om hur du kör .NET-appar finns i dotnet-körning. Om du använder Visual Studio kan du konfigurera flera startprojekt.

Dela via