configurazione di ASP.NET Core SignalR

Questo articolo illustra ASP.NET configurazione core SignalR .

Per BlazorSignalR indicazioni, che aggiungono o sostituisce le linee guida contenute in questo articolo, vedere ASP.NET Linee guida di baseBlazorSignalR.

Opzioni di serializzazione JSON/MessagePack

ASP.NET Core SignalR supporta due protocolli per la codifica dei messaggi: JSON e MessagePack. Ogni protocollo include opzioni di configurazione della serializzazione.

La serializzazione JSON può essere configurata nel server usando il metodo di AddJsonProtocol estensione. AddJsonProtocol può essere aggiunto dopo AddSignalR in Startup.ConfigureServices. Il AddJsonProtocol metodo accetta un delegato che riceve un options oggetto . La PayloadSerializerOptions proprietà su tale oggetto è un System.Text.Json JsonSerializerOptions oggetto che può essere utilizzato per configurare la serializzazione di argomenti e valori restituiti. Per altre informazioni, vedere la documentazione di System.Text.Json.

Ad esempio, per configurare il serializzatore in modo da non modificare la combinazione di maiuscole e minuscole predefinite, usare il codice seguente in Program.cs:

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

Nel client .NET lo stesso AddJsonProtocol metodo di estensione esiste in HubConnectionBuilder. Lo Microsoft.Extensions.DependencyInjection spazio dei nomi deve essere importato per risolvere il metodo di estensione:

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

Nota

Al momento non è possibile configurare la serializzazione JSON nel client JavaScript.

Passare a Newtonsoft.Json

Se sono necessarie funzionalità di Newtonsoft.Json che non sono supportate in System.Text.Json, vedere Passare a Newtonsoft.Json.

Opzioni di serializzazione di MessagePack

La serializzazione di MessagePack può essere configurata fornendo un delegato alla AddMessagePackProtocol chiamata. Per altri dettagli, vedere MessagePack in SignalR .

Nota

Al momento non è possibile configurare la serializzazione messagePack nel client JavaScript.

Configurare le opzioni del server

La tabella seguente descrive le opzioni per la configurazione degli SignalR hub:

Opzione	Valore predefinito	Descrizione
ClientTimeoutInterval	30 secondi	Il server considera il client disconnesso se non ha ricevuto un messaggio (incluso keep-alive) in questo intervallo. La disconnessione del client potrebbe richiedere più tempo rispetto a questo intervallo di timeout a causa della modalità di implementazione. Il valore consigliato è il doppio del KeepAliveInterval valore.
HandshakeTimeout	15 secondi	Se il client non invia un messaggio di handshake iniziale entro questo intervallo di tempo, la connessione viene chiusa. Si tratta di un'impostazione avanzata che deve essere modificata solo se si verificano errori di timeout dell'handshake a causa di una latenza di rete grave. Per altri dettagli sul processo di handshake, vedere La specifica del SignalR protocollo hub.
KeepAliveInterval	15 secondi	Se il server non ha inviato un messaggio entro questo intervallo, viene inviato automaticamente un messaggio ping per mantenere aperta la connessione. Quando si modifica , modificare KeepAliveIntervall'impostazione ServerTimeout o serverTimeoutInMilliseconds nel client. Il valore consigliato ServerTimeout o serverTimeoutInMilliseconds è doppio del KeepAliveInterval valore.
SupportedProtocols	Tutti i protocolli installati	Protocolli supportati da questo hub. Per impostazione predefinita, tutti i protocolli registrati nel server sono consentiti. I protocolli possono essere rimossi da questo elenco per disabilitare protocolli specifici per singoli hub.
EnableDetailedErrors	false	Se true, i messaggi di eccezione dettagliati vengono restituiti ai client quando viene generata un'eccezione in un metodo hub. Il valore predefinito è false dovuto al fatto che questi messaggi di eccezione possono contenere informazioni riservate.
StreamBufferCapacity	10	Numero massimo di elementi che possono essere memorizzati nel buffer per i flussi di caricamento client. Se viene raggiunto questo limite, l'elaborazione delle chiamate viene bloccata fino a quando il server non elabora gli elementi del flusso.
MaximumReceiveMessageSize	32 KB	Dimensioni massime di un singolo messaggio hub in ingresso. L'aumento del valore potrebbe aumentare il rischio di attacchi Denial of Service (DoS).
MaximumParallelInvocationsPerClient	1	Numero massimo di metodi hub che ogni client può chiamare in parallelo prima di accodare.
DisableImplicitFromServicesParameters	false	Gli argomenti del metodo hub vengono risolti dall'inserimento delle dipendenze, se possibile.

