Configuration SignalR de ASP.NET Core

Cet article traite de la configuration ASP.NET Core SignalR .

Pour BlazorSignalR obtenir des conseils, qui ajoutent ou remplacent les instructions de cet article, consultez ASP.NET conseils de baseBlazorSignalR.

Options de sérialisation JSON/MessagePack

ASP.NET Core SignalR prend en charge deux protocoles pour l’encodage des messages : JSON et MessagePack. Chaque protocole a des options de configuration de sérialisation.

La sérialisation JSON peut être configurée sur le serveur à l’aide de la méthode d’extension AddJsonProtocol . AddJsonProtocol peut être ajouté après AddSignalR dans Startup.ConfigureServices. La méthode AddJsonProtocol accepte un délégué qui reçoit un objet options. La PayloadSerializerOptions propriété sur cet objet est un System.Text.JsonJsonSerializerOptions objet qui peut être utilisé pour configurer la sérialisation des arguments et des valeurs de retour. Pour plus d’informations, consultez la documentation System.Text.Json.

Par exemple, pour configurer le sérialiseur pour ne pas modifier la casse des noms de propriétés, plutôt que les noms en casse mixte par défaut, utilisez le code suivant dans Program.cs :

builder.Services.AddSignalR()
    .AddJsonProtocol(options => {
        options.PayloadSerializerOptions.PropertyNamingPolicy = null;
    });

Dans le client .NET, la même AddJsonProtocol méthode d’extension existe sur HubConnectionBuilder. Le namespace Microsoft.Extensions.DependencyInjection doit être importé pour résoudre la méthode d’extension :

// At the top of the file:
using Microsoft.Extensions.DependencyInjection;

// When constructing your connection:
var connection = new HubConnectionBuilder()
    .AddJsonProtocol(options => {
        options.PayloadSerializerOptions.PropertyNamingPolicy = null;
    })
    .Build();

Remarque

Il n’est pas possible de configurer la sérialisation JSON dans le client JavaScript pour l’instant.

Basculer vers Newtonsoft.Json

Si vous avez besoin de fonctionnalités de Newtonsoft.Json qui ne sont pas prises en charge dans System.Text.Json, consultez Basculer vers Newtonsoft.Json.

Options de sérialisation MessagePack

La sérialisation MessagePack peut être configurée en fournissant un délégué à l'appel AddMessagePackProtocol. Pour plus d’informations, consultez MessagePack SignalR .

Remarque

Il n’est pas possible de configurer la sérialisation MessagePack dans le client JavaScript pour l’instant.

Configurer les options du serveur

Le tableau suivant décrit les options de configuration SignalR des hubs :

Choix	Valeur par défaut	Descriptif
ClientTimeoutInterval	30 secondes	Le serveur considère que le client est déconnecté s’il n’a pas reçu de message (y compris keep-alive) dans cet intervalle. Cela pourrait prendre plus de temps que cet intervalle de délai d'expiration pour que le client soit marqué comme déconnecté en raison de son implémentation. La valeur recommandée est double de la KeepAliveInterval valeur.
HandshakeTimeout	15 secondes	Si le client n’envoie pas de message de négociation initial dans cet intervalle de temps, la connexion est fermée. Il s’agit d’un paramètre avancé qui ne doit être modifié que si des erreurs de délai d’attente de l'initialisation de la connexion se produisent en raison d’une latence grave du réseau. Pour plus de détails sur le processus de handshake, consultez la spécification du SignalR protocole Hub.
KeepAliveInterval	15 secondes	Si le serveur n’a pas envoyé de message dans cet intervalle, un message ping est envoyé automatiquement pour maintenir la connexion ouverte. Lors de la modification de KeepAliveInterval, modifiez le paramètre ServerTimeout ou serverTimeoutInMilliseconds sur le client. La valeur recommandée ServerTimeout ou serverTimeoutInMilliseconds est le double de la valeur KeepAliveInterval.
SupportedProtocols	Tous les protocoles installés	Protocoles pris en charge par ce hub. Par défaut, tous les protocoles inscrits sur le serveur sont autorisés. Les protocoles peuvent être supprimés de cette liste pour désactiver des protocoles spécifiques pour des hubs individuels.
EnableDetailedErrors	false	Si true, lorsqu'une exception est levée dans une méthode Hub, les messages d'exception détaillés sont retournés aux clients. La valeur par défaut est false due au fait que ces messages d’exception peuvent contenir des informations sensibles.
StreamBufferCapacity	10	Nombre maximal d’éléments pouvant être mis en mémoire tampon pour les flux de chargement du client. Si cette limite est atteinte, le traitement des appels est bloqué jusqu’à ce que le serveur traite les éléments de flux.
MaximumReceiveMessageSize	32 Ko	Taille maximale d’un seul message hub entrant. L’augmentation de la valeur peut augmenter le risque d’attaques par déni de service (DoS).
MaximumParallelInvocationsPerClient	1	Nombre maximal de méthodes centrales que chaque client peut appeler en parallèle avant la mise en file d'attente.
DisableImplicitFromServicesParameters	false	Si possible, les arguments de méthode Hub sont résolus à partir de la DI.

