konfigurace ASP.NET Core SignalR

Tento článek se zabývá konfigurací ASP.NET Core SignalR .

Pokyny BlazorSignalR , které přidávají nebo nahrazují pokyny v tomto článku, najdete v ASP.NET základních BlazorSignalR doprovodných materiálech.

JSMožnosti serializace ON/MessagePack

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

JSPři serializaci lze na serveru nakonfigurovat pomocí AddJsonProtocol metody rozšíření. AddJsonProtocol lze přidat za AddSignalR v Startup.ConfigureServices. Metoda AddJsonProtocol přebírá delegáta, který přijímá options objekt. Vlastnost PayloadSerializerOptions tohoto objektu System.Text.Json JsonSerializerOptions je objekt, který lze použít ke konfiguraci serializace argumentů a návratových hodnot. Další informace najdete v dokumentaci k souboru System.Text.Json.

Chcete-li například nakonfigurovat serializátor tak, aby nezměnil velikost písmen názvů vlastností, a ne výchozí názvy malých a malých písmen , použijte následující kód v Program.cs:

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

V klientovi .NET existuje stejná AddJsonProtocol metoda rozšíření .HubConnectionBuilder Aby Microsoft.Extensions.DependencyInjection bylo možné přeložit metodu rozšíření, je nutné naimportovat obor názvů:

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

Poznámka:

V tuto chvíli není možné nakonfigurovat JSserializaci ON v javascriptovém klientovi.

Přepnutí na Newtonsoft.Json

Pokud potřebujete funkce Newtonsoft.Json , které nejsou podporované, System.Text.Jsonpřečtěte si téma Přepnout na Newtonsoft.Json.

Možnosti serializace balíčku MessagePack

Serializace MessagePacku je možné nakonfigurovat poskytnutím delegáta volání AddMessagePackProtocol . Další podrobnosti najdete v SignalR balíčku MessagePack.

Poznámka:

V tuto chvíli není možné v javascriptovém klientovi konfigurovat serializaci MessagePack.

Konfigurace možností serveru

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

Možnost	Výchozí hodnota	Popis
ClientTimeoutInterval	30 sekund	Server považuje klienta za odpojeného, pokud v tomto intervalu nepřišel zpráva (včetně zachování). Může trvat delší dobu, než je tento interval časového limitu, aby se klient označil jako odpojený kvůli způsobu implementace. Doporučená hodnota je dvojnásobná KeepAliveInterval .
HandshakeTimeout	15 sekund	Pokud klient během tohoto časového intervalu neodesílá počáteční zprávu handshake, připojení se zavře. Jedná se o rozšířené nastavení, které by se mělo upravit pouze v případě, že dochází k chybám časového limitu handshake kvůli závažné latenci sítě. Další podrobnosti o procesu handshake naleznete ve specifikaci SignalRprotokolu centra.
KeepAliveInterval	15 sekund	Pokud server v tomto intervalu neodeslal zprávu, odešle se zpráva ping automaticky, aby bylo připojení otevřené. Při změně KeepAliveInterval, změňte ServerTimeout nebo serverTimeoutInMilliseconds nastavení v klientovi. Doporučená ServerTimeout hodnota nebo serverTimeoutInMilliseconds hodnota je dvojnásobná KeepAliveInterval .
SupportedProtocols	Všechny nainstalované protokoly	Protokoly podporované tímto centrem Ve výchozím nastavení jsou povolené všechny protokoly zaregistrované na serveru. Protokoly lze z tohoto seznamu odebrat, aby se zakázaly konkrétní protokoly pro jednotlivá centra.
EnableDetailedErrors	false	Pokud truese klientům vrátí podrobné zprávy o výjimce, když je v metodě centra vyvolán výjimka. Výchozí hodnota je false , ž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 nahrávání klientů. Pokud dosáhnete tohoto limitu, zpracování vyvolání se zablokuje, dokud server nezpracovává položky datového proudu.
MaximumReceiveMessageSize	32 kB	Maximální velikost jedné příchozí zprávy centra Zvýšení hodnoty může zvýšit riziko útoků DoS (Denial of Service).
MaximumParallelInvocationsPerClient	0	Maximální počet metod centra, které může každý klient volat paralelně před frontou.
DisableImplicitFromServicesParameters	false	Pokud je to možné, argumenty metody centra se přeloží z DI.

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta možností na AddSignalR hovor v Program.cs.

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

Možnosti pro jedno centrum přepíší globální možnosti, které AddSignalR jsou k dispozici, a lze je nakonfigurovat pomocí AddHubOptions:

builder.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 se správou přenosů a vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do MapHub 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();

Následující tabulka popisuje možnosti konfigurace pokročilých možností PROTOKOLU HTTP ASP.NET Core SignalR:

Možnost	Výchozí hodnota	Popis
ApplicationMaxBufferSize	64 kB	Maximální počet bajtů přijatých z klienta, který server vyrovnávací paměti před použitím zpětného tlaku. Zvýšení této hodnoty umožňuje serveru rychleji přijímat větší zprávy bez použití zpětného tlaku, ale může zvýšit spotřebu paměti.
TransportMaxBufferSize	64 kB	Maximální počet bajtů odeslaných aplikací, které server před pozorováním zpětného tlaku zasadí do vyrovnávací paměti. Zvýšení této hodnoty umožňuje serveru rychleji ukládat větší zprávy do vyrovnávací paměti, aniž by čekal na backpressure, ale může zvýšit spotřebu paměti.
AuthorizationData	Data automaticky shromážděná z Authorize atributů použitých pro třídu centra.	Seznam IAuthorizeData objektů, které slouží k určení, jestli má klient oprávnění připojit se k centru.
Transports	Jsou povoleny všechny přenosy.	Bit příznaky výčtu HttpTransportType hodnot, které mohou omezit přenosy, které klient může použít pro připojení.
LongPolling	Viz níže.	Další možnosti specifické pro přenos dlouhých 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.
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ých dotazování má další možnosti, které lze nakonfigurovat pomocí LongPolling vlastnosti:

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

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

Možnost	Výchozí hodnota	Popis
CloseTimeout	5 sekund	Po zavření serveru, pokud se klient během tohoto časového intervalu nepodaří zavřít, připojení se ukončí.
SubProtocolSelector	null	Delegát, který lze použít k nastavení hlavičky Sec-WebSocket-Protocol na vlastní hodnotu. Delegát obdrží 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 také k dispozici v klientovi Java, ale HttpHubConnectionBuilder podtřída je to, co obsahuje možnosti konfigurace tvůrce i na HubConnection sobě.

Konfigurace protokolování

Protokolování se konfiguruje 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í v ASP.NET Core.

Poznámka:

Abyste mohli zaregistrovat zprostředkovatele protokolování, musíte nainstalovat potřebné balíčky. Úplný seznam najdete v části Předdefinované zprostředkovatele protokolování v dokumentaci.

Pokud například chcete povolit protokolování konzoly, nainstalujte Microsoft.Extensions.Logging.Console balíček NuGet. AddConsole Volání metody rozšíření:

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

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

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

LogLevel Místo hodnoty můžete také zadat 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();

Následující tabulka uvádí dostupné úrovně protokolu. Zadaná configureLogging hodnota nastaví minimální úroveň protokolu, která se bude protokolovat. Zprávy zaprotokolované na této úrovni nebo úrovně uvedené za ní v tabulce se zaprotokolují.

String	ÚroveňProtokolu
trace	LogLevel.Trace
debug	LogLevel.Debug
infonebo information	LogLevel.Information
warnnebo warning	LogLevel.Warning
error	LogLevel.Error
critical	LogLevel.Critical
none	LogLevel.None

Poznámka:

Pokud chcete protokolování úplně zakázat, zadejte signalR.LogLevel.None v metodě configureLogging .

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

Klient SignalR Java používá k protokolování knihovnu SLF4J . Jedná se o rozhraní API pro protokolování vysoké úrovně, které uživatelům knihovny umožňuje zvolit si vlastní konkrétní implementaci protokolování tím, že přinese 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 v 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 se dá bezpečně ignorovat.

Konfigurace povolených přenosů

Přenosy používané SignalR v volání (withUrlv JavaScriptuWithUrl) je možné nakonfigurovat. Bitové or hodnoty HttpTransportType lze použít k omezení klienta pouze na použití zadaných přenosů. Ve výchozím nastavení jsou povoleny všechny přenosy.

Pokud chcete například zakázat přenos událostí odeslaných serverem, 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 konfigurují nastavením transport pole u objektu možností, který je k dispozici:withUrl

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

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

V klientovi Java je přenos vybrán metodou withTransport na .HttpHubConnectionBuilder Klient Java ve výchozím nastavení používá přenos WebSockets.

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

Poznámka:

SignalR Klient Java zatím nepodporuje záložní přenos.

Konfigurace nosné ověřování