Le opzioni possono essere configurate per tutti gli hub fornendo un delegato di opzioni alla AddSignalR chiamata in Program.cs.

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

Le opzioni per un singolo hub eseguono l'override delle opzioni globali disponibili in AddSignalR e possono essere configurate usando AddHubOptions:

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

Opzioni di configurazione HTTP avanzate

Usare HttpConnectionDispatcherOptions per configurare le impostazioni avanzate relative ai trasporti e alla gestione del buffer di memoria. Queste opzioni vengono configurate passando un delegato a MapHub in 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();

La tabella seguente descrive le opzioni per la configurazione delle opzioni HTTP avanzate di ASP.NET Core SignalR:

Opzione	Valore predefinito	Descrizione
ApplicationMaxBufferSize	64 kB	Numero massimo di byte ricevuti dal client che il server memorizza nel buffer prima di applicare la backpressure. L'aumento di questo valore consente al server di ricevere messaggi più grandi più velocemente senza applicare la pressione posteriore, ma può aumentare il consumo di memoria.
TransportMaxBufferSize	64 kB	Numero massimo di byte inviati dall'app che il server memorizza nel buffer prima di osservare la backpressure. L'aumento di questo valore consente al server di memorizzare più velocemente i messaggi più grandi senza attendere la backpressure, ma può aumentare il consumo di memoria.
AuthorizationData	Dati raccolti automaticamente dagli Authorize attributi applicati alla classe Hub.	Elenco di IAuthorizeData oggetti usati per determinare se un client è autorizzato a connettersi all'hub.
Transports	Tutti i trasporti sono abilitati.	Flag di bit enumerazione di HttpTransportType valori che possono limitare i trasporti che un client può usare per connettersi.
LongPolling	Vedere di seguito.	Opzioni aggiuntive specifiche per il trasporto di polling lungo.
WebSockets	Vedere di seguito.	Opzioni aggiuntive specifiche del trasporto WebSocket.
MinimumProtocolVersion	0	Specificare la versione minima del protocollo negotiate. Viene usato per limitare i client alle versioni più recenti.
CloseOnAuthenticationExpiration	false	Impostare questa opzione per abilitare il rilevamento della scadenza dell'autenticazione, che chiuderà le connessioni alla scadenza di un token.

Il trasporto Di polling lungo include opzioni aggiuntive che possono essere configurate usando la LongPolling proprietà :

Opzione	Valore predefinito	Descrizione
PollTimeout	90 secondi	Tempo massimo di attesa del server per l'invio di un messaggio al client prima di terminare una singola richiesta di polling. La riduzione di questo valore fa sì che il client esegua più frequentemente nuove richieste di polling.

Il trasporto WebSocket include opzioni aggiuntive che possono essere configurate usando la WebSockets proprietà :

Opzione	Valore predefinito	Descrizione
CloseTimeout	5 secondi	Dopo la chiusura del server, se il client non riesce a chiudersi entro questo intervallo di tempo, la connessione viene terminata.
SubProtocolSelector	null	Delegato che può essere usato per impostare l'intestazione Sec-WebSocket-Protocol su un valore personalizzato. Il delegato riceve i valori richiesti dal client come input e dovrebbe restituire il valore desiderato.

Configurare le opzioni client

Le opzioni client possono essere configurate nel HubConnectionBuilder tipo (disponibile nei client .NET e JavaScript). È disponibile anche nel client Java, ma la HttpHubConnectionBuilder sottoclasse contiene le opzioni di configurazione del generatore, oltre a quella stessa HubConnection .

Configurare la registrazione

La registrazione viene configurata nel client .NET usando il ConfigureLogging metodo . I provider e i filtri di registrazione possono essere registrati nello stesso modo in cui si trovano nel server. Per altre informazioni, vedere la documentazione relativa alla registrazione in ASP.NET Core .