Les options peuvent être configurées pour tous les hubs en fournissant un délégué d’options à l'appel AddSignalR dans Program.cs.

 builder.Services.AddSignalR(hubOptions =>
 {
     hubOptions.EnableDetailedErrors = true;
     hubOptions.KeepAliveInterval = TimeSpan.FromMinutes(1);
 });

Les options d’un hub unique remplacent les options globales fournies AddSignalR et peuvent être configurées à l’aide de AddHubOptions:

builder.Services.AddSignalR().AddHubOptions<ChatHub>(options =>
{
    options.EnableDetailedErrors = true;
});

Options de configuration HTTP avancées

Permet HttpConnectionDispatcherOptions de configurer des paramètres avancés liés aux transports et à la gestion des mémoires tampons. Ces options sont configurées en transmettant un délégué à MapHub dans Program.cs.

using Microsoft.AspNetCore.Http.Connections;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddSignalR();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();
app.MapHub<ChatHub>("/chathub", options =>
{
    options.Transports =
        HttpTransportType.WebSockets |
        HttpTransportType.LongPolling;
}
);
app.Run();

Le tableau suivant décrit les options de configuration des options HTTP avancées de ASP.NET Core SignalR:

Choix	Valeur par défaut	Descriptif
ApplicationMaxBufferSize	64 Ko	Nombre maximal d’octets reçus du client que le serveur met en mémoire tampon avant d’appliquer la contre-pression. L’augmentation de cette valeur permet au serveur de recevoir des messages plus volumineux plus rapidement sans appliquer de rétropression, mais peut augmenter la consommation de mémoire.
TransportMaxBufferSize	64 Ko	Nombre maximal d’octets envoyés par l’application que le serveur met en mémoire tampon avant d’observer la contre-pression. L’augmentation de cette valeur permet au serveur de mettre en mémoire tampon les messages plus volumineux plus rapidement sans attendre la rétropression, mais peut augmenter la consommation de mémoire.
AuthorizationData	Données collectées automatiquement à partir des Authorize attributs appliqués à la classe Hub.	Liste des IAuthorizeData objets utilisés pour déterminer si un client est autorisé à se connecter au hub.
Transports	Tous les services de transport sont disponibles.	Énumération d’indicateurs de bits des valeurs HttpTransportType qui peuvent restreindre les transports qu’un client peut utiliser pour se connecter.
LongPolling	Voir ci-dessous.	Options supplémentaires propres au transport d’interrogation longue.
WebSockets	Voir ci-dessous.	Options supplémentaires spécifiques au transport WebSockets.
MinimumProtocolVersion	0	Spécifiez la version minimale du protocole de négociation. Cela permet de limiter les clients aux versions plus récentes.
CloseOnAuthenticationExpiration	faux	Définissez cette option pour activer le suivi de l’expiration de l’authentification, ce qui ferme les connexions à l’expiration d’un jeton.

