ASP.NET Core SignalR rozšířeného

Možnosti serializace JSON/MessagePack

ASP.NET Core SignalR podporuje dva protokoly pro kódování zpráv: JSON a MessagePack. Každý protokol má možnosti konfigurace serializace.

Serializaci JSON lze nakonfigurovat na serveru pomocí metody rozšíření AddJsonProtocol . AddJsonProtocollze přidat po Přidání SignalR do Startup.ConfigureServices . AddJsonProtocolMetoda přebírá delegáta, který přijímá options objekt. Vlastnost PayloadSerializerOptions tohoto objektu je System.Text.Json JsonSerializerOptions objekt, který lze použít ke konfiguraci serializace argumentů a vrácených hodnot. Další informace naleznete v dokumentaci System. text. JSON.

Chcete-li například nakonfigurovat serializátor, aby neměnil velká a malá písmena názvů vlastností, nikoli výchozí názvy případů ve stylu CamelCase , použijte následující kód v Startup.ConfigureServices :

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

V klientovi .NET AddJsonProtocol existuje stejná rozšiřující metoda v HubConnectionBuilder. Microsoft.Extensions.DependencyInjectionObor názvů musí být importován, aby bylo možné přeložit metodu rozšíření:

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

Přepnout na Newtonsoft. JSON

Pokud potřebujete funkce nástroje Newtonsoft.Json , které nejsou podporované v systému System.Text.Json , přečtěte si téma Přepnutí na Newtonsoft.Json .

Možnosti serializace MessagePack

Serializaci MessagePack lze nakonfigurovat poskytnutím delegáta volání AddMessagePackProtocol . Další podrobnosti najdete v SignalR tématu MessagePack .

Konfigurovat možnosti serveru

Následující tabulka popisuje možnosti konfigurace SignalR Center:

Možnost	Výchozí hodnota	Description
ClientTimeoutInterval	30 sekund	Server považuje klienta za odpojený, pokud neobdržel v tomto intervalu zprávu (včetně Keep-Alive). Aby bylo možné klienta označit jako odpojený z důvodu jeho implementace, může trvat delší dobu než tento časový limit. Doporučená hodnota je dvojnásobná KeepAliveInterval hodnota.
HandshakeTimeout	15 sekund	Pokud klient v tomto časovém intervalu nepošle počáteční zprávu handshake, připojení se zavře. Toto je pokročilé nastavení, které by mělo být změněno pouze v případě, že dochází k chybám časového limitu handshake kvůli závažné latenci sítě. Další informace o procesu handshake najdete v tématu SignalR specifikace protokolu pro rozbočovače.
KeepAliveInterval	15 sekund	Pokud server do tohoto intervalu neodeslal zprávu, odešle se automaticky zpráva s potvrzením, aby bylo připojení otevřené. Při změně KeepAliveInterval změňte ServerTimeout serverTimeoutInMilliseconds nastavení nebo v klientovi. Doporučená hodnota ServerTimeout nebo serverTimeoutInMilliseconds je dvojnásobná hodnota KeepAliveInterval .
SupportedProtocols	Všechny nainstalované protokoly	Protokoly podporované tímto rozbočovačem Ve výchozím nastavení jsou povoleny všechny protokoly registrované na serveru. Protokoly lze z tohoto seznamu odebrat, chcete-li zakázat konkrétní protokoly pro jednotlivá centra.
EnableDetailedErrors	false	Pokud se true do klientů vrátí podrobné zprávy o výjimce, pokud je vyvolána výjimka v metodě rozbočovače. Výchozí hodnota je, false protože tyto zprávy o výjimce mohou obsahovat citlivé informace.
StreamBufferCapacity	10	Maximální počet položek, které lze uložit do vyrovnávací paměti pro datové proudy pro odeslání klienta. Pokud je dosaženo tohoto limitu, zpracování volání je blokováno, dokud server nezpracovává položky datového proudu.
MaximumReceiveMessageSize	32 KB	Maximální velikost jedné příchozí zprávy centra
MaximumParallelInvocationsPerClient	1	Maximální počet metod centra, které může každý klient volat paralelně před zařazením do fronty.

Možnosti lze nakonfigurovat pro všechna centra tím, že poskytnete možnosti delegáta pro AddSignalR volání v Startup.ConfigureServices .

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR(hubOptions =>
    {
        hubOptions.EnableDetailedErrors = true;
        hubOptions.KeepAliveInterval = TimeSpan.FromMinutes(1);
    });
}

Možnosti pro jeden rozbočovač přepíší globální možnosti poskytované v AddSignalR a můžou být nakonfigurované pomocí AddHubOptions :

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

Rozšířené možnosti konfigurace protokolu HTTP

Slouží HttpConnectionDispatcherOptions ke konfiguraci upřesňujících nastavení souvisejících s přenosy a správou vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do <T> MapHub v 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;
        });
    });
}

následující tabulka popisuje možnosti konfigurace SignalR rozšířených možností protokolu HTTP v ASP.NET Core:

Možnost	Výchozí hodnota	Description
ApplicationMaxBufferSize	64 kB	Maximální počet bajtů přijatých od klienta, které jsou ukládány do vyrovnávací paměti serveru před použitím protitlaku. Zvýšením této hodnoty umožníte, aby server přijímal větší zprávy rychleji bez použití zatížení, ale může zvýšit spotřebu paměti.
TransportMaxBufferSize	64 kB	Maximální počet bajtů odeslaných aplikací, které jsou vyrovnávací paměti serveru před pozorováním protitlaku. Zvýšení této hodnoty umožňuje serveru rychleji ukládat větší zprávy bez nutnosti očekávat zatížení, ale může zvýšit spotřebu paměti.
AuthorizationData	Data se automaticky shromažďují z Authorize atributů použitých pro třídu centra.	Seznam objektů IAuthorizeData , pomocí kterých se určí, jestli je klient autorizovaný pro připojení k centru
Transports	Všechny přenosy jsou povolené.	Bitové příznaky výčtu HttpTransportType hodnot, které mohou omezit přenos, který může klient použít pro připojení.
LongPolling	Viz níže.	Další možnosti specifické pro přenos dlouhého cyklického dotazování.
WebSockets	Viz níže.	Další možnosti specifické pro přenos pomocí protokolu WebSockets
MinimumProtocolVersion	0	Zadejte minimální verzi protokolu Negotiate. Slouží k omezení klientů na novější verze.
CloseOnAuthenticationExpiration	false (nepravda)	Tuto možnost nastavte, pokud chcete povolit sledování vypršení platnosti ověřování, které ukončí připojení, když vyprší platnost tokenu.

Přenos dlouhého cyklického dotazování má další možnosti, které je možné konfigurovat pomocí LongPolling vlastnosti:

Možnost	Výchozí hodnota	Description
PollTimeout	90 sekund	Maximální doba, po kterou server čeká na odeslání zprávy klientovi před ukončením jedné žádosti o cyklické dotazování. Snížení této hodnoty způsobí, že klient bude vydávat nové požadavky na dotaz častěji.

Přenos protokolu WebSocket má další možnosti, které je možné konfigurovat pomocí WebSockets vlastnosti:

Možnost	Výchozí hodnota	Description
CloseTimeout	5 sekund	Pokud se po ukončení serveru aplikace v tomto časovém intervalu nepovede zavřít, připojení se ukončí.
SubProtocolSelector	null	Delegát, který lze použít k nastavení Sec-WebSocket-Protocol záhlaví na vlastní hodnotu. Delegát obdrží hodnoty požadované klientem jako vstup a očekává se, že se vrátí požadovaná hodnota.

Konfigurace možností klienta

Možnosti klienta lze nakonfigurovat pro HubConnectionBuilder typ (k dispozici v klientech rozhraní .NET a v jazyce JavaScript). Je také k dispozici v klientovi Java, ale HttpHubConnectionBuilder podtřídou je to, co obsahuje možnosti konfigurace tvůrce a také na HubConnection sebe sama.

Konfigurovat protokolování

Protokolování je konfigurováno v klientovi .NET pomocí ConfigureLogging metody. Zprostředkovatelé protokolování a filtry je možné zaregistrovat stejným způsobem jako na serveru. další informace najdete v dokumentaci k protokolování ASP.NET Core .

Pokud chcete například povolit protokolování konzoly, nainstalujte Microsoft.Extensions.Logging.Console NuGet konzoly. Zavolejte AddConsole rozšiřující metodu:

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

V klientovi JavaScriptu existuje podobná configureLogging metoda. Zadejte hodnotu LogLevel určující minimální úroveň zpráv protokolu, které se mají vytvořit. Protokoly se zapisou do okna konzoly prohlížeče.

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

Místo hodnoty můžete také zadat hodnotu představující název LogLevel string úrovně protokolu. To je užitečné při konfiguraci protokolování v prostředích, kde nemáte SignalR přístup k LogLevel konstantám.

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

V následující tabulce jsou uvedeny dostupné úrovně protokolu. Hodnota, kterou poskytnete configureLogging pro , nastaví minimální úroveň protokolu, která se bude protokolovat. Zprávy zaprotokolované na této úrovni nebo úrovně za ní uvedené v tabulce se budou protokolovat.

Řetězec	LogLevel
trace	LogLevel.Trace
debug	LogLevel.Debug
info nebo information	LogLevel.Information
warn nebo warning	LogLevel.Warning
error	LogLevel.Error
critical	LogLevel.Critical
none	LogLevel.None