Pokud chcete poskytnout ověřovací data spolu s SignalR požadavky, použijte AccessTokenProvider možnost (accessTokenFactory v JavaScriptu) k určení funkce, která vrací požadovaný přístupový token. V klientovi .NET se tento přístupový token předává jako token HTTP Bearer Authentication (Použití hlavičky Authorization s typem Bearer). V javascriptovém klientovi se přístupový token používá jako nosný token s výjimkou několika případů, kdy rozhraní API prohlížeče omezují možnost použít 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 access_tokenřetězce dotazu .

V klientovi AccessTokenProvider .NET lze tuto 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 javascriptovém klientovi je přístupový token nakonfigurován nastavením accessTokenFactory pole na 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 klientovi SignalR Java můžete nakonfigurovat nosný token, který se má použít pro ověřování tím, že poskytnete objekt pro vytváření přístupových tokenů pro HttpHubConnectionBuilder. Použití sAccessTokenFactory k poskytnutí jednoho<řetězce> RxJava. Při volání Single.defer můžete napsat logiku pro vytvář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í naživu

Další možnosti konfigurace časového limitu a zachování chování:

.NET

Možnost	Výchozí hodnota	Popis
WithServerTimeout	30 sekund (30 000 milisekund)	Časový limit pro aktivitu serveru a je nastavený přímo na HubConnectionBuilder. Pokud server v tomto intervalu neodeslal zprávu, klient považuje server za odpojený a aktivuje událost (onclosev JavaScriptuClosed). Tato hodnota musí být dostatečně velká, aby se zpráva ping odeslala ze serveru a přijala ji klient v intervalu časového limitu. Doporučená hodnota je číslo alespoň zdvojnásobit hodnotu intervaluWithKeepAliveInterval uchování () serveru, aby bylo možné dorazit čas na doručení příkazu ping.
HandshakeTimeout	15 sekund	Časový limit pro počáteční metodu handshake serveru a je k dispozici na samotném objektu HubConnection . Pokud server v tomto intervalu neodesílá odpověď handshake, klient zruší metodu handshake a aktivuje událost (onclosev JavaScriptuClosed). Jedná se o rozšířené nastavení, které by se mělo upravit pouze v případě, že dochází k chybám časového limitu handshake kvůli závažné latenci sítě. Další podrobnosti o procesu handshake naleznete ve specifikaci SignalRprotokolu centra.
WithKeepAliveInterval	15 sekund	Určuje interval, ve kterém klient odesílá zprávy ping a je nastaven přímo na HubConnectionBuilder. Toto nastavení umožňuje serveru rozpoznat pevné odpojení, například když klient odpojí počítač od sítě. Odeslání jakékoli zprávy z klienta resetuje časovač na začátek intervalu. Pokud klient neodeslal zprávu v ClientTimeoutInterval sadě na serveru, považuje server za odpojeného klienta.

V klientovi .NET jsou hodnoty časového limitu zadány jako TimeSpan hodnoty.

Následující příklad ukazuje hodnoty, které jsou dvojité výchozí hodnoty:

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

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

await builder.StartAsync();

JavaScript

Možnost	Výchozí hodnota	Popis
withServerTimeout	30 sekund (30 000 milisekund)	Časový limit pro aktivitu serveru a je nastavený přímo na HubConnectionBuilder. Pokud server v tomto intervalu neodeslal zprávu, klient považuje server za odpojený a aktivuje onclose událost. Toto nastavení umožňuje serveru rozpoznat pevné odpojení, například když klient odpojí počítač od sítě. Tato hodnota musí být dostatečně velká, aby se zpráva ping odeslala ze serveru a přijala ji klient v intervalu časového limitu. Doporučená hodnota je číslo alespoň zdvojnásobit hodnotu intervaluwithKeepAliveInterval uchování () serveru, aby bylo možné dorazit čas na doručení příkazu ping.
withKeepAliveInterval	15 sekund (15 000 milisekund)	Určuje interval, ve kterém klient odesílá zprávy ping a je nastaven přímo na HubConnectionBuilder. Toto nastavení umožňuje serveru rozpoznat pevné odpojení, například když klient odpojí počítač od sítě. Odeslání jakékoli zprávy z klienta resetuje časovač na začátek intervalu. Pokud klient neodeslal zprávu v ClientTimeoutInterval sadě na serveru, považuje server za odpojeného klienta. Příkaz ping se vyskytuje nejčastěji jako příkaz ping na serveru. Pokud server odešle příkaz ping každých pět sekund, přiřazování hodnoty nižší než 5000 (5 sekund) odešle příkaz ping každých pět sekund. Výchozí hodnota je 15 sekund. Interval udržování by měl být menší nebo roven polovině hodnoty přiřazené k vypršení časového limitu serveru (withServerTimeout).