Le transport d’interrogation longue offre des options supplémentaires qui peuvent être configurées via la propriété LongPolling :

Choix	Valeur par défaut	Descriptif
PollTimeout	90 secondes	Durée maximale pendant laquelle le serveur attend qu’un message soit envoyé au client avant de terminer une demande de sondage unique. La diminution de cette valeur entraîne l’émission de nouvelles demandes de sondage plus fréquemment par le client.

Le transport WebSocket a des options supplémentaires qui peuvent être configurées à l’aide de la WebSockets propriété :

Choix	Valeur par défaut	Descriptif
CloseTimeout	5 secondes	Une fois le serveur fermé, si le client ne parvient pas à fermer dans cet intervalle de temps, la connexion est arrêtée.
SubProtocolSelector	null	Délégué qui peut être utilisé pour définir l’en-tête Sec-WebSocket-Protocol sur une valeur personnalisée. Le délégué reçoit les valeurs demandées par le client comme entrée et doit retourner la valeur souhaitée.

Configurer les options du client

Les options clientes peuvent être configurées sur le HubConnectionBuilder type (disponible dans les clients .NET et JavaScript). Il est également disponible dans le client Java, mais c'est la sous-classe HttpHubConnectionBuilder qui contient les options de configuration du générateur, ainsi que HubConnection elle-même.

Configuration de la journalisation

La journalisation est configurée dans le client .NET à l’aide de la ConfigureLogging méthode. Les fournisseurs de journalisation et les filtres peuvent être enregistrés de la même façon que sur le serveur. Pour plus d’informations, consultez la documentation de journalisation dans ASP.NET Core .

Remarque

Pour inscrire des fournisseurs de journalisation, vous devez installer les packages nécessaires. Consultez la section Fournisseurs de journalisation intégrés de la documentation pour obtenir une liste complète.

Par exemple, pour activer la journalisation de la console, installez le Microsoft.Extensions.Logging.Console package NuGet. Appelez la méthode d’extension AddConsole :

var connection = new HubConnectionBuilder()
    .WithUrl("https://example.com/chathub")
    .ConfigureLogging(logging => {
        logging.SetMinimumLevel(LogLevel.Information);
        logging.AddConsole();
    })
    .Build();

Dans le client JavaScript, une méthode similaire configureLogging existe. Fournissez une LogLevel valeur indiquant le niveau minimal de messages de journal à produire. Les logs sont écrits dans la fenêtre de la console du navigateur.

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub")
    .configureLogging(signalR.LogLevel.Information)
    .build();

Au lieu d'une LogLevel valeur, vous pouvez également fournir une string valeur représentant un nom de niveau de log. Cela est utile lors de la configuration de la journalisation dans des environnements où vous n’avez pas accès aux constantes.

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub")
    .configureLogging("warn")
    .build();

Le tableau suivant répertorie les niveaux de journalisation disponibles. La valeur que vous attribuez à configureLogging détermine le niveau minimal de consignation qui sera enregistré. Les messages enregistrés à ce niveau , ou les niveaux répertoriés après celui-ci dans la table, seront enregistrés.

Chaîne	LogLevel
trace	LogLevel.Trace
debug	LogLevel.Debug
info ouinformation	LogLevel.Information
warn ouwarning	LogLevel.Warning
error	LogLevel.Error
critical	LogLevel.Critical
none	LogLevel.None

Remarque

Pour désactiver entièrement la journalisation, spécifiez signalR.LogLevel.None dans la configureLogging méthode.

Pour plus d’informations sur la journalisation, consultez la SignalR documentation de diagnostic.