Další informace o protokolování najdete v dokumentaci SignalR k diagnostice.

Klient SignalR Java používá k protokolování knihovnu SLF4J. Jedná se o rozhraní API pro protokolování vysoké úrovně, které umožňuje uživatelům knihovny zvolit si vlastní specifickou implementaci protokolování tím, že přináší konkrétní závislost protokolování. Následující fragment kódu ukazuje použití s java.util.logging klientem SignalR Java.

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

Pokud ve svých závislostech nenakonfigurujete protokolování, SLF4J načte výchozí protokolovací nástroj pro žádnou operaci s následující zprávou upozornění:

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.

To můžete bezpečně ignorovat.

Konfigurace povolených přenosů

Přenosy, které používá SignalR , je možné nakonfigurovat ve volání ( v WithUrl withUrl JavaScriptu). Bitový operátor OR hodnot lze použít k omezení klienta pouze na použití HttpTransportType zadaných přenosů. Všechny přenosy jsou ve výchozím nastavení povolené.

Pokud například chcete zakázat přenos událostí Server-Sent událostí, ale povolit připojení WebSocket a Long Polling:

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

V klientovi JavaScriptu se přenosy konfiguruje nastavením pole u objektu transport options poskytnutého pro withUrl :

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

V této verzi klienta Java je jediným dostupným přenosem websocket.

V klientovi Java je přenos vybraný pomocí withTransport metody na HttpHubConnectionBuilder . Klient Java ve výchozím nastavení používá přenos WebSocket.

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

Konfigurace ověřování pomocí beareru

Pokud chcete spolu s požadavky poskytnout ověřovací data, pomocí možnosti ( v JavaScriptu) zadejte funkci, SignalR AccessTokenProvider která vrátí požadovaný accessTokenFactory přístupový token. V klientovi .NET se tento přístupový token předává jako token HTTP "Bearer Authentication" (pomocí hlavičky Authorization s typem Bearer ). V klientovi JavaScriptu se přístupový token používá jako bearer token, s výjimkou několika případů, kdy rozhraní API prohlížeče omezují možnost používat hlavičky (konkrétně v požadavcích Server-Sent Events a WebSockets). V těchto případech se přístupový token poskytuje jako hodnota řetězce dotazu access_token .

V klientovi .NET lze AccessTokenProvider možnost zadat pomocí delegáta možností v WithUrl souboru :

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

V klientovi JavaScriptu se přístupový token konfiguruje nastavením pole u accessTokenFactory objektu options v souboru 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();

V klientovi Java můžete nakonfigurovat bearer token, který se má použít k ověřování, tím, že objektu pro vytváření přístupových SignalR tokenů poskytnete HttpHubConnectionBuilder. Pomocí withAccessTokenFactory můžete poskytnout RxJava Single <String> . Voláním metody Single.defer můžetenapsat logiku pro vytvoření přístupových tokenů pro vašeho klienta.

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

Konfigurace možností časového limitu a udržování připojení

U samotného objektu jsou k dispozici další možnosti konfigurace chování při časovém limitu a HubConnection udržování připojení:

Konfigurace dalších možností

Další možnosti je možné nakonfigurovat v metodě ( v JavaScriptu) v různých konfiguračních rozhraních API v klientovi Java nebo v těchto WithUrl withUrl HubConnectionBuilder HttpHubConnectionBuilder rozhraních:

V klientovi .NET mohou být tyto možnosti upraveny delegátem možností poskytovaným pro 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();

V klientovi JavaScriptu je možné tyto možnosti skytovat v objektu JavaScriptu poskytnutém klientovi 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();

V klientovi Java je možné tyto možnosti nakonfigurovat pomocí metod HttpHubConnectionBuilder vrácených z HubConnectionBuilder.create("HUB URL")

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

Další zdroje informací

• Začínáme s ASP.NET CoreSignalR
• Použití center v ASP.NET CoreSignalR
• ASP.NET Core SignalR JavaScriptový klient
• SignalRASP.NET Core Klient .NET
• Použití protokolu MessagePack hub v SignalR pro ASP.NET Core
• SignalRASP.NET Core podporované platformy

Možnosti serializace JSON/MessagePack

SignalRASP.NET Core podporuje dva protokoly pro kódování zpráv: JSON a MessagePack. Každý protokol má možnosti konfigurace serializace.

Serializace JSON se na serveru konfiguruje pomocí metody rozšíření AddJsonProtocol. AddJsonProtocolje možné přidat za přidat SignalR do Startup.ConfigureServices . Metoda AddJsonProtocol přebírá delegáta, který přijímá options objekt . Vlastnost PayloadSerializerOptions tohoto objektu je objekt, který lze použít ke konfiguraci serializace argumentů a System.Text.Json JsonSerializerOptions návratových hodnot. Další informace najdete v dokumentaci k System.Text.Json.

Pokud například chcete serializátor nakonfigurovat tak, aby neměňte velká a malá písmena názvů vlastností, místo výchozích názvů camel case, použijte v souboru následující Startup.ConfigureServices kód:

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

V klientovi .NET existuje stejná rozšiřující AddJsonProtocol metoda v HubConnectionBuilder. Obor Microsoft.Extensions.DependencyInjection názvů je nutné importovat, aby se metoda rozšíření vyřešila:

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

Přepněte na Soubor Newtonsoft.Json.

Pokud potřebujete funkce , které nejsou podporované v systému , přejděte Newtonsoft.Json System.Text.Json Newtonsoft.Json na .

Možnosti serializace MessagePack

Serializace MessagePack lze nakonfigurovat poskytnutím delegáta pro volání AddMessagePackProtocol. Další podrobnosti SignalR najdete v tématu MessagePack v .

Konfigurace možností serveru

Následující tabulka popisuje možnosti konfigurace SignalR center:

Možnost	Výchozí hodnota	Description
ClientTimeoutInterval	30 sekund	Server považuje klienta za odpojeného, pokud v tomto intervalu neobdržel zprávu (včetně udržování). Kvůli tomu, jak je implementovaný, může trvat delší než tento časový limit, než se klient označí jako odpojený. Doporučená hodnota je dvojnásobek KeepAliveInterval hodnoty.
HandshakeTimeout	15 sekund	Pokud klient v tomto časovém intervalu nepošla úvodní zprávu handshake, připojení se zavře. Jedná se o pokročilé nastavení, které by se mělo změnit pouze v případě, že kvůli závažné latenci sítě dochází k chybám časového limitu handshake. Další podrobnosti o procesu handshake najdete ve specifikaci SignalR protokolu centra.
KeepAliveInterval	15 sekund	Pokud server v tomto intervalu neodeslal zprávu, automaticky se odesílá zpráva ping, aby připojení bylo otevřené. Při změně KeepAliveInterval změňte ServerTimeout nastavení nebo na serverTimeoutInMilliseconds klientovi. Doporučená hodnota ServerTimeout serverTimeoutInMilliseconds nebo je dvojnásobek KeepAliveInterval hodnoty.
SupportedProtocols	Všechny nainstalované protokoly	Protokoly podporované tímto centrem. Ve výchozím nastavení jsou povolené všechny protokoly zaregistrované na serveru. Protokoly je možné z tohoto seznamu odebrat a zakázat tak konkrétní protokoly pro jednotlivá centra.
EnableDetailedErrors	false	Pokud je v metodě centra vyvolána výjimka, klientům se vrátí podrobné zprávy o true výjimce. Výchozí hodnota je false , protože tyto zprávy výjimek mohou obsahovat citlivé informace.
StreamBufferCapacity	10	Maximální počet položek, které je možné uložit do vyrovnávací paměti pro streamy nahrávání klientů. Pokud dosáhnete tohoto limitu, zpracování vyvolání se zablokuje, dokud server nezpracuje položky datového proudu.
MaximumReceiveMessageSize	32 kB	Maximální velikost jedné příchozí zprávy centra.
MaximumParallelInvocationsPerClient	1	Maximální počet metod centra, které může každý klient paralelně volat před zařadit do fronty.

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta možností na AddSignalR volání v Startup.ConfigureServices .

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR(hubOptions =>
    {
        hubOptions.EnableDetailedErrors = true;
        hubOptions.KeepAliveInterval = TimeSpan.FromMinutes(1);
    });
}

Možnosti pro jedno centrum přepíší globální možnosti poskytované v a AddSignalR je možné nakonfigurovat pomocí AddHubOptions :

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

Pokročilé možnosti konfigurace HTTP

Slouží HttpConnectionDispatcherOptions ke konfiguraci upřesňujících nastavení souvisejících s přenosy a spravou vyrovnávací paměti. Tyto možnosti se konfiguruje předáním delegáta do MapHubu <T> v 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;
        });
    });
}

Následující tabulka popisuje možnosti konfigurace ASP.NET Core SignalR rozšířených možností HTTP:

Možnost	Výchozí hodnota	Description
ApplicationMaxBufferSize	32 kB	Maximální počet bajtů přijatých z klienta, které server před použitím backpressu do vyrovnávací paměti použije. Zvýšení této hodnoty umožňuje serveru přijímat větší zprávy rychleji bez použití backpressu, ale může zvýšit spotřebu paměti.
AuthorizationData	Data automaticky shromážděná z atributů Authorize použitých na třídu Hub.	Seznam objektů IAuthorizeData používaných k určení, jestli má klient oprávnění pro připojení k centru.
TransportMaxBufferSize	32 kB	Maximální počet bajtů odeslaných aplikací, které server před pozorováním backpressu do vyrovnávací paměti odesílá. Zvýšení této hodnoty umožňuje serveru rychleji vyrovnávací paměť větších zpráv, aniž by čekal na backpressure, ale může zvýšit spotřebu paměti.
Transports	Všechny přenosy jsou povolené.	Bit označuje výčet hodnot, které HttpTransportType mohou omezit přenosy, které může klient použít pro připojení.
LongPolling	Viz níže.	Další možnosti specifické pro přenos dlouhého dotazování.
WebSockets	Viz níže.	Další možnosti specifické pro přenos WebSocket.
MinimumProtocolVersion	0	Zadejte minimální verzi protokolu negotiate. Slouží k omezení klientů na novější verze.

Přenos dlouhého dotazování má další možnosti, které je možné nakonfigurovat pomocí LongPolling vlastnosti :

Možnost	Výchozí hodnota	Description
PollTimeout	90 sekund	Maximální doba, po kterou server čeká na odeslání zprávy klientovi, než se ukončuje jedna žádost o dotazování. Snížení této hodnoty způsobí, že klient bude vydávat nové požadavky na dotazování častěji.

Přenos protokolu WebSocket má další možnosti, které je možné nakonfigurovat pomocí WebSockets vlastnosti :

Možnost	Výchozí hodnota	Description
CloseTimeout	5 sekund	Pokud se po ukončení serveru v případě, že se klientovi v tomto časovém intervalu nepodaří zavřít, připojení se ukončí.
SubProtocolSelector	null	Delegát, který lze použít k nastavení Sec-WebSocket-Protocol hlavičky na vlastní hodnotu. Delegát přijímá hodnoty požadované klientem jako vstup a očekává se, že vrátí požadovanou hodnotu.

Konfigurace možností klienta

Možnosti klienta lze konfigurovat pro HubConnectionBuilder typ (k dispozici v klientech .NET a JavaScript). Je k dispozici také v klientovi Java, ale podtřída obsahuje možnosti konfigurace tvůrce i HttpHubConnectionBuilder HubConnection samotné.

Konfigurace protokolování

Protokolování se konfiguruje v klientovi .NET pomocí ConfigureLogging metody . Zprostředkovatelé a filtry protokolování je možné zaregistrovat stejným způsobem jako na serveru. Další informace najdete v ASP.NET Core v dokumentaci k protokolování.

Pokud chcete například povolit protokolování konzoly, nainstalujte Microsoft.Extensions.Logging.Console NuGet konzoly. Zavolejte AddConsole rozšiřující metodu:

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

V klientovi JavaScriptu existuje podobná configureLogging metoda. Zadejte hodnotu LogLevel určující minimální úroveň zpráv protokolu, které se mají vytvořit. Protokoly se zapisou do okna konzoly prohlížeče.

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

Místo hodnoty můžete také zadat hodnotu představující název LogLevel string úrovně protokolu. To je užitečné při konfiguraci protokolování v prostředích, kde nemáte SignalR přístup k LogLevel konstantám.

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

V následující tabulce jsou uvedeny dostupné úrovně protokolu. Hodnota, kterou poskytnete configureLogging pro , nastaví minimální úroveň protokolu, která se bude protokolovat. Zprávy zaprotokolované na této úrovni nebo úrovně za ní uvedené v tabulce se budou protokolovat.

Řetězec	LogLevel
trace	LogLevel.Trace
debug	LogLevel.Debug
info nebo information	LogLevel.Information
warn nebo warning	LogLevel.Warning
error	LogLevel.Error
critical	LogLevel.Critical
none	LogLevel.None

Další informace o protokolování najdete v dokumentaci SignalR k diagnostice.

Klient SignalR Java používá k protokolování knihovnu SLF4J. Jedná se o rozhraní API pro protokolování vysoké úrovně, které umožňuje uživatelům knihovny zvolit si vlastní specifickou implementaci protokolování tím, že přináší konkrétní závislost protokolování. Následující fragment kódu ukazuje, jak se používá java.util.logging s klientem SignalR Java.

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

Pokud ve svých závislostech nenakonfigurujete protokolování, SLF4J načte výchozí protokolovací nástroj bez operace s následující zprávou upozornění:

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.

To můžete bezpečně ignorovat.

Konfigurace povolených přenosů

Přenosy, které používá SignalR , je možné nakonfigurovat ve volání ( v WithUrl withUrl JavaScriptu). Bitový operátor OR hodnot lze použít k omezení klienta pouze na použití HttpTransportType zadaných přenosů. Všechny přenosy jsou ve výchozím nastavení povolené.

Pokud například chcete zakázat přenos událostí Server-Sent událostí, ale povolit připojení WebSocket a Long Polling:

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

V klientovi JavaScriptu se přenosy konfiguruje nastavením pole u objektu transport options poskytnutého pro withUrl :

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

V této verzi klienta Java je jediným dostupným přenosem websocket.

V klientovi Java je přenos vybraný pomocí withTransport metody na HttpHubConnectionBuilder . Klient Java ve výchozím nastavení používá přenos WebSocket.

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

Konfigurace ověřování pomocí beareru

Pokud chcete spolu s požadavky poskytnout ověřovací data, pomocí možnosti ( v JavaScriptu) zadejte funkci, SignalR AccessTokenProvider která vrátí požadovaný accessTokenFactory přístupový token. V klientovi .NET se tento přístupový token předává jako token HTTP "Bearer Authentication" (pomocí hlavičky Authorization s typem Bearer ). V klientovi JavaScriptu se přístupový token používá jako bearer token, s výjimkou několika případů, kdy rozhraní API prohlížeče omezují možnost používat hlavičky (konkrétně v požadavcích Server-Sent Events a WebSockets). V těchto případech se přístupový token poskytuje jako hodnota řetězce dotazu access_token .

V klientovi .NET lze AccessTokenProvider možnost zadat pomocí delegáta možností v WithUrl souboru :

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

V klientovi JavaScriptu se přístupový token konfiguruje nastavením pole u accessTokenFactory objektu options v souboru 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();

V klientovi Java můžete nakonfigurovat bearer token, který se má použít k ověřování, tím, že objektu pro vytváření přístupových SignalR tokenů poskytnete HttpHubConnectionBuilder. Pomocí withAccessTokenFactory můžete poskytnout RxJava Single <String> . Voláním metody Single.defer můžetenapsat logiku pro vytvoření přístupových tokenů pro vašeho klienta.

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

Konfigurace možností časového limitu a udržování připojení

U samotného objektu jsou k dispozici další možnosti konfigurace chování při časovém limitu a HubConnection udržování připojení:

Konfigurace dalších možností

Další možnosti je možné nakonfigurovat v metodě ( v JavaScriptu) v různých konfiguračních rozhraních API v klientovi Java nebo v těchto WithUrl withUrl HubConnectionBuilder HttpHubConnectionBuilder rozhraních:

V klientu .NET můžete tyto možnosti upravit pomocí delegáta možností, který je k dispozici pro 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();

V klientovi JavaScriptu lze tyto možnosti poskytnout v objektu jazyka JavaScript, který je k dispozici pro 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();

V klientovi Java lze tyto možnosti nakonfigurovat s metodami HttpHubConnectionBuilder vrácenými z HubConnectionBuilder.create("HUB URL")

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

Další zdroje informací

• Začínáme s ASP.NET CoreSignalR
• Použití center v ASP.NET CoreSignalR
• ASP.NET Core SignalR JavaScriptový klient
• SignalRASP.NET Core Klient .NET
• Použití protokolu MessagePack hub v SignalR pro ASP.NET Core
• SignalRASP.NET Core podporované platformy

Možnosti serializace JSON/MessagePack

ASP.NET Core SignalR podporuje dva protokoly pro kódování zpráv: JSON a MessagePack. Každý protokol má možnosti konfigurace serializace.

Serializaci JSON lze nakonfigurovat na serveru pomocí metody rozšíření AddJsonProtocol . AddJsonProtocollze přidat po Přidání SignalR do Startup.ConfigureServices . AddJsonProtocolMetoda přebírá delegáta, který přijímá options objekt. Vlastnost PayloadSerializerOptions tohoto objektu je System.Text.Json JsonSerializerOptions objekt, který lze použít ke konfiguraci serializace argumentů a vrácených hodnot. Další informace naleznete v dokumentaci System. text. JSON.

Chcete-li například nakonfigurovat serializátor, aby neměnil velká a malá písmena názvů vlastností, nikoli výchozí názvy případů ve stylu CamelCase , použijte následující kód v Startup.ConfigureServices :

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

V klientovi .NET AddJsonProtocol existuje stejná rozšiřující metoda v HubConnectionBuilder. Microsoft.Extensions.DependencyInjectionObor názvů musí být importován, aby bylo možné přeložit metodu rozšíření:

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

Přepnout na Newtonsoft. JSON

Pokud potřebujete funkce nástroje Newtonsoft.Json , které nejsou podporované v systému System.Text.Json , přečtěte si téma Přepnutí na Newtonsoft.Json .

Možnosti serializace MessagePack