Nota

Per registrare i provider di registrazione, è necessario installare i pacchetti necessari. Per un elenco completo, vedere la sezione Provider di registrazione predefiniti della documentazione.

Ad esempio, per abilitare la registrazione della console, installare il Microsoft.Extensions.Logging.Console pacchetto NuGet. Chiamare il metodo di AddConsole estensione:

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

Nel client JavaScript esiste un metodo simile configureLogging . Specificare un LogLevel valore che indica il livello minimo di messaggi di log da produrre. I log vengono scritti nella finestra della console del browser.

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

Anziché un LogLevel valore, è anche possibile specificare un string valore che rappresenta un nome a livello di log. Ciò è utile quando si configura l'accesso SignalR negli ambienti in cui non si ha accesso alle LogLevel costanti.

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

Nella tabella seguente sono elencati i livelli di log disponibili. Valore specificato per configureLogging impostare il livello minimo di log che verrà registrato. I messaggi registrati a questo livello o i livelli elencati dopo la registrazione nella tabella verranno registrati.

String	LogLevel
trace	LogLevel.Trace
debug	LogLevel.Debug
infoo information	LogLevel.Information
warno warning	LogLevel.Warning
error	LogLevel.Error
critical	LogLevel.Critical
none	LogLevel.None

Nota

Per disabilitare completamente la registrazione, specificare signalR.LogLevel.None nel configureLogging metodo .

Per altre informazioni sulla registrazione, vedere la SignalR documentazione di Diagnostica.

Il SignalR client Java usa la libreria SLF4J per la registrazione. Si tratta di un'API di registrazione di alto livello che consente agli utenti della libreria di scegliere la propria implementazione di registrazione specifica inserendo una dipendenza di registrazione specifica. Il frammento di codice seguente illustra come usare java.util.logging con il SignalR client Java.

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

Se non si configura la registrazione nelle dipendenze, SLF4J carica un logger di nessuna operazione predefinita con il messaggio di avviso seguente:

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.

Può essere tranquillamente ignorato.

Configurare i trasporti consentiti

I trasporti usati da SignalR possono essere configurati nella WithUrl chiamata (withUrl in JavaScript). È possibile utilizzare un OR bit per bit dei valori di HttpTransportType per limitare il client all'uso solo dei trasporti specificati. Tutti i trasporti sono abilitati per impostazione predefinita.

Ad esempio, per disabilitare il trasporto Eventi inviati dal server, ma consentire le connessioni WebSocket e Long Polling:

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

Nel client JavaScript i trasporti vengono configurati impostando il campo sull'oggetto transport opzioni fornito su withUrl:

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

In questa versione dei WebSocket client Java è l'unico trasporto disponibile.

Nel client Java il trasporto viene selezionato con il withTransport metodo in HttpHubConnectionBuilder. Per impostazione predefinita, il client Java usa il trasporto WebSocket.

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

Nota

Il SignalR client Java non supporta ancora il fallback del trasporto.

Configurare l'autenticazione con connessione

Per fornire dati di autenticazione insieme SignalR alle richieste, usare l'opzione AccessTokenProvider (accessTokenFactory in JavaScript) per specificare una funzione che restituisce il token di accesso desiderato. Nel client .NET questo token di accesso viene passato come token HTTP "Bearer Authentication" (Uso dell'intestazione Authorization con un tipo di Bearer). Nel client JavaScript il token di accesso viene usato come token di connessione, ad eccezione di alcuni casi in cui le API del browser limitano la possibilità di applicare intestazioni (in particolare, nelle richieste Di eventi inviati dal server e WebSocket). In questi casi, il token di accesso viene fornito come valore access_tokendella stringa di query .

Nel client .NET è possibile specificare l'opzione AccessTokenProvider usando il delegato delle opzioni in WithUrl:

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

Nel client JavaScript il token di accesso viene configurato impostando il campo sull'oggetto accessTokenFactory options in 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();

SignalR Nel client Java è possibile configurare un token di connessione da usare per l'autenticazione fornendo una factory di token di accesso a HttpHubConnectionBuilder. Usare withAccessTokenFactory per fornire una stringa singola>< RxJava. Con una chiamata a Single.defer, è possibile scrivere la logica per produrre token di accesso per il client.

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