Le client Java SignalR utilise la bibliothèque SLF4J pour la journalisation. Il s'agit d'une API de journalisation de haut niveau qui permet aux utilisateurs de la bibliothèque de choisir leur propre implémentation de journalisation spécifique en introduisant une dépendance de journalisation spécifique. L'extrait de code suivant montre comment utiliser java.util.logging avec le client Java SignalR.

implementation 'org.slf4j:slf4j-jdk14:1.7.25'

Si vous ne configurez pas la journalisation dans vos dépendances, SLF4J charge un journal de non-opération par défaut avec le message d'avertissement suivant :

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

Cela peut être ignoré en toute sécurité.

Configurer les transports autorisés

Les transports utilisés par SignalR peuvent être configurés dans l’appel WithUrl (withUrl en JavaScript). Une opération bitwise-OR des valeurs de HttpTransportType peut être utilisée pour restreindre le client à n'utiliser que les transports spécifiés. Tous les transports sont activés par défaut.

Par exemple, pour désactiver le transport d'événements Server-Sent, mais autoriser les connexions WebSockets et les connexions d'interrogation longue :

var connection = new HubConnectionBuilder()
    .WithUrl("https://example.com/chathub", HttpTransportType.WebSockets | HttpTransportType.LongPolling)
    .Build();

Dans le client JavaScript, les transports sont configurés en réglant le champ transport dans l'objet options fourni à withUrl.

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub", { transport: signalR.HttpTransportType.WebSockets | signalR.HttpTransportType.LongPolling })
    .build();

Dans cette version du client Java WebSockets est le seul transport disponible.

Dans le client Java, le transport est sélectionné avec la méthode withTransport sur le HttpHubConnectionBuilder. Le client Java utilise par défaut le transport WebSockets.

HubConnection hubConnection = HubConnectionBuilder.create("https://example.com/chathub")
    .withTransport(TransportEnum.WEBSOCKETS)
    .build();

Remarque

Le client Java SignalR ne prend pas encore en charge le transport de secours.

Configurer l’authentification du porteur

Pour fournir des données d’authentification avec SignalR des demandes, utilisez l’option AccessTokenProvider (accessTokenFactory en JavaScript) pour spécifier une fonction qui retourne le jeton d’accès souhaité. Dans le client .NET, ce jeton d’accès est transmis en tant que jeton HTTP « Authentification du porteur » (à l’aide de l’en-tête Authorization avec un type de Bearer). Dans le client JavaScript, le jeton d’accès est utilisé comme jeton du porteur, sauf dans quelques cas où les API de navigateur limitent la possibilité d’appliquer des en-têtes (en particulier, dans les événements Server-Sent et les requêtes WebSockets). Dans ces cas, le jeton d’accès est fourni en tant que valeur access_token de chaîne de requête.

Dans le client .NET, l’option AccessTokenProvider peut être spécifiée à l’aide du délégué d’options dans WithUrl:

var connection = new HubConnectionBuilder()
    .WithUrl("https://example.com/chathub", options => {
        options.AccessTokenProvider = async () => {
            // Get and return the access token.
        };
    })
    .Build();

Dans le client JavaScript, le jeton d’accès est configuré en définissant le accessTokenFactory champ sur l’objet options dans withUrl:

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub", {
        accessTokenFactory: () => {
            // Get and return the access token.
            // This function can return a JavaScript Promise if asynchronous
            // logic is required to retrieve the access token.
        }
    })
    .build();

Dans le client Java SignalR, vous pouvez configurer un jeton de porteur à utiliser pour l'authentification en fournissant une fabrique de jetons d'accès à HttpHubConnectionBuilder. Utilisez withAccessTokenFactory pour fournir un RxJavaSingle<String>. Avec un appel à Single.defer, vous pouvez écrire une logique pour produire des jetons d'accès pour votre client.

HubConnection hubConnection = HubConnectionBuilder.create("https://example.com/chathub")
    .withAccessTokenProvider(Single.defer(() -> {
        // Your logic here.
        return Single.just("An Access Token");
    })).build();