Následující příklad ukazuje hodnoty, které jsou dvojité výchozí hodnoty:

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

Java

Možnost	Výchozí hodnota	Popis
getServerTimeout / setServerTimeout	30 sekund (30 000 milisekund)	Časový limit pro aktivitu serveru Pokud server v tomto intervalu neodeslal zprávu, klient považuje server za odpojený a aktivuje onClose událost. Tato hodnota musí být dostatečně velká, aby se zpráva ping odeslala ze serveru a přijala ji klient v intervalu časového limitu. Doporučená hodnota je číslo alespoň zdvojnásobit hodnotu serveru KeepAliveInterval , aby bylo možné dorazit příkazy ping.
withHandshakeResponseTimeout	15 sekund	Časový limit pro počáteční metodu handshake serveru Pokud server v tomto intervalu neodesílá odpověď handshake, klient zruší metodu handshake a aktivuje onClose událost. Jedná se o rozšířené nastavení, které by se mělo upravit pouze v případě, že dochází k chybám časového limitu handshake kvůli závažné latenci sítě. Další podrobnosti o procesu Handshake naleznete ve specifikaci SignalRprotokolu centra.
getKeepAliveInterval / setKeepAliveInterval	15 sekund (15 000 milisekund)	Určuje interval, ve kterém klient odesílá zprávy ping. Odeslání jakékoli zprávy z klienta resetuje časovač na začátek intervalu. Pokud klient neodeslal zprávu v ClientTimeoutInterval sadě na serveru, považuje server za odpojeného klienta.

Konfigurace stavových opětovného připojení

SignalR stavové opětovné připojení snižuje vnímaný výpadek klientů, kteří mají ve svém síťovém připojení dočasné odpojení, například při přepínání síťových připojení nebo krátké dočasné ztrátě přístupu.

Stavové opětovné připojení toho dosáhne takto:

• Dočasné ukládání dat do vyrovnávací paměti na serveru a klientovi.
• Potvrzení přijatých zpráv (ACK-ing) serverem i klientem
• Rozpoznává se, kdy je připojení vzhůru a přehrává se zprávy, které mohly být odeslány, když bylo připojení dole.

Stavové opětovné připojení je dostupné v systému ASP.NET Core 8.0 a novějším.

Přihlaste se k opětovnému připojení stavového připojení v koncovém bodu centra serveru i v klientovi:

• Aktualizujte konfiguraci koncového bodu centra serveru a povolte možnost AllowStatefulReconnects :

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

  Volitelně je možné nastavit maximální velikost vyrovnávací paměti v bajtech povolených serverem globálně nebo pro konkrétní centrum s StatefulReconnectBufferSize možností:

  Globální StatefulReconnectBufferSize sada možností:

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

  Možnost nastavená StatefulReconnectBufferSize pro konkrétní centrum:

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

  Možnost StatefulReconnectBufferSize je volitelná s výchozím nastavením 100 000 bajtů.

• Aktualizujte kód klienta JavaScriptu nebo TypeScriptu, aby se tato možnost povolila withStatefulReconnect :

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

  Možnost bufferSize je volitelná s výchozím nastavením 100 000 bajtů.

• Aktualizujte kód klienta .NET, aby se tato možnost povolila WithStatefulReconnect :

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

  Možnost StatefulReconnectBufferSize je volitelná s výchozím nastavením 100 000 bajtů.

Konfigurace dalších možností

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

.NET