Serializaci MessagePack lze nakonfigurovat poskytnutím delegáta volání AddMessagePackProtocol . Další podrobnosti najdete v SignalR tématu MessagePack .

Konfigurovat možnosti serveru

Následující tabulka popisuje možnosti konfigurace SignalR Center:

Možnost	Výchozí hodnota	Description
ClientTimeoutInterval	30 sekund	Server považuje klienta za odpojený, pokud neobdržel v tomto intervalu zprávu (včetně Keep-Alive). Aby bylo možné klienta označit jako odpojený z důvodu jeho implementace, může trvat delší dobu než tento časový limit. Doporučená hodnota je dvojnásobná KeepAliveInterval hodnota.
HandshakeTimeout	15 sekund	Pokud klient v tomto časovém intervalu nepošle počáteční zprávu handshake, připojení se zavře. Toto je pokročilé nastavení, které by mělo být změněno pouze v případě, že dochází k chybám časového limitu handshake kvůli závažné latenci sítě. Další informace o procesu handshake najdete v tématu SignalR specifikace protokolu pro rozbočovače.
KeepAliveInterval	15 sekund	Pokud server do tohoto intervalu neodeslal zprávu, odešle se automaticky zpráva s potvrzením, aby bylo připojení otevřené. Při změně KeepAliveInterval změňte ServerTimeout serverTimeoutInMilliseconds nastavení nebo v klientovi. Doporučená hodnota ServerTimeout nebo serverTimeoutInMilliseconds je dvojnásobná hodnota KeepAliveInterval .
SupportedProtocols	Všechny nainstalované protokoly	Protokoly podporované tímto rozbočovačem Ve výchozím nastavení jsou povoleny všechny protokoly registrované na serveru. Protokoly lze z tohoto seznamu odebrat, chcete-li zakázat konkrétní protokoly pro jednotlivá centra.
EnableDetailedErrors	false	Pokud se true do klientů vrátí podrobné zprávy o výjimce, pokud je vyvolána výjimka v metodě rozbočovače. Výchozí hodnota je, false protože tyto zprávy o výjimce mohou obsahovat citlivé informace.
StreamBufferCapacity	10	Maximální počet položek, které lze uložit do vyrovnávací paměti pro datové proudy pro odeslání klienta. Pokud je dosaženo tohoto limitu, zpracování volání je blokováno, dokud server nezpracovává položky datového proudu.
MaximumReceiveMessageSize	32 KB	Maximální velikost jedné příchozí zprávy centra

Možnosti lze nakonfigurovat pro všechna centra tím, že poskytnete možnosti delegáta pro AddSignalR volání v Startup.ConfigureServices .

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR(hubOptions =>
    {
        hubOptions.EnableDetailedErrors = true;
        hubOptions.KeepAliveInterval = TimeSpan.FromMinutes(1);
    });
}

Možnosti pro jeden rozbočovač přepíší globální možnosti poskytované v AddSignalR a můžou být nakonfigurované pomocí AddHubOptions :

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

Rozšířené možnosti konfigurace protokolu HTTP

Slouží HttpConnectionDispatcherOptions ke konfiguraci upřesňujících nastavení souvisejících s přenosy a správou vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do <T> MapHub v 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;
        });
    });
}

následující tabulka popisuje možnosti konfigurace SignalR rozšířených možností protokolu HTTP v ASP.NET Core:

Možnost	Výchozí hodnota	Description
ApplicationMaxBufferSize	32 KB	Maximální počet bajtů přijatých od klienta, které jsou ukládány do vyrovnávací paměti serveru před použitím protitlaku. Zvýšením této hodnoty umožníte, aby server přijímal větší zprávy rychleji bez použití zatížení, ale může zvýšit spotřebu paměti.
AuthorizationData	Data se automaticky shromažďují z Authorize atributů použitých pro třídu centra.	Seznam objektů IAuthorizeData , pomocí kterých se určí, jestli je klient autorizovaný pro připojení k centru
TransportMaxBufferSize	32 KB	Maximální počet bajtů odeslaných aplikací, které jsou vyrovnávací paměti serveru před pozorováním protitlaku. Zvýšením této hodnoty umožníte serveru rychleji ukládat větší zprávy bez nutnosti očekávat zatížení, ale může zvýšit spotřebu paměti.
Transports	Všechny přenosy jsou povolené.	Bitové příznaky výčtu HttpTransportType hodnot, které mohou omezit přenos, který může klient použít pro připojení.
LongPolling	Viz níže.	Další možnosti specifické pro přenos dlouhého cyklického dotazování.
WebSockets	Viz níže.	Další možnosti specifické pro přenos pomocí protokolu WebSockets
MinimumProtocolVersion	0	Zadejte minimální verzi protokolu Negotiate. Slouží k omezení klientů na novější verze.

Přenos dlouhého cyklického dotazování má další možnosti, které je možné konfigurovat pomocí LongPolling vlastnosti:

Možnost	Výchozí hodnota	Description
PollTimeout	90 sekund	Maximální doba, po kterou server čeká na odeslání zprávy klientovi před ukončením jedné žádosti o cyklické dotazování. Snížení této hodnoty způsobí, že klient bude vydávat nové požadavky na dotaz častěji.

Přenos protokolu WebSocket má další možnosti, které je možné konfigurovat pomocí WebSockets vlastnosti:

Možnost	Výchozí hodnota	Description
CloseTimeout	5 sekund	Pokud se po ukončení serveru aplikace v tomto časovém intervalu nepovede zavřít, připojení se ukončí.
SubProtocolSelector	null	Delegát, který lze použít k nastavení Sec-WebSocket-Protocol záhlaví na vlastní hodnotu. Delegát obdrží hodnoty požadované klientem jako vstup a očekává se, že se vrátí požadovaná hodnota.

Konfigurace možností klienta

Možnosti klienta lze nakonfigurovat pro HubConnectionBuilder typ (k dispozici v klientech rozhraní .NET a v jazyce JavaScript). Je také k dispozici v klientovi Java, ale HttpHubConnectionBuilder podtřídou je to, co obsahuje možnosti konfigurace tvůrce a také na HubConnection sebe sama.

Konfigurovat protokolování

Protokolování je konfigurováno v klientovi .NET pomocí ConfigureLogging metody. Zprostředkovatelé protokolování a filtry je možné zaregistrovat stejným způsobem jako na serveru. další informace najdete v dokumentaci k protokolování ASP.NET Core .

chcete-li například povolit protokolování konzoly, nainstalujte Microsoft.Extensions.Logging.Console balíček NuGet. Zavolejte AddConsole metodu rozšíření:

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

V klientovi jazyka JavaScript existuje podobná configureLogging metoda. Zadejte LogLevel hodnotu, která určuje minimální úroveň zpráv protokolu, které mají být vyprodukovány. Protokoly se zapisují do okna konzoly prohlížeče.

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

Místo LogLevel hodnoty můžete zadat také string hodnotu představující název úrovně protokolu. To je užitečné při konfiguraci SignalR protokolování v prostředích, kde nemáte přístup k LogLevel konstantám.

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

V následující tabulce jsou uvedeny dostupné úrovně protokolu. Hodnota, kterou zadáte, configureLogging nastaví minimální úroveň protokolu, která se bude protokolovat. Zprávy zaznamenané na této úrovni nebo úrovně uvedené za ní v tabulce budou protokolovány.

Řetězec	LogLevel
trace	LogLevel.Trace
debug	LogLevel.Debug
info nebo information	LogLevel.Information
warn nebo warning	LogLevel.Warning
error	LogLevel.Error
critical	LogLevel.Critical
none	LogLevel.None

Další informace o protokolování naleznete v dokumentaci k SignalR diagnostice.

SignalRKlient Java používá k protokolování knihovnu SLF4J . Jedná se o rozhraní API pro protokolování na vysoké úrovni, které umožňuje uživatelům knihovny zvolit si vlastní specifickou implementaci protokolování, a to tak, že se do konkrétní závislosti protokolování přinášejí. Následující fragment kódu ukazuje, jak používat java.util.logging s SignalR klientem Java.

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

Pokud ve svých závislostech nenakonfigurujete protokolování, SLF4J načte výchozí protokolovací nástroj No-operation s následující zprávou upozornění:

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.

Tuto možnost lze bezpečně ignorovat.

Konfigurace povolených přenosů

Přenosy používané nástrojem SignalR lze konfigurovat ve WithUrl volání ( withUrl v jazyce JavaScript). Bitové nebo hodnoty HttpTransportType lze použít k omezení klienta na používání pouze zadaných přenosů. Ve výchozím nastavení jsou povolené všechny přenosy.

Pokud třeba chcete zakázat přenos Server-Sentch událostí, ale povolit WebSockets a dlouhá připojení s dotazem:

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

V klientu jazyka JavaScript jsou přenosy konfigurovány nastavením transport pole v objektu Options, který je k dispozici pro withUrl :

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

V této verzi je jediným dostupným přenosem klientský WebSocket v jazyce Java.

V klientovi Java se přenos vybere s withTransport metodou na HttpHubConnectionBuilder . Klient Java standardně používá přenos pomocí protokolu WebSockets.

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

Konfigurace ověřování nosiče