Configurare le opzioni di timeout e keep-alive

Opzioni aggiuntive per la configurazione del timeout e del comportamento keep-alive:

.NET

Opzione	Default value	Descrizione
WithServerTimeout	30 secondi (30.000 millisecondi)	Timeout per l'attività del server e impostato direttamente su HubConnectionBuilder. Se il server non ha inviato un messaggio in questo intervallo, il client considera il server disconnesso e attiva l'evento Closed (onclose in JavaScript). Questo valore deve essere sufficientemente grande per l'invio di un messaggio ping dal server e ricevuto dal client entro l'intervallo di timeout. Il valore consigliato è un numero pari almeno al doppio del valore dell'intervallo keep-alive (WithKeepAliveInterval) del server per consentire l'arrivo dei ping.
HandshakeTimeout	15 secondi	Timeout per l'handshake server iniziale ed è disponibile nell'oggetto HubConnection stesso. Se il server non invia una risposta handshake in questo intervallo, il client annulla l'handshake e attiva l'evento Closed (onclose in JavaScript). Si tratta di un'impostazione avanzata che deve essere modificata solo se si verificano errori di timeout dell'handshake a causa di una latenza di rete grave. Per altri dettagli sul processo di handshake, vedere La specifica del SignalR protocollo hub.
WithKeepAliveInterval	15 secondi	Determina l'intervallo in cui il client invia messaggi ping e viene impostato direttamente su HubConnectionBuilder. Questa impostazione consente al server di rilevare disconnessioni disconnesse, ad esempio quando un client scollega il computer dalla rete. L'invio di qualsiasi messaggio dal client reimposta il timer all'inizio dell'intervallo. Se il client non ha inviato un messaggio nel ClientTimeoutInterval set nel server, il server considera il client disconnesso.

Nel client .NET i valori di timeout vengono specificati come TimeSpan valori.

L'esempio seguente mostra i valori che corrispondono al doppio dei valori predefiniti:

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

Opzione	Default value	Descrizione
withServerTimeout	30 secondi (30.000 millisecondi)	Timeout per l'attività del server e impostato direttamente su HubConnectionBuilder. Se il server non ha inviato un messaggio in questo intervallo, il client considera il server disconnesso e attiva l'evento onclose . Questa impostazione consente al server di rilevare disconnessioni disconnesse, ad esempio quando un client scollega il computer dalla rete. Questo valore deve essere sufficientemente grande per l'invio di un messaggio ping dal server e ricevuto dal client entro l'intervallo di timeout. Il valore consigliato è un numero pari almeno al doppio del valore dell'intervallo keep-alive (withKeepAliveInterval) del server per consentire l'arrivo dei ping.
withKeepAliveInterval	15 secondi (15.000 millisecondi)	Determina l'intervallo in cui il client invia messaggi ping e viene impostato direttamente su HubConnectionBuilder. Questa impostazione consente al server di rilevare disconnessioni disconnesse, ad esempio quando un client scollega il computer dalla rete. L'invio di qualsiasi messaggio dal client reimposta il timer all'inizio dell'intervallo. Se il client non ha inviato un messaggio nel ClientTimeoutInterval set nel server, il server considera il client disconnesso. Il ping viene eseguito al massimo con la frequenza con cui viene eseguito il ping del server. Se il server esegue il ping ogni cinque secondi, assegnando un valore inferiore a 5000 (5 secondi) esegue il ping ogni cinque secondi. Il valore predefinito è 15 secondi. L'intervallo keep-alive deve essere minore o uguale alla metà del valore assegnato al timeout del server (withServerTimeout).

L'esempio seguente mostra i valori che corrispondono al doppio dei valori predefiniti:

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

Java