Možnost .NET	Výchozí hodnota	Popis
AccessTokenProvider	null	Funkce vracející řetězec zadaný jako nosný ověřovací token v požadavcích HTTP.
SkipNegotiation	false	Pokud chcete přeskočit krok vyjednávání, nastavte true tuto možnost. Podporuje se pouze v případech, kdy je přenos WebSockets jediným povoleným přenosem. Toto nastavení nejde povolit při použití služby Azure SignalR .
ClientCertificates	Prázdné	Kolekce certifikátů TLS, které se posílají do žádostí o ověření.
Cookies	Prázdné	Kolekce HTTP cookies, která se má odeslat s každým požadavkem HTTP.
Credentials	Prázdné	Přihlašovací údaje pro odeslání s každým požadavkem HTTP.
CloseTimeout	5 sekund	Pouze protokoly WebSocket. Maximální doba, po kterou klient čeká po zavření serveru, aby potvrdil požadavek uzavření. Pokud server během této doby nepotvrdí zavření, klient se odpojí.
Headers	Prázdné	Mapa dalších hlaviček HTTP, která se mají odesílat s každým požadavkem HTTP
HttpMessageHandlerFactory	null	Delegát, který lze použít ke konfiguraci nebo nahrazení HttpMessageHandler použitého k odesílání požadavků HTTP. Nepoužívá se pro připojení WebSocket. Tento delegát musí vrátit hodnotu, která není null a obdrží výchozí hodnotu jako parametr. Buď upravte nastavení této výchozí hodnoty a vraťte ji, nebo vraťte novou HttpMessageHandler instanci. Při nahrazení obslužné rutiny nezapomeňte zkopírovat nastavení, která chcete zachovat z poskytnuté obslužné rutiny, jinak nakonfigurované možnosti (například Cookies a hlavičky) se na novou obslužnou rutinu nevztahují.
Proxy	null	Proxy server HTTP, který se má použít při odesílání požadavků HTTP.
UseDefaultCredentials	false	Nastavte tuto logickou hodnotu tak, aby se odesílaly výchozí přihlašovací údaje pro požadavky HTTP a WebSockets. To umožňuje použití ověřování systému Windows.
WebSocketConfiguration	null	Delegát, který lze použít ke konfiguraci dalších možností Protokolu WebSocket. Přijme instanci ClientWebSocketOptions , kterou lze použít ke konfiguraci možností.
ApplicationMaxBufferSize	1 MB	Maximální početch Zvýšení této hodnoty umožňuje klientovi rychleji přijímat větší zprávy bez použití zpětného tlaku, ale může zvýšit spotřebu paměti.
TransportMaxBufferSize	1 MB	Maximální počet bajtů odeslaných uživatelskou aplikací, které klient před sledováním zpětného tlaku zasadí do vyrovnávací paměti. Zvýšení této hodnoty umožňuje klientovi rychleji ukládat větší zprávy do vyrovnávací paměti, aniž by čekal na backpressure, ale může zvýšit spotřebu paměti.

JavaScript

Možnost JavaScriptu	Výchozí hodnota	Popis
accessTokenFactory	null	Funkce vracející řetězec zadaný jako nosný ověřovací token v požadavcích HTTP.
transport	null	Hodnota HttpTransportType určující přenos, který se má použít pro připojení.
headers	null	Slovník hlaviček odeslaných s každým požadavkem HTTP. Odesílání hlaviček v prohlížeči nefunguje pro webSockety ani ServerSentEvents datový proud.
logMessageContent	null	Nastavte na true protokolování bajtů a znaků zpráv odeslaných a přijatých klientem.
skipNegotiation	false	Pokud chcete přeskočit krok vyjednávání, nastavte true tuto možnost. Podporuje se pouze v případech, kdy je přenos WebSockets jediným povoleným přenosem. Toto nastavení nejde povolit při použití služby Azure SignalR .
withCredentials	true	Určuje, jestli se přihlašovací údaje posílají s požadavkem CORS. Aplikace Azure Služba používá cookieho pro rychlé relace a potřebuje, aby tato možnost fungovala správně. Další informace oCORch ASP.NET SignalRch SignalR
timeout	100,000	Časový limit v milisekundách, který se má použít u požadavků HTTP To se nevztahuje na požadavky na dlouhé dotazování, EventSource nebo WebSockets.

Java

Možnost Javy	Výchozí hodnota	Popis
withAccessTokenProvider	null	Funkce vracející řetězec zadaný jako nosný ověřovací token v požadavcích HTTP.
shouldSkipNegotiate	false	Pokud chcete přeskočit krok vyjednávání, nastavte true tuto možnost. Podporuje se pouze v případech, kdy je přenos WebSockets jediným povoleným přenosem. Toto nastavení nejde povolit při použití služby Azure SignalR .
withHeader withHeaders	Prázdné	Mapa dalších hlaviček HTTP, která se mají odesílat s každým požadavkem HTTP

V klientovi .NET lze tyto možnosti upravit delegátem možností, které WithUrlposkytuje:

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 javascriptovém klientovi je možné tyto možnosti zadat v objektu JavaScriptu, který withUrlposkytuje:

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 pomocí metod vrácených HttpHubConnectionBuilder 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 Core SignalR
• Použití center v ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• klient ASP.NET Core SignalR .NET
• Použití protokolu Centra MessagePack pro SignalR ASP.NET Core
• podporované platformy ASP.NET Core SignalR