K poskytnutí ověřovacích dat spolu s SignalR požadavky použijte AccessTokenProvider možnost ( accessTokenFactory v jazyce JavaScript) k určení funkce, která vrací požadovaný přístupový token. V klientovi .NET se tento přístupový token předává jako token ověřování HTTP "Bearer" (s použitím Authorization hlavičky s typem Bearer ). V klientu jazyka JavaScript se přístupový token používá jako nosný token, s výjimkou případů, kdy rozhraní API prohlížeče omezuje možnost použít hlavičky (konkrétně v požadavcích Server-Sent události a objekty WebSockets). V těchto případech je přístupový token k dispozici jako hodnota řetězce dotazu access_token .

V klientu .NET AccessTokenProvider lze možnost zadat pomocí delegáta možnosti v WithUrl :

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

V klientovi JavaScriptu je přístupový token nakonfigurovaný nastavením accessTokenFactory pole v objektu Options v 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();

V SignalR klientovi Java můžete nakonfigurovat nosný token, který se bude používat pro ověřování, a to poskytnutím továrny přístupového tokenu HttpHubConnectionBuilder. Pomocí withAccessTokenFactory můžete zadat RxJava Single <String> . Při volání metody Single. odkladmůžete napsat logiku pro vytvoření přístupových tokenů pro klienta.

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

Konfigurace možností timeout a Keep-Alive

Další možnosti konfigurace časového limitu a chování funkce Keep-Alive jsou k dispozici na HubConnection samotném objektu:

Konfigurace dalších možností

Další možnosti je možné nakonfigurovat v metodě ( v JavaScriptu) v různých konfiguračních rozhraních API v klientovi Java nebo v těchto WithUrl withUrl HubConnectionBuilder HttpHubConnectionBuilder rozhraních:

V klientovi .NET mohou být tyto možnosti upraveny delegátem možností poskytovaným pro WithUrl :

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

V klientovi Jazyka JavaScript je možné tyto možnosti poskytnuta v objektu JavaScriptu poskytnutém klientovi withUrl :

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

V klientovi Java je možné tyto možnosti nakonfigurovat pomocí metod HttpHubConnectionBuilder vrácených z HubConnectionBuilder.create("HUB URL")

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

Další zdroje informací

• Začínáme s ASP.NET CoreSignalR
• Použití center v ASP.NET CoreSignalR
• ASP.NET Core SignalR JavaScriptový klient
• SignalRASP.NET Core Klient .NET
• Použití protokolu MessagePack hub v SignalR pro ASP.NET Core
• SignalRASP.NET Core podporované platformy

Možnosti serializace JSON/MessagePack

SignalRASP.NET Core podporuje dva protokoly pro kódování zpráv: JSON a MessagePack. Každý protokol má možnosti konfigurace serializace.

Serializace JSON se na serveru konfiguruje pomocí metody rozšíření AddJsonProtocol. AddJsonProtocolje možné přidat za přidat SignalR do Startup.ConfigureServices . Metoda AddJsonProtocol přebírá delegáta, který přijímá options objekt . Vlastnost PayloadSerializerOptions tohoto objektu je objekt, který lze použít ke konfiguraci serializace argumentů a System.Text.Json JsonSerializerOptions návratových hodnot. Další informace najdete v dokumentaci k System.Text.Json.

Pokud například chcete serializátor nakonfigurovat tak, aby neměňte velká a malá písmena názvů vlastností, místo výchozích názvů camel case, použijte v souboru následující Startup.ConfigureServices kód:

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

V klientovi .NET existuje stejná rozšiřující AddJsonProtocol metoda v HubConnectionBuilder. Obor Microsoft.Extensions.DependencyInjection názvů je nutné importovat, aby se metoda rozšíření vyřešila:

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

Přepněte na Soubor Newtonsoft.Json.

Pokud potřebujete funkce , které nejsou podporované v systému , přejděte Newtonsoft.Json System.Text.Json Newtonsoft.Json na .

Možnosti serializace MessagePack

Serializace MessagePack lze nakonfigurovat poskytnutím delegáta pro volání AddMessagePackProtocol. Další podrobnosti SignalR najdete v tématu MessagePack v .

Konfigurace možností serveru

Následující tabulka popisuje možnosti konfigurace SignalR center:

Možnost	Výchozí hodnota	Description
ClientTimeoutInterval	30 sekund	Server považuje klienta za odpojeného, pokud v tomto intervalu neobdržel zprávu (včetně udržování). Kvůli tomu, jak je implementovaný, může trvat delší než tento časový limit, než se klient označí jako odpojený. Doporučená hodnota je dvojnásobek KeepAliveInterval hodnoty.
HandshakeTimeout	15 sekund	Pokud klient v tomto časovém intervalu nepošla úvodní zprávu handshake, připojení se zavře. Jedná se o pokročilé nastavení, které by se mělo změnit pouze v případě, že kvůli závažné latenci sítě dochází k chybám časového limitu handshake. Další podrobnosti o procesu handshake najdete ve specifikaci SignalR protokolu centra.
KeepAliveInterval	15 sekund	Pokud server v tomto intervalu neodeslal zprávu, automaticky se odesílá zpráva ping, aby připojení bylo otevřené. Při změně KeepAliveInterval změňte ServerTimeout nastavení nebo na serverTimeoutInMilliseconds klientovi. Doporučená hodnota ServerTimeout serverTimeoutInMilliseconds nebo je dvojnásobek KeepAliveInterval hodnoty.
SupportedProtocols	Všechny nainstalované protokoly	Protokoly podporované tímto centrem. Ve výchozím nastavení jsou povolené všechny protokoly zaregistrované na serveru. Protokoly je možné z tohoto seznamu odebrat a zakázat tak konkrétní protokoly pro jednotlivá centra.
EnableDetailedErrors	false	Pokud je v metodě centra vyvolána výjimka, klientům se vrátí podrobné zprávy o true výjimce. Výchozí hodnota je false , protože tyto zprávy výjimek mohou obsahovat citlivé informace.
StreamBufferCapacity	10	Maximální počet položek, které lze uložit do vyrovnávací paměti pro streamy nahrávání klientů. Pokud je tohoto limitu dosaženo, zpracování volání se zablokuje, dokud server nezpracuje položky datového proudu.
MaximumReceiveMessageSize	32 kB	Maximální velikost jedné příchozí zprávy centra.

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta možností na AddSignalR volání v Startup.ConfigureServices .

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR(hubOptions =>
    {
        hubOptions.EnableDetailedErrors = true;
        hubOptions.KeepAliveInterval = TimeSpan.FromMinutes(1);
    });
}

Možnosti pro jedno centrum přepíší globální možnosti poskytované v a AddSignalR je možné nakonfigurovat pomocí AddHubOptions :

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

Pokročilé možnosti konfigurace HTTP

Slouží HttpConnectionDispatcherOptions ke konfiguraci upřesňujících nastavení souvisejících s přenosy a spravou vyrovnávací paměti. Tyto možnosti se konfiguruje předáním delegáta do MapHubu <T> v 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;
        });
    });
}

Následující tabulka popisuje možnosti konfigurace ASP.NET Core SignalR rozšířených možností HTTP:

Možnost	Výchozí hodnota	Description
ApplicationMaxBufferSize	32 kB	Maximální počet bajtů přijatých z klienta, které server před použitím backpressu do vyrovnávací paměti použije. Zvýšení této hodnoty umožňuje serveru přijímat větší zprávy rychleji bez použití backpressu, ale může zvýšit spotřebu paměti.
AuthorizationData	Data automaticky shromážděná z atributů Authorize použitých na třídu Hub.	Seznam objektů IAuthorizeData používaných k určení, jestli má klient oprávnění pro připojení k centru.
TransportMaxBufferSize	32 kB	Maximální počet bajtů odeslaných aplikací, které server před pozorováním backpressu do vyrovnávací paměti odesílá. Zvýšení této hodnoty umožňuje serveru rychleji vyrovnávací paměť větších zpráv, aniž by čekal na backpressure, ale může zvýšit spotřebu paměti.
Transports	Všechny přenosy jsou povolené.	Bit označuje výčet hodnot, které HttpTransportType mohou omezit přenosy, které může klient použít pro připojení.
LongPolling	Viz níže.	Další možnosti specifické pro přenos dlouhého dotazování.
WebSockets	Viz níže.	Další možnosti specifické pro přenos WebSocket.

Přenos dlouhého dotazování má další možnosti, které je možné nakonfigurovat pomocí LongPolling vlastnosti :

Možnost	Výchozí hodnota	Description
PollTimeout	90 sekund	Maximální doba, po kterou server čeká na odeslání zprávy klientovi, než se ukončuje jedna žádost o dotazování. Snížení této hodnoty způsobí, že klient bude vydávat nové požadavky na dotazování častěji.

Přenos protokolu WebSocket má další možnosti, které je možné nakonfigurovat pomocí WebSockets vlastnosti :

Možnost	Výchozí hodnota	Description
CloseTimeout	5 sekund	Pokud se po zavření serveru v případě, že se klientovi v tomto časovém intervalu nepodaří zavřít, připojení se ukončí.
SubProtocolSelector	null	Delegát, který lze použít k nastavení Sec-WebSocket-Protocol hlavičky na vlastní hodnotu. Delegát přijímá hodnoty požadované klientem jako vstup a očekává se, že vrátí požadovanou hodnotu.

Konfigurace možností klienta