Configurer les options de délai d’expiration et de conservation en vie

Options supplémentaires pour la configuration du délai d’attente et du comportement de maintien de la connexion :

.FILET

Choix	Valeur par défaut	Descriptif
WithServerTimeout	30 secondes (30 000 millisecondes)	Délai d’expiration de l’activité du serveur et défini directement sur HubConnectionBuilder. Si le serveur n’a pas envoyé de message dans cet intervalle, le client considère le serveur déconnecté et déclenche l’événement Closed (onclose en JavaScript). Cette valeur doit être suffisamment grande pour qu’un message ping soit envoyé à partir du serveur et reçu par le client dans l’intervalle de délai d’expiration. La valeur recommandée est un nombre au moins double de la valeur d'intervalleWithKeepAliveInterval de maintien de la connexion du serveur pour permettre l’arrivée des pings.
HandshakeTimeout	15 secondes	Le délai d'expiration pour la négociation initiale du serveur est disponible directement sur l'objet HubConnection lui-même. Si le serveur n’envoie pas de réponse de poignée de main dans cet intervalle, le client annule la poignée de main et déclenche l’événement Closed (onclose en JavaScript). Il s’agit d’un paramètre avancé qui ne doit être modifié que si des erreurs de délai d’attente de l'initialisation de la connexion se produisent en raison d’une latence grave du réseau. Pour plus de détails sur le processus de handshake, consultez la spécification du SignalR protocole Hub.
WithKeepAliveInterval	15 secondes	Détermine l’intervalle auquel le client envoie des messages ping et est défini directement sur HubConnectionBuilder. Ce paramètre permet au serveur de détecter les déconnexions matérielles, par exemple lorsqu’un client débranche son ordinateur du réseau. L’envoi d’un message du client réinitialise le minuteur au début de l’intervalle. Si le client n’a pas envoyé de message dans le délai défini sur le ClientTimeoutInterval serveur, le serveur considère le client comme déconnecté.

Dans le client .NET, les délais d’expiration sont spécifiés en tant que valeurs TimeSpan.

L’exemple suivant montre les valeurs qui sont deux fois les valeurs par défaut :

var builder = new HubConnectionBuilder()
    .WithUrl(Navigation.ToAbsoluteUri("/chathub"))
    .WithServerTimeout(TimeSpan.FromSeconds(60))
    .WithKeepAliveInterval(TimeSpan.FromSeconds(30))
    .Build();

