Lernprogramm: Erstellen einer minimalen Orleans Anwendung

Artikel
01/31/2025

In diesem Tutorial folgen Sie Schritt-für-Schritt-Anleitungen, um grundlegende bewegliche Teile zu erstellen, die in den meisten Orleans-Anwendungen verwendet werden. Es ist so konzipiert, dass es eigenständig und minimalistisch ist.

In diesem Lernprogramm fehlt die entsprechende Fehlerbehandlung und anderer wesentlicher Code, der für eine Produktionsumgebung nützlich wäre. Es sollte Ihnen jedoch helfen, die allgemeine App-Struktur für Orleans zu verstehen und Ihnen zu ermöglichen, sich auf die für Sie relevantesten Teile zu konzentrieren.

Voraussetzungen

Projekteinrichtung

In diesem Lernprogramm erstellen Sie vier Projekte als Teil derselben Lösung:

Bibliothek, die die Kornschnittstellen enthalten soll.
Bibliothek, die die Kornklassen enthalten soll.
Konsolen-App zum Hosten des Silos.
Konsolen-App zum Hosten des Clients.

Erstellen der Struktur in Visual Studio

Ersetzen Sie den Standardcode durch den für jedes Projekt angegebenen Code.

Erstellen Sie zunächst ein Konsolen-App-Projekt in einer neuen Lösung. Rufen Sie den Projektteil Silo auf und benennen Sie die Lösung OrleansHelloWorld. Weitere Informationen zum Erstellen einer Konsolen-App finden Sie im Lernprogramm: Erstellen einer .NET-Konsolenanwendung mit Visual Studio.
Fügen Sie ein weiteres Konsolen-App-Projekt hinzu, und nennen Sie es Client.
Fügen Sie eine Klassenbibliothek hinzu, und nennen Sie sie GrainInterfaces. Informationen zum Erstellen einer Klassenbibliothek finden Sie im Lernprogramm: Erstellen einer .NET-Klassenbibliothek mit Visual Studio.
Fügen Sie eine weitere Klassenbibliothek hinzu, und nennen Sie sie Grains.

Löschen von Standardquelldateien

Löschen Sie Class1.cs aus Grains.
Class1.cs aus GrainInterfaceslöschen.

Hinzufügen von Verweisen

Grains verweist auf GrainInterfaces.
Silo bezieht sich auf Getreide.
Client verweist auf GrainInterfaces.

Hinzufügen von Orleans NuGet-Paketen

Projekt	NuGet-Paket
Silo	`Microsoft.Orleans.Server` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Kunde	`Microsoft.Orleans.Client` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Kornschnittstellen	`Microsoft.Orleans.Sdk`
Körner	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.Server, Microsoft.Orleans.Client und Microsoft.Orleans.Sdk sind Metapackagen, die Abhängigkeiten mitbringen, die Sie wahrscheinlich für silo und client benötigen. Weitere Informationen zum Hinzufügen von Paketverweisen finden Sie unter dotnet add package oder Pakete in Visual Studio mit dem NuGet-Paket-Manager installieren und verwalten.

Definieren einer Kornschnittstelle

Fügen Sie im GrainInterfaces Projekt eine IHello.cs Codedatei hinzu, und definieren Sie die folgende IHello Schnittstelle darin:

namespace GrainInterfaces;

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

Definieren einer Kornklasse

Fügen Sie im Grains Projekt eine HelloGrain.cs Codedatei hinzu, und definieren Sie die folgende Klasse darin:

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

Erstellen des Silos

Um das Silo-Projekt zu erstellen, fügen Sie Code zum Initialisieren eines Servers hinzu, der die Getreide hostet und ausführt – ein Silo. Sie verwenden den localhost-Clusteringanbieter, mit dem Sie alles lokal ausführen können, ohne dass sie von externen Speichersystemen abhängig sind. Weitere Informationen finden Sie unter Konfiguration für lokale Entwicklung. In diesem Beispiel betreiben Sie einen Cluster mit einem einzelnen Silo.

Fügen Sie den folgenden Code zum Program.cs des projekts Silo hinzu:

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

Der vorangehende Code:

Konfiguriert den IHost für die Verwendung von Orleans mit der UseOrleans-Methode.
Gibt an, dass der localhost-Clusteringanbieter mit der UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String)-Methode verwendet werden soll.
Führt den host aus und wartet, bis der Prozess beendet wird, indem auf STRG+C oder SIGTERM gelauscht wird.

Erstellen des Clients

Schließlich müssen Sie einen Client für die Kommunikation mit den Getreiden konfigurieren, ihn mit dem Cluster verbinden (mit einem einzigen Silo darin) und den Korn aufrufen. Die Clusterkonfiguration muss mit derjenigen übereinstimmen, die Sie für das Silo verwendet haben. Weitere Informationen finden Sie unter Cluster und Clients.

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

Ausführen der Anwendung

Erstellen Sie die Projektmappe, und führen Sie das Silo aus. Nachdem Sie die Bestätigungsmeldung erhalten haben, dass das Silo ausgeführt wird, führen Sie den Client aus.

Um den Silo über die Befehlszeile zu starten, führen Sie den folgenden Befehl aus dem Verzeichnis aus, das die Silo-Projektdatei enthält:

dotnet run

Im Rahmen des Startvorgangs des Silos werden zahlreiche Ausgaben angezeigt. Nachdem die folgende Meldung angezeigt wurde, können Sie den Client ausführen:

Application started. Press Ctrl+C to shut down.

Führen Sie im Clientprojektverzeichnis denselben .NET CLI-Befehl in einem separaten Terminalfenster aus, um den Client zu starten:

dotnet run

Weitere Informationen zum Ausführen von .NET-Apps finden Sie unter dotnet run. Wenn Sie Visual Studio verwenden, können Sie mehrere Startprojekte konfigurieren.

Teilen über