Možnosti klienta je možné nakonfigurovat pro HubConnectionBuilder typ (k dispozici v klientech .NET a JavaScript). Je k dispozici také v klientovi Java, ale podtřída obsahuje možnosti konfigurace tvůrce i HttpHubConnectionBuilder HubConnection samotné.

Konfigurace protokolování

Protokolování se konfiguruje v klientovi .NET pomocí ConfigureLogging metody . Zprostředkovatelé a filtry protokolování je možné zaregistrovat stejným způsobem jako na serveru. Další informace najdete v ASP.NET Core dokumentaci k protokolování.

Pokud chcete například povolit protokolování konzoly, nainstalujte Microsoft.Extensions.Logging.Console NuGet konzoly. Zavolejte AddConsole rozšiřující metodu:

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

V klientovi JavaScriptu existuje podobná configureLogging metoda. Zadejte hodnotu LogLevel určující minimální úroveň zpráv protokolu, které se mají vytvořit. Protokoly se zapisou do okna konzoly prohlížeče.

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

Místo hodnoty můžete také zadat hodnotu představující název LogLevel string úrovně protokolu. To je užitečné při konfiguraci protokolování v prostředích, kde nemáte SignalR přístup k LogLevel konstantám.

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

V následující tabulce jsou uvedeny dostupné úrovně protokolu. Hodnota, kterou poskytnete configureLogging pro , nastaví minimální úroveň protokolu, která se bude protokolovat. Zprávy zaprotokolované na této úrovni nebo úrovně za ní uvedené v tabulce se budou protokolovat.

Řetězec	LogLevel
trace	LogLevel.Trace
debug	LogLevel.Debug
info nebo information	LogLevel.Information
warn nebo warning	LogLevel.Warning
error	LogLevel.Error
critical	LogLevel.Critical
none	LogLevel.None

Další informace o protokolování najdete v dokumentaci SignalR k diagnostice.

Klient SignalR Java používá k protokolování knihovnu SLF4J. Jedná se o rozhraní API pro protokolování vysoké úrovně, které umožňuje uživatelům knihovny zvolit si vlastní specifickou implementaci protokolování tím, že přináší konkrétní závislost protokolování. Následující fragment kódu ukazuje použití s java.util.logging klientem SignalR Java.

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

Pokud ve svých závislostech nenakonfigurujete protokolování, SLF4J načte výchozí protokolovací nástroj pro žádnou operaci s následující zprávou upozornění:

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.

To můžete bezpečně ignorovat.

Konfigurace povolených přenosů

Přenosy, které používá SignalR , je možné nakonfigurovat ve volání ( v WithUrl withUrl JavaScriptu). Bitový operátor OR hodnot lze použít k omezení klienta pouze na použití HttpTransportType zadaných přenosů. Všechny přenosy jsou ve výchozím nastavení povolené.

Pokud chcete například zakázat přenos událostí Server-Sent, ale povolit připojení WebSocket a Long Polling:

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

V klientovi JavaScriptu se přenosy konfiguruje nastavením pole u objektu transport options poskytnutého do withUrl :

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

V této verzi klienta Java je jediným dostupným přenosem websocket.

V klientovi Java je přenos vybraný pomocí withTransport metody na HttpHubConnectionBuilder . Klient Java ve výchozím nastavení používá přenos WebSocket.

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

Konfigurace ověřování pomocí beareru

Pokud chcete spolu s požadavky poskytnout ověřovací data, pomocí možnosti ( v JavaScriptu) zadejte funkci, SignalR AccessTokenProvider která vrátí požadovaný accessTokenFactory přístupový token. V klientovi .NET se tento přístupový token předává jako token HTTP "Bearer Authentication" (pomocí Authorization hlavičky s typem Bearer ). V klientovi JavaScriptu se přístupový token používá jako bearer token, s výjimkou několika případů, kdy rozhraní API prohlížeče omezují možnost používat hlavičky (konkrétně v požadavcích Server-Sent Events a WebSockets). V těchto případech se přístupový token poskytuje jako hodnota řetězce dotazu access_token .

V klientovi .NET lze AccessTokenProvider možnost zadat pomocí delegáta možností v WithUrl :

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

V klientovi JavaScriptu se přístupový token konfiguruje nastavením pole u objektu accessTokenFactory options v withUrl souboru :

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

V klientovi Java můžete nakonfigurovat bearer token, který se má použít k ověřování, tím, že objektu pro vytváření přístupových tokenů poskytnete SignalR HttpHubConnectionBuilder. Pomocí withAccessTokenFactory můžete poskytnout RxJava Single <String> . Voláním metody Single.defer můžetenapsat logiku pro vytvoření přístupových tokenů pro vašeho klienta.

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

Konfigurace možností časového limitu a udržování připojení

U samotného objektu jsou k dispozici další možnosti konfigurace chování při časovém limitu a HubConnection udržování připojení:

Konfigurace dalších možností

Další možnosti je možné nakonfigurovat v metodě ( v JavaScriptu) v různých konfiguračních rozhraních API v klientovi Java nebo v těchto WithUrl withUrl HubConnectionBuilder HttpHubConnectionBuilder rozhraních:

V klientovi .NET mohou být tyto možnosti upraveny delegátem možností poskytovaným pro WithUrl :

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

V klientovi Jazyka JavaScript je možné tyto možnosti poskytnuta v objektu JavaScriptu poskytnutém klientovi withUrl :

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

V klientovi Java je možné tyto možnosti nakonfigurovat pomocí metod HttpHubConnectionBuilder vrácených z HubConnectionBuilder.create("HUB URL")

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

Další zdroje informací

• Začínáme s ASP.NET CoreSignalR
• Použití center v ASP.NET CoreSignalR
• ASP.NET Core SignalR JavaScriptový klient
• SignalRASP.NET Core Klient .NET
• Použití protokolu MessagePack hub v SignalR pro ASP.NET Core
• SignalRASP.NET Core podporované platformy

Možnosti serializace JSON/MessagePack

ASP.NET Core SignalR podporuje dva protokoly pro kódování zpráv: JSON a MessagePack. Každý protokol má možnosti konfigurace serializace.

Serializaci JSON lze nakonfigurovat na serveru pomocí metody rozšíření AddJsonProtocol , kterou lze přidat po Přidání SignalR do Startup.ConfigureServices metody. AddJsonProtocolMetoda přebírá delegáta, který přijímá options objekt. Vlastnost PayloadSerializerSettings tohoto objektu je JsonSerializerSettings objekt JSON.NET, který lze použít ke konfiguraci serializace argumentů a vrácených hodnot. Další informace najdete v dokumentaci k JSON.NET.

Chcete-li například nakonfigurovat serializátor pro použití názvů vlastností "PascalCase" místo výchozích ve stylu CamelCase názvů případů , použijte následující kód v Startup.ConfigureServices :

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

V klientovi .NET AddJsonProtocol existuje stejná rozšiřující metoda v HubConnectionBuilder. Microsoft.Extensions.DependencyInjectionObor názvů musí být importován, aby bylo možné přeložit metodu rozšíření:

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

Možnosti serializace MessagePack

Serializaci MessagePack lze nakonfigurovat poskytnutím delegáta volání AddMessagePackProtocol . Další podrobnosti najdete v SignalR tématu MessagePack .

Konfigurovat možnosti serveru

Následující tabulka popisuje možnosti konfigurace SignalR Center:

Možnost	Výchozí hodnota	Description
ClientTimeoutInterval	30 sekund	Server považuje klienta za odpojený, pokud neobdržel v tomto intervalu zprávu (včetně Keep-Alive). Aby bylo možné klienta označit jako odpojený z důvodu jeho implementace, může trvat delší dobu než tento časový limit. Doporučená hodnota je dvojnásobná KeepAliveInterval hodnota.
HandshakeTimeout	15 sekund	Pokud klient v tomto časovém intervalu nepošle počáteční zprávu handshake, připojení se zavře. Toto je pokročilé nastavení, které by mělo být změněno pouze v případě, že dochází k chybám časového limitu handshake kvůli závažné latenci sítě. Další informace o procesu handshake najdete v tématu SignalR specifikace protokolu pro rozbočovače.
KeepAliveInterval	15 sekund	Pokud server do tohoto intervalu neodeslal zprávu, odešle se automaticky zpráva s potvrzením, aby bylo připojení otevřené. Při změně KeepAliveInterval změňte ServerTimeout serverTimeoutInMilliseconds nastavení nebo v klientovi. Doporučená hodnota ServerTimeout nebo serverTimeoutInMilliseconds je dvojnásobná hodnota KeepAliveInterval .
SupportedProtocols	Všechny nainstalované protokoly	Protokoly podporované tímto rozbočovačem Ve výchozím nastavení jsou povoleny všechny protokoly registrované na serveru. Protokoly lze z tohoto seznamu odebrat, chcete-li zakázat konkrétní protokoly pro jednotlivá centra.
EnableDetailedErrors	false	Pokud se true do klientů vrátí podrobné zprávy o výjimce, pokud je vyvolána výjimka v metodě rozbočovače. Výchozí hodnota je, false protože tyto zprávy o výjimce mohou obsahovat citlivé informace.

Možnosti lze nakonfigurovat pro všechna centra tím, že poskytnete možnosti delegáta pro AddSignalR volání v Startup.ConfigureServices .

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR(hubOptions =>
    {
        hubOptions.EnableDetailedErrors = true;
        hubOptions.KeepAliveInterval = TimeSpan.FromMinutes(1);
    });
}

