Hostování ASP.NET Core SignalR ve službách na pozadí

Dave Pringle a Brady Gaster

Tento článek obsahuje pokyny pro:

• Hostování SignalR center s využitím pracovního procesu na pozadí hostovaného s ASP.NET Core
• Odesílání zpráv připojeným klientům z rozhraní .NET BackgroundService.

Zobrazení nebo stažení ukázkového kódu (postup stažení)

Povolení SignalR při spuštění aplikace

Hostování ASP.NET Core SignalR Hubs v kontextu pracovního procesu na pozadí je stejné jako hostování centra ve webové aplikaci ASP.NET Core. Program.cs Volání builder.Services.AddSignalRpřidá požadované služby do vrstvy ASP.NET injektáže závislostí jádra (DI) pro podporu SignalR. Metoda MapHub je volána pro WebApplicationapp připojení koncových bodů centra v kanálu požadavku 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();

V předchozím příkladu ClockHub třída implementuje Hub<T> třídu pro vytvoření centra silného typu. Byl ClockHub nakonfigurován Program.cs tak, aby reagoval na požadavky v koncovém bodu /hubs/clock.

Další informace o centrech se silnými typy najdete v SignalR tématu Použití center pro ASP.NET Core.

Note

Tato funkce není omezena na třídu Hub<T> . Každá třída, která dědí z Centra, například DynamicHub, funguje.

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

Rozhraní používané silným typem ClockHub je IClock rozhraní.

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

SignalR Volání centra ze služby na pozadí

Při spuštění je třída, Worker a BackgroundService, povolena pomocí AddHostedService.

builder.Services.AddHostedService<Worker>();

Vzhledem k tomu SignalR , že je také povolena během spouštěcí fáze, ve které je každé centrum připojené k jednotlivému koncovému bodu v kanálu požadavku HTTP ASP.NET Core, je každé centrum reprezentováno IHubContext<T> na serveru. Pomocí funkcí DI jádra ASP.NET mohou další třídy, které vytvoří instance hostitelské vrstvy, jako jsou BackgroundService třídy, třídy kontroleru MVC nebo Razor stránkovací modely, získat odkazy na serverové rozbočovače přijetím instancí IHubContext<ClockHub, IClock> během výstavby.

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

Vzhledem k tomu, že ExecuteAsync metoda se v rámci služby na pozadí označuje jako iterativní, aktuální datum a čas serveru se odesílají připojeným klientům pomocí ClockHubnástroje .

Reakce na SignalR události pomocí služeb na pozadí

Podobně jako jednostráňová aplikace využívající klienta JavaScriptu pro SignalRdesktopovou aplikaci .NET nebo desktopovou aplikaci .NET pomocí klienta SignalRASP.NET Core BackgroundService .NET se dá použít také k IHostedService připojení ke SignalR službě Hubs a reakci na události.

Třída ClockHubClient implementuje IClock rozhraní i IHostedService rozhraní. Tímto způsobem je možné povolit během spouštění nepřetržitě a reagovat na události centra ze serveru.

public partial class ClockHubClient : IClock, IHostedService
{
}

Během inicializace ClockHubClient vytvoří instanci a HubConnection povolí IClock.ShowTime metodu jako obslužnou rutinu pro událost centra 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;
}

V implementaci IHostedService.StartAsyncHubConnection se spustí asynchronně.

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 Během metody je HubConnection uvolněna asynchronně.

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

Dodatečné zdroje

• Začínáme
• Hubs
• Publikování do Azure
• Rozbočovače se silnými typy