Hostowanie ASP.NET Core SignalR w usługach w tle

Przez Dave Pringle i Brady Gaster

Ten artykuł zawiera wskazówki dotyczące:

• Hostowanie SignalR centrów przy użyciu procesu roboczego w tle hostowanego przy użyciu platformy ASP.NET Core.
• Wysyłanie komunikatów do połączonych klientów z poziomu usługi w tle platformy .NET Core.

Wyświetl lub pobierz przykładowy kod (jak pobrać)

Włączanie SignalR przy uruchamianiu aplikacji

Hostowanie ASP.NET Core SignalR Hubs w kontekście procesu roboczego w tle jest identyczne z hostem centrum w aplikacji internetowej ASP.NET Core. W Program.cspliku wywołanie builder.Services.AddSignalR powoduje dodanie wymaganych usług do warstwy ASP.NET Core Dependency Injection (DI) w celu obsługi SignalRfunkcji . Metoda jest wywoływana MapHub w elemecie WebApplication app w celu połączenia punktów końcowych centrum w potoku żądania ASP.NET Core.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSignalR();
builder.Services.AddHostedService<Worker>();

var app = builder.Build();

app.MapHub<ClockHub>("/hubs/clock");

app.Run();

W poprzednim przykładzie ClockHub klasa implementuje klasę Hub<T> , aby utworzyć silnie typizowane centrum. Element ClockHub został skonfigurowany Program.cs do odpowiadania na żądania w punkcie końcowym /hubs/clock.

Aby uzyskać więcej informacji na temat silnie typiowanych centrów, zobacz Use hubs in for ASP.NET Core (Używanie centrów w programie SignalR dla platformy ASP.NET Core).

Uwaga

Ta funkcja nie jest ograniczona do klasy T> centrum<. Każda klasa dziedziczona z centrum, taka jak DynamicHub, działa.

public class ClockHub : Hub<IClock>
{
    public async Task SendTimeToClients(DateTime dateTime)
    {
        await Clients.All.ShowTime(dateTime);
    }
}

Interfejs używany przez silnie typizowane ClockHub jest interfejsem IClock .

public interface IClock
{
    Task ShowTime(DateTime currentTime);
}

Wywoływanie SignalR centrum z usługi w tle

Podczas uruchamiania Worker klasa BackgroundService, jest włączona przy użyciu polecenia AddHostedService.

builder.Services.AddHostedService<Worker>();

Ponieważ SignalR jest również włączona w fazie uruchamiania, w której każde centrum jest dołączone do pojedynczego punktu końcowego w potoku żądania HTTP platformy ASP.NET Core, każde centrum jest reprezentowane przez IHubContext<T> obiekt na serwerze. Korzystając z funkcji di platformy ASP.NET Core, inne klasy tworzone przez warstwę hostingu, takie jak BackgroundService klasy, klasy kontrolera MVC lub Razor modele stron, mogą uzyskać odwołania do centrów po stronie serwera, akceptując wystąpienia IHubContext<ClockHub, IClock> podczas budowy.

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;
    private readonly IHubContext<ClockHub, IClock> _clockHub;

    public Worker(ILogger<Worker> logger, IHubContext<ClockHub, IClock> clockHub)
    {
        _logger = logger;
        _clockHub = clockHub;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Worker running at: {Time}", DateTime.Now);
            await _clockHub.Clients.All.ShowTime(DateTime.Now);
            await Task.Delay(1000, stoppingToken);
        }
    }
}

ExecuteAsync Ponieważ metoda jest wywoływana iteracyjnie w usłudze w tle, bieżąca data i godzina serwera są wysyłane do połączonych klientów przy użyciu .ClockHub

Reagowanie na zdarzenia za SignalR pomocą usług w tle

Podobnie jak aplikacja jednostronicowa korzystająca z klienta JavaScript dla SignalRprogramu lub aplikacji klasycznej platformy .NET przy użyciu klienta platformy .NET platformy ASP.NET Core SignalR , implementacja BackgroundService IHostedService może być również używana do nawiązywania połączenia z SignalR usługami Hubs i reagowania na zdarzenia.

Klasa ClockHubClient implementuje zarówno interfejs, jak IClock IHostedService i interfejs. W ten sposób można ją włączyć podczas uruchamiania w celu ciągłego uruchamiania i reagowania na zdarzenia centrum z serwera.

public partial class ClockHubClient : IClock, IHostedService
{
}

Podczas inicjowania obiekt ClockHubClient tworzy wystąpienie obiektu HubConnection i włącza IClock.ShowTime metodę jako procedurę obsługi zdarzenia centrum ShowTime .

private readonly ILogger<ClockHubClient> _logger;
private HubConnection _connection;

public ClockHubClient(ILogger<ClockHubClient> logger)
{
    _logger = logger;
    
    _connection = new HubConnectionBuilder()
        .WithUrl(Strings.HubUrl)
        .Build();

    _connection.On<DateTime>(Strings.Events.TimeSent, ShowTime);
}

public Task ShowTime(DateTime currentTime)
{
    _logger.LogInformation("{CurrentTime}", currentTime.ToShortTimeString());

    return Task.CompletedTask;
}

W implementacji IHostedService.StartAsync HubConnection element jest uruchamiany asynchronicznie.

public async Task StartAsync(CancellationToken cancellationToken)
{
    // Loop is here to wait until the server is running
    while (true)
    {
        try
        {
            await _connection.StartAsync(cancellationToken);

            break;
        }
        catch
        {
            await Task.Delay(1000, cancellationToken);
        }
    }
}

IHostedService.StopAsync Podczas metody metoda HubConnection jest usuwana asynchronicznie.

public async Task StopAsync(CancellationToken cancellationToken)
{
    await _connection.DisposeAsync();
}

Dodatkowe zasoby

• Rozpocznij
• Centra
• Publikowanie na platformie Azure
• Silnie typizowane koncentratory