Héberger ASP.NET Core SignalR dans les services d'arrière-plan

Par Dave Pringle et Brady Gaster

Cet article fournit des conseils pour :

• Hosting SignalR Hubs à l'aide d'un processus de travail en arrière-plan hébergé avec ASP.NET Core.
• Envoi de messages aux clients connectés à partir d'un .NET Core BackgroundService.

Affichez ou téléchargez l’exemple de code (procédure de téléchargement)

Activer SignalR au démarrage de l’application

Hosting ASP.NET Core SignalR Hubs dans le contexte d'un processus de travail en arrière-plan est identique à l'hébergement d'un concentrateur dans une application Web ASP.NET Core. Dans Program.cs, l'appel builder.Services.AddSignalR ajoute les services requis à la couche ASP.NET Core Dependency Injection (DI) pour prendre en charge SignalR. La méthode MapHub est appelée sur WebApplication app pour connecter les points de terminaison Hub dans le pipeline de requêtes 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();

Dans l'exemple précédent, la classe ClockHub implémente la classe Hub<T> pour créer un Hub fortement typé. Le ClockHub a été configuré Program.cs pour répondre aux demandes au point de terminaison /hubs/clock.

Pour plus d'informations sur les Hubs fortement typés, consultez Utiliser des hubs SignalR dans pour ASP.NET Core.

Notes

Cette fonctionnalité n'est pas limitée à la classe Hub<T>. Toute classe qui hérite de Hub, telle que DynamicHub, fonctionne.

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

L'interface utilisée par les fortement typés ClockHub est l'interface IClock.

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

Appeler un hub SignalR à partir d'un service en arrière-plan

Au démarrage, la classe Worker, un BackgroundService, est activée à l'aide de AddHostedService.

builder.Services.AddHostedService<Worker>();

Comme SignalR est également activé pendant la phase de démarrage, dans laquelle chaque hub est attaché à un point de terminaison individuel dans le pipeline de requêtes HTTP d'ASP.NET Core, chaque hub est représenté par un IHubContext<T> sur le serveur. À l'aide des fonctionnalités DI d'ASP.NET Core, d'autres classes instanciées par la couche d'hébergement, telles que les classes BackgroundService, les classes de contrôleur MVC ou les modèles de page Razor, peuvent obtenir des références aux concentrateurs côté serveur en acceptant des instances de IHubContext<ClockHub, IClock> pendant la construction.

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

Comme la méthode ExecuteAsync est appelée de manière itérative dans le service d'arrière-plan, la date et l'heure actuelles du serveur sont envoyées aux clients connectés à l'aide de l'extension ClockHub.

Réagissez aux événements SignalR avec des services d'arrière-plan

Comme une application monopage utilisant le client JavaScript pour SignalR, ou une application de bureau .NET utilisant le client ASP.NET Core SignalR .NET, une implémentation BackgroundService ou IHostedService peut également être utilisée pour se connecter aux hubs SignalR et répondre aux événements.

La classe ClockHubClient implémente à la fois l'interface IClock et l'interface IHostedService. De cette façon, il peut être activé au démarrage pour s'exécuter en continu et répondre aux événements du Hub à partir du serveur.

public partial class ClockHubClient : IClock, IHostedService
{
}

Lors de l'initialisation, le ClockHubClient crée une instance d’un HubConnection et active la méthode IClock.ShowTime en tant que gestionnaire de l'événement du Hub 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;
}

Dans l’implémentation IHostedService.StartAsync, le HubConnection est démarré de manière asynchrone.

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

Pendant la méthode IHostedService.StopAsync, le HubConnection est supprimé de manière asynchrone.

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

Ressources supplémentaires

• Prise en main
• Hubs
• Publication dans Azure
• Hubs fortement typés