Självstudie: Skapa en minimal Orleans applikation

Artikel
01/29/2025

I den här handledningen följer du steg-för-steg-instruktioner för att skapa grundläggande rörliga komponenter som är gemensamma för de flesta Orleans-program. Den är utformad för att vara fristående och minimalistisk.

Den här handledningen 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 Orleans och låta dig fokusera din fortsatta inlärning på de delar som är mest relevanta för dig.

Förutsättningar

Projektkonfiguration

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 namnet OrleansHelloWorld. Mer information om hur du skapar en konsolapp finns i Självstudie: Skapa ett .NET-konsolprogram med Visual Studio.
Lägg till ett annat Konsolappsprojekt och ge det namnet Client.
Lägg till ett klassbibliotek och ge det namnet GrainInterfaces. 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 namnet Grains.

Ta bort standardkällfiler

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

Lägga till referenser

Grains referenser GrainInterfaces.
Silo syftar på Grains.
Client 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`
Korninterfacen	`Microsoft.Orleans.Sdk`
Korn	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.Server, Microsoft.Orleans.Client och Microsoft.Orleans.Sdk är metapaket som medför de beroenden du troligen behöver på silo och klienten. Mer information om hur du lägger till paketreferenser kan du se i dotnet add package eller Install and manage packages in Visual Studio using the 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 projektet Grains 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. För mer information, se Lokal utvecklingskonfiguration. 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 projektet 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();

Föregående kod:

Konfigurerar IHost för att använda Orleans med metoden UseOrleans.
Anger att localhost-klusterprovidern ska användas med metoden UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
Kör host 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. För mer information, se 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 programmet

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

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

dotnet run

Du kommer att se många resultat som en del av silons uppstart. 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 run. Om du använder Visual Studio kan du konfigurera flera startprojekt.

Dela via