configurazione di ASP.NET Core SignalR

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

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 .

Configurare le opzioni del server

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

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:

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

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

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 .

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.

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

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:

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

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

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:

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

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 AddJsonProtocol metodo di estensione, che può essere aggiunto dopo AddSignalR nel Startup.ConfigureServices metodo . Il AddJsonProtocol metodo accetta un delegato che riceve un options oggetto . La PayloadSerializerSettings proprietà su tale oggetto è un oggetto Json.NET JsonSerializerSettings che può essere utilizzato per configurare la serializzazione di argomenti e valori restituiti. Per altre informazioni, vedere la documentazione Json.NET.

Ad esempio, per configurare il serializzatore in modo da usare i nomi delle proprietà "PascalCase", anziché i nomi dei case camel predefiniti, usare il codice seguente in Startup.ConfigureServices:

services.AddSignalR()
    .AddJsonProtocol(options => {
        options.PayloadSerializerSettings.ContractResolver =
            new DefaultContractResolver();
    });

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.PayloadSerializerSettings.ContractResolver =
            new DefaultContractResolver();
    })
    .Build();

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 .

Configurare le opzioni del server

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

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

public void ConfigureServices(IServiceCollection services)
{
    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:

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 Startup.Configure.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseSignalR((configure) =>
    {
        var desiredTransports =
            HttpTransportType.WebSockets |
            HttpTransportType.LongPolling;

        configure.MapHub<ChatHub>("/chathub", (options) =>
        {
            options.Transports = desiredTransports;
        });
    });
}

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

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

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

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 .

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

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

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 sono disponibili nell'oggetto HubConnection stesso:

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:

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.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", {
        skipNegotiation: true,
        transport: signalR.HttpTransportType.WebSockets
    })
    .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

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 AddJsonProtocol metodo di estensione, che può essere aggiunto dopo AddSignalR nel Startup.ConfigureServices metodo . Il AddJsonProtocol metodo accetta un delegato che riceve un options oggetto . La PayloadSerializerSettings proprietà su tale oggetto è un oggetto Json.NET JsonSerializerSettings che può essere utilizzato per configurare la serializzazione di argomenti e valori restituiti. Per altre informazioni, vedere la documentazione Json.NET.

Ad esempio, per configurare il serializzatore in modo da usare i nomi delle proprietà "PascalCase", anziché i nomi dei case camel predefiniti, usare il codice seguente in Startup.ConfigureServices:

services.AddSignalR()
    .AddJsonProtocol(options => {
        options.PayloadSerializerSettings.ContractResolver =
            new DefaultContractResolver();
    });

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.PayloadSerializerSettings.ContractResolver =
            new DefaultContractResolver();
    })
    .Build();

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 .

Configurare le opzioni del server

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

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

public void ConfigureServices(IServiceCollection services)
{
    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:

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 Startup.Configure.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseSignalR((configure) =>
    {
        var desiredTransports =
            HttpTransportType.WebSockets |
            HttpTransportType.LongPolling;

        configure.MapHub<ChatHub>("/chathub", (options) =>
        {
            options.Transports = desiredTransports;
        });
    });
}

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

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

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

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 .

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

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.

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 sono disponibili nell'oggetto HubConnection stesso:

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:

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.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", {
        skipNegotiation: true,
        transport: signalR.HttpTransportType.WebSockets
    })
    .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

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 Startup.ConfigureServices:

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

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 .

Configurare le opzioni del server

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

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

public void ConfigureServices(IServiceCollection services)
{
    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:

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 Startup.Configure.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseRouting();

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

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

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

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

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 .

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.

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

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 sono disponibili nell'oggetto HubConnection stesso:

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:

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.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", {
        skipNegotiation: true,
        transport: signalR.HttpTransportType.WebSockets
    })
    .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

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 Startup.ConfigureServices:

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

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 .

Configurare le opzioni del server

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

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

public void ConfigureServices(IServiceCollection services)
{
    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:

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 Startup.Configure.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseRouting();

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

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

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

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

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 .

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.

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

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 sono disponibili nell'oggetto HubConnection stesso:

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:

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.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", {
        skipNegotiation: true,
        transport: signalR.HttpTransportType.WebSockets
    })
    .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

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 Startup.ConfigureServices:

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

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 .

Configurare le opzioni del server

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

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

public void ConfigureServices(IServiceCollection services)
{
    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:

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 Startup.Configure.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseRouting();

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

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

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

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

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 .

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.

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

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 sono disponibili nell'oggetto HubConnection stesso:

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:

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

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 Program.cs. 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();

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 .

Configurare le opzioni del server

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

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:

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

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

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 .

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.

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

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 sono disponibili nell'oggetto HubConnection stesso:

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:

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

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

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 .

Configurare le opzioni del server

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

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:

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

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

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 .

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.

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

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 sono disponibili nell'oggetto HubConnection stesso:

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:

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