Opzione	Default value	Descrizione
getServerTimeout / setServerTimeout	30 secondi (30.000 millisecondi)	Timeout per l'attività del server. Se il server non ha inviato un messaggio in questo intervallo, il client considera il server disconnesso e attiva l'evento onClose . Questo valore deve essere sufficientemente grande per l'invio di un messaggio ping dal server e ricevuto dal client entro l'intervallo di timeout. Il valore consigliato è un numero almeno doppio del valore del KeepAliveInterval server per consentire l'arrivo dei ping.
withHandshakeResponseTimeout	15 secondi	Timeout per l'handshake del server iniziale. Se il server non invia una risposta handshake in questo intervallo, il client annulla l'handshake e attiva l'evento onClose . Si tratta di un'impostazione avanzata che deve essere modificata solo se si verificano errori di timeout dell'handshake a causa di una latenza di rete grave. Per altri dettagli sul processo handshake, vedere La specifica del SignalR protocollo hub.
getKeepAliveInterval / setKeepAliveInterval	15 secondi (15.000 millisecondi)	Determina l'intervallo in cui il client invia messaggi ping. L'invio di qualsiasi messaggio dal client reimposta il timer all'inizio dell'intervallo. Se il client non ha inviato un messaggio nel ClientTimeoutInterval set nel server, il server considera il client disconnesso.

Configurare la riconnessione con stato

SignalR la riconnessione con stato riduce il tempo di inattività percepito dei client che hanno una disconnessione temporanea nella connessione di rete, ad esempio quando si cambiano connessioni di rete o si verifica una breve perdita temporanea nell'accesso.

La riconnessione con stato consente di ottenere questo risultato:

• Memorizzazione temporaneamente nel buffer dei dati nel server e nel client.
• Riconoscimento dei messaggi ricevuti (ACK-ing) sia dal server che dal client.
• Riconoscimento quando una connessione è inattiva e riproduce i messaggi che potrebbero essere stati inviati mentre la connessione era inattiva.

La riconnessione con stato è disponibile in ASP.NET Core 8.0 e versioni successive.

Acconsentire esplicitamente alla riconnessione con stato sia all'endpoint dell'hub server che al client:

• Aggiornare la configurazione dell'endpoint dell'hub server per abilitare l'opzione AllowStatefulReconnects :

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

  Facoltativamente, le dimensioni massime del buffer in byte consentite dal server possono essere impostate a livello globale o per un hub specifico con l'opzione StatefulReconnectBufferSize :

  L'opzione StatefulReconnectBufferSize impostata a livello globale:

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

  L'opzione StatefulReconnectBufferSize impostata per un hub specifico:

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

  L'opzione StatefulReconnectBufferSize è facoltativa con un valore predefinito di 100.000 byte.

• Aggiornare il codice client JavaScript o TypeScript per abilitare l'opzione withStatefulReconnect :

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

  L'opzione bufferSize è facoltativa con un valore predefinito di 100.000 byte.

• Aggiornare il codice client .NET per abilitare l'opzione WithStatefulReconnect :

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

  L'opzione StatefulReconnectBufferSize è facoltativa con un valore predefinito di 100.000 byte.

Configurazione di opzioni aggiuntive

È possibile configurare opzioni aggiuntive nel WithUrl metodo (withUrl in JavaScript) in HubConnectionBuilder o nelle varie API HttpHubConnectionBuilder di configurazione nel client Java:

.NET