builder.On<string, string>("ReceiveMessage", (user, message) => ...

await builder.StartAsync();

JavaScript

Choix	Valeur par défaut	Descriptif
withServerTimeout	30 secondes (30 000 millisecondes)	Délai d’expiration de l’activité du serveur et défini directement sur HubConnectionBuilder. Si le serveur n’a pas envoyé de message dans cet intervalle, le client considère le serveur déconnecté et déclenche l’événement onclose . Ce paramètre permet au serveur de détecter les déconnexions matérielles, par exemple lorsqu’un client débranche son ordinateur du réseau. Cette valeur doit être suffisamment grande pour qu’un message ping soit envoyé à partir du serveur et reçu par le client dans l’intervalle de délai d’expiration. La valeur recommandée est un nombre au moins double de la valeur d'intervallewithKeepAliveInterval de maintien de la connexion du serveur pour permettre l’arrivée des pings.
withKeepAliveInterval	15 secondes (15 000 millisecondes)	Détermine l’intervalle auquel le client envoie des messages ping et est défini directement sur HubConnectionBuilder. Ce paramètre permet au serveur de détecter les déconnexions matérielles, par exemple lorsqu’un client débranche son ordinateur du réseau. L’envoi d’un message du client réinitialise le minuteur au début de l’intervalle. Si le client n’a pas envoyé de message dans le délai défini sur le ClientTimeoutInterval serveur, le serveur considère le client comme déconnecté. Le ping se produit au maximum aussi souvent que le serveur envoie des pings. Si le serveur envoie un ping toutes les cinq secondes, l’affectation d’une valeur inférieure à 5000 (5 secondes) correspond à un test ping toutes les cinq secondes. La valeur par défaut est de 15 secondes. L’intervalle de conservation active doit être inférieur ou égal à la moitié de la valeur affectée au délai d’expiration du serveur (withServerTimeout).

L’exemple suivant montre les valeurs qui sont deux fois les valeurs par défaut :

var connection = new signalR.HubConnectionBuilder()
  .withUrl("/chatHub")
  .withServerTimeout(60000)
  .withKeepAliveInterval(30000)
  .build();

Java

Choix	Valeur par défaut	Descriptif
getServerTimeout / setServerTimeout	30 secondes (30 000 millisecondes)	Délai d’attente de l’activité du serveur. Si le serveur n’a pas envoyé de message dans cet intervalle, le client considère le serveur déconnecté et déclenche l’événement onClose . Cette valeur doit être suffisamment grande pour qu’un message ping soit envoyé à partir du serveur et reçu par le client dans l’intervalle de délai d’expiration. La valeur recommandée doit être au moins deux fois la valeur du KeepAliveInterval serveur afin de permettre aux pings de parvenir.
withHandshakeResponseTimeout	15 secondes	Délai d'attente dépassé pour la négociation initiale du serveur. Si le serveur n’envoie pas de réponse de négociation dans ce délai, le client annule la négociation et déclenche l’événement onClose. Il s’agit d’un paramètre avancé qui ne doit être modifié que si des erreurs de délai d’attente de l'initialisation de la connexion se produisent en raison d’une latence grave du réseau. Pour plus de détails sur le processus de Handshake, consultez la spécification du SignalR protocole Hub.
getKeepAliveInterval / setKeepAliveInterval	15 secondes (15 000 millisecondes)	Détermine l’intervalle auquel le client envoie des messages ping. L’envoi d’un message du client réinitialise le minuteur au début de l’intervalle. Si le client n’a pas envoyé de message dans le délai défini sur le ClientTimeoutInterval serveur, le serveur considère le client comme déconnecté.

Configurer la reconnexion avec état

La reconnexion avec état de SignalR réduit le temps d'indisponibilité perçu par les clients en cas de déconnexion temporaire de leur connexion réseau, par exemple lors d'un changement de connexion réseau ou d'une courte perte d'accès.

Pour ce faire, la reconnexion avec état procède comme suit :

• Mise en mémoire tampon temporaire des données sur le serveur et le client.
• Accusant réception des messages reçus (procédure « ACK-ing ») par le serveur et le client.
• Reconnaissance du moment où une connexion est établie et de la réémission des messages qui ont pu être envoyés pendant l'interruption de la connexion.

La reconnexion avec état est disponible à partir de .NET 8 ou version ultérieure.

Activez la reconnexion avec état au niveau du point de terminaison du hub de serveur et au niveau du client :

• Mettez à jour la configuration du point de terminaison du hub de serveur pour activer l’option AllowStatefulReconnects :

  app.MapHub<MyHub>("/hubName", options =>
  {
      options.AllowStatefulReconnects = true;
  });
  

  Si vous le souhaitez, la taille maximale de la mémoire tampon en octets autorisée par le serveur peut être définie globalement ou pour un hub spécifique avec l’option StatefulReconnectBufferSize :

  L’option StatefulReconnectBufferSize définie globalement :

  builder.AddSignalR(o => o.StatefulReconnectBufferSize = 1000);
  

  Option StatefulReconnectBufferSize définie pour un hub spécifique :

  builder.AddSignalR().AddHubOptions<MyHub>(o => o.StatefulReconnectBufferSize = 1000);
  

  L’option StatefulReconnectBufferSize est facultative avec une valeur par défaut de 100 000 octets.

• Mettez à jour le code client JavaScript ou TypeScript pour activer l’option withStatefulReconnect :

  const builder = new signalR.HubConnectionBuilder()
    .withUrl("/hubname")
    .withStatefulReconnect({ bufferSize: 1000 });  // Optional, defaults to 100,000
  const connection = builder.build();
  

  L’option bufferSize est facultative avec une valeur par défaut de 100 000 octets.

• Mettez à jour le code client .NET pour activer l’option WithStatefulReconnect :

    var builder = new HubConnectionBuilder()
        .WithUrl("<hub url>")
        .WithStatefulReconnect();
    builder.Services.Configure<HubConnectionOptions>(o => o.StatefulReconnectBufferSize = 1000);
    var hubConnection = builder.Build();
  

  L’option StatefulReconnectBufferSize est facultative avec une valeur par défaut de 100 000 octets.

Configurer des options supplémentaires

Des options supplémentaires peuvent être configurées dans la méthode WithUrl (withUrl en JavaScript) sur HubConnectionBuilder ou dans les différentes API de configuration sur le client Java HttpHubConnectionBuilder.

.FILET

Option .NET	Valeur par défaut	Descriptif
AccessTokenProvider	null	Fonction retournant une chaîne fournie en tant que jeton d’authentification du porteur dans les requêtes HTTP.
SkipNegotiation	false	Définissez ceci sur true pour ignorer l’étape de négociation. Uniquement pris en charge lorsque le transport WebSockets est le seul transport activé. Ce paramètre ne peut pas être activé lors de l’utilisation du service Azure SignalR .
ClientCertificates	Vide	Collection de certificats TLS à envoyer aux demandes d’authentification.
Cookies	Vide	Collection de cookies HTTP à envoyer avec chaque requête HTTP.
Credentials	Vide	Informations d’identification à envoyer avec chaque requête HTTP.
CloseTimeout	5 secondes	WebSockets uniquement. Durée maximale d’attente du client après la fermeture du serveur pour accuser réception de la demande de fermeture. Si le serveur ne reconnaît pas la fermeture dans ce délai, le client se déconnecte.
Headers	Vide	Tableau des en-têtes HTTP supplémentaires à envoyer avec chaque requête HTTP.
HttpMessageHandlerFactory	null	Délégué pouvant être utilisé pour configurer ou remplacer le HttpMessageHandler, utilisé pour envoyer des requêtes HTTP. Non utilisé pour les connexions WebSocket. Ce délégué doit retourner une valeur non null et reçoit la valeur par défaut en tant que paramètre. Modifiez les paramètres sur cette valeur par défaut et retournez-la ou retournez une nouvelle HttpMessageHandler instance. Lorsque vous remplacez le gestionnaire, veillez à copier les paramètres que vous souhaitez conserver du gestionnaire fourni, sinon, les options configurées (telles que cookies et en-têtes) ne s’appliquent pas au nouveau gestionnaire.
Proxy	null	Proxy HTTP à utiliser lors de l’envoi de requêtes HTTP.
UseDefaultCredentials	false	Définissez cette valeur booléenne pour envoyer les informations d’identification par défaut pour les requêtes HTTP et WebSockets. Cela permet l’utilisation de l’authentification Windows.
WebSocketConfiguration	null	Délégué qui peut être utilisé pour configurer des options WebSocket supplémentaires. Reçoit une instance de ClientWebSocketOptions ce qui peut être utilisée pour configurer les options.
ApplicationMaxBufferSize	1 Mo	Nombre maximal d’octets reçus du serveur que le client met en mémoire tampon avant d’appliquer la contre-pression. L’augmentation de cette valeur permet au client de recevoir des messages plus volumineux plus rapidement sans appliquer de rétropression, mais peut augmenter la consommation de mémoire.
TransportMaxBufferSize	1 Mo	Nombre maximal d’octets envoyés par l’application utilisateur que le client met en mémoire tampon avant d’observer la rétropression. L’augmentation de cette valeur permet au client de mettre en mémoire tampon les messages plus volumineux plus rapidement sans attendre la rétropression, mais peut augmenter la consommation de mémoire.

JavaScript

Option JavaScript	Valeur par défaut	Descriptif
accessTokenFactory	null	Fonction retournant une chaîne fournie en tant que jeton d’authentification du porteur dans les requêtes HTTP.
transport	null	Valeur HttpTransportType spécifiant le transport à utiliser pour la connexion.
headers	null	Dictionnaire d’en-têtes envoyés avec chaque requête HTTP. L’envoi d’en-têtes dans le navigateur ne fonctionne pas pour les WebSockets ou le ServerSentEvents flux.
logMessageContent	null	Réglez sur true afin de consigner les octets/caractères des messages envoyés et reçus par le client.
skipNegotiation	false	Définissez ceci sur true pour ignorer l’étape de négociation. Uniquement pris en charge lorsque le transport WebSockets est le seul transport activé. Ce paramètre ne peut pas être activé lors de l’utilisation du service Azure SignalR .
withCredentials	true	Spécifie si les informations d’identification seront envoyées avec la requête CORS. Azure App Service utilise des cookies pour les sessions sticky et a besoin que cette option soit activée pour fonctionner correctement. Pour plus d’informations sur CORS avec SignalR, consultez considérations relatives à la sécurité dans ASP.NET Core SignalR.
timeout	100,000	Délai d’expiration en millisecondes à appliquer aux requêtes HTTP. Cela ne s’applique pas aux requêtes d’interrogation longue, à EventSource ou aux WebSockets.

Java

Option Java	Valeur par défaut	Descriptif
withAccessTokenProvider	null	Fonction retournant une chaîne fournie en tant que jeton d’authentification du porteur dans les requêtes HTTP.
shouldSkipNegotiate	false	Définissez ceci sur true pour ignorer l’étape de négociation. Uniquement pris en charge lorsque le transport WebSockets est le seul transport activé. Ce paramètre ne peut pas être activé lors de l’utilisation du service Azure SignalR .
withHeader withHeaders	Vide	Tableau des en-têtes HTTP supplémentaires à envoyer avec chaque requête HTTP.

Dans le client .NET, ces options peuvent être modifiées par le délégué d’options fourni à WithUrl:

var connection = new HubConnectionBuilder()
    .WithUrl("https://example.com/chathub", options => {
        options.Headers["Foo"] = "Bar";
        options.SkipNegotiation = true;
        options.Transports = HttpTransportType.WebSockets;
        options.Cookies.Add(new Cookie(/* ... */);
        options.ClientCertificates.Add(/* ... */);
    })
    .Build();

Dans le client JavaScript, ces options peuvent être fournies dans un objet JavaScript fourni pour withUrl:

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub", {
        // "Foo: Bar" will not be sent with WebSockets or Server-Sent Events requests
        headers: { "Foo": "Bar" },
        transport: signalR.HttpTransportType.LongPolling 
    })
    .build();

Dans le client Java, ces options peuvent être configurées avec les méthodes sur le HttpHubConnectionBuilder renvoyées par le HubConnectionBuilder.create("HUB URL")

HubConnection hubConnection = HubConnectionBuilder.create("https://example.com/chathub")
        .withHeader("Foo", "Bar")
        .shouldSkipNegotiate(true)
        .withHandshakeResponseTimeout(30*1000)
        .build();

Ressources supplémentaires

• Bien démarrer avec ASP.NET Core SignalR
• Utiliser des hubs dans ASP.NET Core SignalR
• ASP.NET Core SignalR Client JavaScript
• ASP.NET Core SignalR .NET Client
• Utiliser le protocole MessagePack Hub dans SignalR ASP.NET Core
• Plateformes ASP.NET CoreSignalR prises en charge