Možnosti pro jeden rozbočovač přepíší globální možnosti poskytované v AddSignalR a můžou být nakonfigurované pomocí AddHubOptions :

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

Rozšířené možnosti konfigurace protokolu HTTP

Slouží HttpConnectionDispatcherOptions ke konfiguraci upřesňujících nastavení souvisejících s přenosy a správou vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do <T> MapHub v 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;
        });
    });
}

následující tabulka popisuje možnosti konfigurace SignalR rozšířených možností protokolu HTTP v ASP.NET Core:

Možnost	Výchozí hodnota	Description
ApplicationMaxBufferSize	32 KB	Maximální počet bajtů přijatých od klienta, které jsou vyrovnávací paměti serveru. Zvýšením této hodnoty umožníte serveru přijímat větší zprávy, ale můžou negativně ovlivnit spotřebu paměti.
AuthorizationData	Data se automaticky shromažďují z Authorize atributů použitých pro třídu centra.	Seznam objektů IAuthorizeData , pomocí kterých se určí, jestli je klient autorizovaný pro připojení k centru
TransportMaxBufferSize	32 KB	Maximální počet bajtů odeslaných aplikací, které jsou vyrovnávací paměti serveru. Zvýšením této hodnoty umožníte serveru odesílat větší zprávy, ale můžou negativně ovlivnit spotřebu paměti.
Transports	Všechny přenosy jsou povolené.	Bitové příznaky výčtu HttpTransportType hodnot, které mohou omezit přenos, který může klient použít pro připojení.
LongPolling	Viz níže.	Další možnosti specifické pro přenos dlouhého cyklického dotazování.
WebSockets	Viz níže.	Další možnosti specifické pro přenos pomocí protokolu WebSockets

Přenos dlouhého cyklického dotazování má další možnosti, které je možné konfigurovat pomocí LongPolling vlastnosti:

Možnost	Výchozí hodnota	Description
PollTimeout	90 sekund	Maximální doba, po kterou server čeká na odeslání zprávy klientovi před ukončením jedné žádosti o cyklické dotazování. Snížení této hodnoty způsobí, že klient bude vydávat nové požadavky na dotaz častěji.

Přenos protokolu WebSocket má další možnosti, které je možné konfigurovat pomocí WebSockets vlastnosti:

Možnost	Výchozí hodnota	Description
CloseTimeout	5 sekund	Pokud se po ukončení serveru aplikace v tomto časovém intervalu nepovede zavřít, připojení se ukončí.
SubProtocolSelector	null	Delegát, který lze použít k nastavení Sec-WebSocket-Protocol záhlaví na vlastní hodnotu. Delegát obdrží hodnoty požadované klientem jako vstup a očekává se, že se vrátí požadovaná hodnota.

Konfigurace možností klienta

Možnosti klienta lze nakonfigurovat pro HubConnectionBuilder typ (k dispozici v klientech rozhraní .NET a v jazyce JavaScript). Je také k dispozici v klientovi Java, ale HttpHubConnectionBuilder podtřídou je to, co obsahuje možnosti konfigurace tvůrce a také na HubConnection sebe sama.

Konfigurovat protokolování

Protokolování je konfigurováno v klientovi .NET pomocí ConfigureLogging metody. Zprostředkovatelé protokolování a filtry je možné zaregistrovat stejným způsobem jako na serveru. další informace najdete v dokumentaci k protokolování ASP.NET Core .

chcete-li například povolit protokolování konzoly, nainstalujte Microsoft.Extensions.Logging.Console balíček NuGet. Zavolejte AddConsole metodu rozšíření:

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

V klientovi jazyka JavaScript existuje podobná configureLogging metoda. Zadejte LogLevel hodnotu, která určuje minimální úroveň zpráv protokolu, které mají být vyprodukovány. Protokoly se zapisují do okna konzoly prohlížeče.

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

Další informace o protokolování naleznete v dokumentaci k SignalR diagnostice.

SignalRKlient Java používá k protokolování knihovnu SLF4J . Jedná se o rozhraní API pro protokolování na vysoké úrovni, které umožňuje uživatelům knihovny zvolit si vlastní specifickou implementaci protokolování, a to tak, že se do konkrétní závislosti protokolování přinášejí. Následující fragment kódu ukazuje, jak používat java.util.logging s SignalR klientem Java.

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

Pokud ve svých závislostech nenakonfigurujete protokolování, SLF4J načte výchozí protokolovací nástroj No-operation s následující zprávou upozornění:

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.

Tuto možnost lze bezpečně ignorovat.

Konfigurace povolených přenosů

Přenosy používané nástrojem SignalR lze konfigurovat ve WithUrl volání ( withUrl v jazyce JavaScript). Bitové nebo hodnoty HttpTransportType lze použít k omezení klienta na používání pouze zadaných přenosů. Ve výchozím nastavení jsou povolené všechny přenosy.

Pokud třeba chcete zakázat přenos Server-Sentch událostí, ale povolit WebSockets a dlouhá připojení s dotazem:

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

V klientu jazyka JavaScript jsou přenosy konfigurovány nastavením transport pole v objektu Options, který je k dispozici pro withUrl :

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

V této verzi je jediným dostupným přenosem klientský WebSocket v jazyce Java.

Konfigurace ověřování nosiče

K poskytnutí ověřovacích dat spolu s SignalR požadavky použijte AccessTokenProvider možnost ( accessTokenFactory v jazyce JavaScript) k určení funkce, která vrací požadovaný přístupový token. V klientovi .NET se tento přístupový token předává jako token ověřování HTTP "Bearer" (s použitím Authorization hlavičky s typem Bearer ). V klientu jazyka JavaScript se přístupový token používá jako nosný token, s výjimkou případů, kdy rozhraní API prohlížeče omezuje možnost použít hlavičky (konkrétně v požadavcích Server-Sent události a objekty WebSockets). V těchto případech je přístupový token k dispozici jako hodnota řetězce dotazu access_token .

V klientu .NET AccessTokenProvider lze možnost zadat pomocí delegáta možnosti v WithUrl :

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

V klientovi JavaScriptu je přístupový token nakonfigurovaný nastavením accessTokenFactory pole v objektu Options v 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();

V SignalR klientovi Java můžete nakonfigurovat nosný token, který se bude používat pro ověřování, a to poskytnutím továrny přístupového tokenu HttpHubConnectionBuilder. Pomocí withAccessTokenFactory můžete zadat RxJava Single <String> . Při volání metody Single. odkladmůžete napsat logiku pro vytvoření přístupových tokenů pro klienta.

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

Konfigurace možností timeout a Keep-Alive

Další možnosti konfigurace časového limitu a chování funkce Keep-Alive jsou k dispozici na HubConnection samotném objektu:

Konfigurace dalších možností

Další možnosti lze konfigurovat v WithUrl withUrl metodě (v jazyce JavaScript) na HubConnectionBuilder různých konfiguračních rozhraních API v HttpHubConnectionBuilder klientovi Java:

V klientu .NET můžete tyto možnosti upravit pomocí delegáta možností, který je k dispozici pro WithUrl :

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

V klientovi JavaScriptu lze tyto možnosti poskytnout v objektu jazyka JavaScript, který je k dispozici pro withUrl :

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

V klientovi Java lze tyto možnosti nakonfigurovat s metodami HttpHubConnectionBuilder vrácenými z HubConnectionBuilder.create("HUB URL")

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

Další zdroje informací

• Začínáme s ASP.NET CoreSignalR
• Použití center v ASP.NET CoreSignalR
• ASP.NET Core SignalR JavaScriptový klient
• SignalRASP.NET Core Klient .NET
• Použití protokolu MessagePack hub v SignalR pro ASP.NET Core
• SignalRASP.NET Core podporované platformy

Možnosti serializace JSON/MessagePack

ASP.NET Core SignalR podporuje dva protokoly pro kódování zpráv: JSON a MessagePack. Každý protokol má možnosti konfigurace serializace.

Serializaci JSON lze nakonfigurovat na serveru pomocí metody rozšíření AddJsonProtocol , kterou lze přidat po Přidání SignalR do Startup.ConfigureServices metody. AddJsonProtocolMetoda přebírá delegáta, který přijímá options objekt. Vlastnost PayloadSerializerSettings tohoto objektu je JsonSerializerSettings objekt JSON.NET, který lze použít ke konfiguraci serializace argumentů a vrácených hodnot. Další informace najdete v dokumentaci k JSON.NET.

Chcete-li například nakonfigurovat serializátor pro použití názvů vlastností "PascalCase" místo výchozích ve stylu CamelCase názvů případů , použijte následující kód v Startup.ConfigureServices :

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

V klientovi .NET AddJsonProtocol existuje stejná rozšiřující metoda v HubConnectionBuilder. Microsoft.Extensions.DependencyInjectionObor názvů musí být importován, aby bylo možné přeložit metodu rozšíření:

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

Možnosti serializace MessagePack

Serializaci MessagePack lze nakonfigurovat poskytnutím delegáta volání AddMessagePackProtocol . Další podrobnosti najdete v SignalR tématu MessagePack .

Konfigurovat možnosti serveru

Následující tabulka popisuje možnosti konfigurace SignalR Center:

Možnost	Výchozí hodnota	Description
HandshakeTimeout	15 sekund	Pokud klient v tomto časovém intervalu nepošle počáteční zprávu handshake, připojení se zavře. Toto je pokročilé nastavení, které by mělo být změněno pouze v případě, že dochází k chybám časového limitu handshake kvůli závažné latenci sítě. Další informace o procesu handshake najdete v tématu SignalR specifikace protokolu pro rozbočovače.
KeepAliveInterval	15 sekund	Pokud server do tohoto intervalu neodeslal zprávu, odešle se automaticky zpráva s potvrzením, aby bylo připojení otevřené. Při změně KeepAliveInterval změňte ServerTimeout serverTimeoutInMilliseconds nastavení nebo v klientovi. Doporučená hodnota ServerTimeout nebo serverTimeoutInMilliseconds je dvojnásobná hodnota KeepAliveInterval .
SupportedProtocols	Všechny nainstalované protokoly	Protokoly podporované tímto rozbočovačem Ve výchozím nastavení jsou povoleny všechny protokoly registrované na serveru. Protokoly lze z tohoto seznamu odebrat, chcete-li zakázat konkrétní protokoly pro jednotlivá centra.
EnableDetailedErrors	false	Pokud se true do klientů vrátí podrobné zprávy o výjimce, pokud je vyvolána výjimka v metodě rozbočovače. Výchozí hodnota je, false protože tyto zprávy o výjimce mohou obsahovat citlivé informace.

Možnosti lze nakonfigurovat pro všechna centra tím, že poskytnete možnosti delegáta pro AddSignalR volání v Startup.ConfigureServices .

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR(hubOptions =>
    {
        hubOptions.EnableDetailedErrors = true;
        hubOptions.KeepAliveInterval = TimeSpan.FromMinutes(1);
    });
}

Možnosti pro jeden rozbočovač přepíší globální možnosti poskytované v AddSignalR a můžou být nakonfigurované pomocí AddHubOptions :

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

Rozšířené možnosti konfigurace protokolu HTTP

Slouží HttpConnectionDispatcherOptions ke konfiguraci upřesňujících nastavení souvisejících s přenosy a správou vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do <T> MapHub v 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;
        });
    });
}

následující tabulka popisuje možnosti konfigurace SignalR rozšířených možností protokolu HTTP v ASP.NET Core:

Možnost	Výchozí hodnota	Description
ApplicationMaxBufferSize	32 KB	Maximální počet bajtů přijatých od klienta, které jsou vyrovnávací paměti serveru. Zvýšením této hodnoty umožníte serveru přijímat větší zprávy, ale můžou negativně ovlivnit spotřebu paměti.
AuthorizationData	Data se automaticky shromažďují z Authorize atributů použitých pro třídu centra.	Seznam objektů IAuthorizeData , pomocí kterých se určí, jestli je klient autorizovaný pro připojení k centru
TransportMaxBufferSize	32 KB	Maximální počet bajtů odeslaných aplikací, které jsou vyrovnávací paměti serveru. Zvýšením této hodnoty umožníte serveru odesílat větší zprávy, ale můžou negativně ovlivnit spotřebu paměti.
Transports	Všechny přenosy jsou povolené.	Bitové příznaky výčtu HttpTransportType hodnot, které mohou omezit přenos, který může klient použít pro připojení.
LongPolling	Viz níže.	Další možnosti specifické pro přenos dlouhého cyklického dotazování.
WebSockets	Viz níže.	Další možnosti specifické pro přenos pomocí protokolu WebSockets

Přenos dlouhého cyklického dotazování má další možnosti, které je možné konfigurovat pomocí LongPolling vlastnosti:

Možnost	Výchozí hodnota	Description
PollTimeout	90 sekund	Maximální doba, po kterou server čeká na odeslání zprávy klientovi před ukončením jedné žádosti o cyklické dotazování. Snížení této hodnoty způsobí, že klient bude vydávat nové požadavky na dotaz častěji.

Přenos protokolu WebSocket má další možnosti, které je možné konfigurovat pomocí WebSockets vlastnosti:

Možnost	Výchozí hodnota	Description
CloseTimeout	5 sekund	Pokud se po ukončení serveru aplikace v tomto časovém intervalu nepovede zavřít, připojení se ukončí.
SubProtocolSelector	null	Delegát, který lze použít k nastavení Sec-WebSocket-Protocol záhlaví na vlastní hodnotu. Delegát obdrží hodnoty požadované klientem jako vstup a očekává se, že se vrátí požadovaná hodnota.

Konfigurace možností klienta

Možnosti klienta lze nakonfigurovat pro HubConnectionBuilder typ (k dispozici v klientech rozhraní .NET a v jazyce JavaScript). Je také k dispozici v klientovi Java, ale HttpHubConnectionBuilder podtřídou je to, co obsahuje možnosti konfigurace tvůrce a také na HubConnection sebe sama.

Konfigurovat protokolování

Protokolování je konfigurováno v klientovi .NET pomocí ConfigureLogging metody. Zprostředkovatelé protokolování a filtry je možné zaregistrovat stejným způsobem jako na serveru. Další informace najdete v ASP.NET Core v dokumentaci k protokolování.

Pokud chcete například povolit protokolování konzoly, nainstalujte Microsoft.Extensions.Logging.Console NuGet konzoly. Zavolejte AddConsole rozšiřující metodu:

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

V klientovi JavaScriptu existuje podobná configureLogging metoda. Zadejte hodnotu LogLevel určující minimální úroveň zpráv protokolu, které se mají vytvořit. Protokoly se zapisou do okna konzoly prohlížeče.

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

Další informace o protokolování najdete v dokumentaci SignalR k diagnostice.

Klient SignalR Java používá k protokolování knihovnu SLF4J. Jedná se o rozhraní API pro protokolování vysoké úrovně, které umožňuje uživatelům knihovny zvolit si vlastní specifickou implementaci protokolování tím, že přináší konkrétní závislost protokolování. Následující fragment kódu ukazuje použití s java.util.logging klientem SignalR Java.

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

Pokud ve svých závislostech nenakonfigurujete protokolování, SLF4J načte výchozí protokolovací nástroj pro žádnou operaci s následující zprávou upozornění:

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.

To můžete bezpečně ignorovat.

Konfigurace povolených přenosů

Přenosy, které používá SignalR , je možné nakonfigurovat ve volání ( v WithUrl withUrl JavaScriptu). Bitový operátor OR hodnot lze použít k omezení klienta pouze na použití HttpTransportType zadaných přenosů. Všechny přenosy jsou ve výchozím nastavení povolené.

Pokud například chcete zakázat přenos událostí Server-Sent událostí, ale povolit připojení WebSocket a Long Polling:

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

V klientovi JavaScriptu se přenosy konfiguruje nastavením pole u objektu transport options poskytnutého pro withUrl :

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

Konfigurace ověřování pomocí beareru

Pokud chcete spolu s požadavky poskytnout ověřovací data, pomocí možnosti ( v JavaScriptu) zadejte funkci, SignalR AccessTokenProvider která vrátí požadovaný accessTokenFactory přístupový token. V klientovi .NET se tento přístupový token předává jako token HTTP "Bearer Authentication" (pomocí hlavičky Authorization s typem Bearer ). V klientovi JavaScriptu se přístupový token používá jako bearer token, s výjimkou několika případů, kdy rozhraní API prohlížeče omezují možnost používat hlavičky (konkrétně v požadavcích Server-Sent Events a WebSockets). V těchto případech se přístupový token poskytuje jako hodnota řetězce dotazu access_token .

V klientovi .NET lze AccessTokenProvider možnost zadat pomocí delegáta možností v WithUrl souboru :

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

V klientovi JavaScriptu se přístupový token konfiguruje nastavením pole u accessTokenFactory objektu options v souboru 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();

V klientovi Java můžete nakonfigurovat bearer token, který se má použít k ověřování, tím, že objektu pro vytváření přístupových SignalR tokenů poskytnete HttpHubConnectionBuilder. Pomocí withAccessTokenFactory můžete poskytnout RxJava Single <String> . Voláním metody Single.defer můžetenapsat logiku pro vytvoření přístupových tokenů pro vašeho klienta.

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

Konfigurace možností časového limitu a udržování připojení

U samotného objektu jsou k dispozici další možnosti konfigurace chování při časovém limitu a HubConnection udržování připojení:

Konfigurace dalších možností

Další možnosti je možné nakonfigurovat v metodě ( v JavaScriptu) v různých konfiguračních rozhraních API v klientovi Java nebo v těchto WithUrl withUrl HubConnectionBuilder HttpHubConnectionBuilder rozhraních:

V klientu .NET můžete tyto možnosti upravit pomocí delegáta možností, který je k dispozici pro WithUrl :

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

V klientovi JavaScriptu lze tyto možnosti poskytnout v objektu jazyka JavaScript, který je k dispozici pro withUrl :

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

V klientovi Java lze tyto možnosti nakonfigurovat s metodami HttpHubConnectionBuilder vrácenými z HubConnectionBuilder.create("HUB URL")

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

Další materiály

• Začínáme s ASP.NET CoreSignalR
• Použití center v ASP.NET CoreSignalR
• ASP.NET Core SignalR JavaScriptový klient
• SignalRASP.NET Core Klient .NET
• Použití protokolu MessagePack hub v SignalR pro ASP.NET Core
• SignalRASP.NET Core podporované platformy