Opzione .NET	Default value	Descrizione
AccessTokenProvider	null	Funzione che restituisce una stringa fornita come token di autenticazione bearer nelle richieste HTTP.
SkipNegotiation	false	Impostare su per true ignorare il passaggio di negoziazione. Supportato solo quando il trasporto WebSocket è l'unico trasporto abilitato. Questa impostazione non può essere abilitata quando si usa il servizio di Azure SignalR .
ClientCertificates	Vuoto	Raccolta di certificati TLS da inviare per autenticare le richieste.
Cookies	Vuoto	Raccolta di cookie HTTP da inviare con ogni richiesta HTTP.
Credentials	Vuoto	Credenziali da inviare con ogni richiesta HTTP.
CloseTimeout	5 secondi	Solo WebSocket. Periodo massimo di attesa del client dopo la chiusura del server per confermare la richiesta di chiusura. Se il server non riconosce la chiusura entro questo periodo, il client si disconnette.
Headers	Vuoto	Mappa di intestazioni HTTP aggiuntive da inviare con ogni richiesta HTTP.
HttpMessageHandlerFactory	null	Delegato che può essere usato per configurare o sostituire l'oggetto HttpMessageHandler usato per inviare richieste HTTP. Non usato per le connessioni WebSocket. Questo delegato deve restituire un valore non Null e riceve il valore predefinito come parametro. Modificare le impostazioni sul valore predefinito e restituirlo oppure restituire una nuova HttpMessageHandler istanza. Quando si sostituisce il gestore assicurarsi di copiare le impostazioni che si desidera mantenere dal gestore fornito, in caso contrario, le opzioni configurate (ad esempio Cookie e Intestazioni) non verranno applicate al nuovo gestore.
Proxy	null	Proxy HTTP da usare per l'invio di richieste HTTP.
UseDefaultCredentials	false	Impostare questo valore booleano per inviare le credenziali predefinite per le richieste HTTP e WebSocket. In questo modo viene abilitato l'uso di autenticazione di Windows.
WebSocketConfiguration	null	Delegato che può essere usato per configurare opzioni WebSocket aggiuntive. Riceve un'istanza di ClientWebSocketOptions che può essere usata per configurare le opzioni.
ApplicationMaxBufferSize	1 MB	Numero massimo di byte ricevuti dal server che il client memorizza nel buffer prima di applicare la backpressure. L'aumento di questo valore consente al client di ricevere più velocemente messaggi di dimensioni maggiori senza applicare la backpressure, ma può aumentare il consumo di memoria.
TransportMaxBufferSize	1 MB	Numero massimo di byte inviati dall'applicazione utente memorizzati nel buffer del client prima di osservare la backpressure. L'aumento di questo valore consente al client di memorizzare più velocemente i messaggi più grandi senza attendere la backpressure, ma può aumentare il consumo di memoria.

JavaScript

Opzione JavaScript	Valore predefinito	Descrizione
accessTokenFactory	null	Funzione che restituisce una stringa fornita come token di autenticazione bearer nelle richieste HTTP.
transport	null	Valore HttpTransportType che specifica il trasporto da utilizzare per la connessione.
headers	null	Dizionario di intestazioni inviate con ogni richiesta HTTP. L'invio di intestazioni nel browser non funziona per WebSocket o per il ServerSentEvents flusso.
logMessageContent	null	Impostare su per true registrare i byte/caratteri dei messaggi inviati e ricevuti dal client.
skipNegotiation	false	Impostare su per true ignorare il passaggio di negoziazione. Supportato solo quando il trasporto WebSocket è l'unico trasporto abilitato. Questa impostazione non può essere abilitata quando si usa il servizio di Azure SignalR .
withCredentials	true	Specifica se le credenziali verranno inviate con la richiesta CORS. app Azure Servizio usa i cookie per le sessioni permanenti e richiede che questa opzione funzioni correttamente. Per altre informazioni su CORS con SignalR, vedere Considerazioni sulla sicurezza in ASP.NET Core SignalR.
timeout	100,000	Timeout in millisecondi da applicare alle richieste HTTP. Ciò non si applica alle richieste di polling long polling, a EventSource o a WebSocket.

Java

Opzione Java	Valore predefinito	Descrizione
withAccessTokenProvider	null	Funzione che restituisce una stringa fornita come token di autenticazione bearer nelle richieste HTTP.
shouldSkipNegotiate	false	Impostare su per true ignorare il passaggio di negoziazione. Supportato solo quando il trasporto WebSocket è l'unico trasporto abilitato. Questa impostazione non può essere abilitata quando si usa il servizio di Azure SignalR .
withHeader withHeaders	Vuoto	Mappa di intestazioni HTTP aggiuntive da inviare con ogni richiesta HTTP.

Nel client .NET queste opzioni possono essere modificate dal delegato di opzioni fornito a 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();

Nel client JavaScript queste opzioni possono essere fornite in un oggetto JavaScript fornito a 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();

Nel client Java queste opzioni possono essere configurate con i metodi nell'oggetto HttpHubConnectionBuilder restituito da HubConnectionBuilder.create("HUB URL")

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

Risorse aggiuntive

• Introduzione a ASP.NET Core SignalR
• Usare hub in ASP.NET Core SignalR
• client JavaScript di ASP.NET Core SignalR
• client .NET di ASP.NET Core SignalR
• Usare il protocollo hub MessagePack in SignalR per ASP.NET Core
• piattaforme supportate da ASP.NET Core SignalR