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.

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.

Serializace JSON se dá nakonfigurovat na serveru 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.JsonJsonSerializerOptions 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á metoda rozšíření na AddJsonProtocolHubConnectionBuilder. Obor názvů Microsoft.Extensions.DependencyInjection musí být importován, aby bylo možné rozliš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();

Poznámka:

V tuto chvíli není možné nakonfigurovat serializaci JSON 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

Serializaci MessagePack lze konfigurovat poskytnutím delegáta pro volání AddMessagePackProtocol. Další informace naleznete v MessagePackuSignalR.

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šla zpráva (včetně udržování připojení). Může trvat déle, než je tento časový limit, než bude klient označen jako odpojený, kvůli způsobu, jakým je to implementováno. Doporučená hodnota je dvojnásobná vůči hodnotě 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 Centrální specifikaci protokoluSignalR.
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á hodnota ServerTimeout nebo hodnota serverTimeoutInMilliseconds je dvojnásobná hodnota 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 true je v metodě hubu vyvolána výjimka, vrátí se klientům podrobné zprávy o výjimce. 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	1	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 rozbočovače se získají z DI.

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta nastavení pro volání AddSignalR 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 dostupné v AddSignalR 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 pokročilých nastavení souvisejících se správou přenosů a paměťové vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do MapHubProgram.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 přímo od klienta, které server načte do vyrovnávací paměti, než se použije zpětné zatížení. 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 zpětný tlak, ale může to zvýšit spotřebu paměti.
AuthorizationData	Data automaticky shromážděná z Authorize atributů použitých pro třídu Hub.	Seznam IAuthorizeData objektů, které slouží k určení, jestli má klient oprávnění připojit se k centru.
Transports	Všechny transporty jsou povoleny.	Bitové příznaky v enumeraci hodnot HttpTransportType, které mohou omezit přenosy, jež klient může použít pro připojení.
LongPolling	Viz níže.	Další možnosti specifické pro přenosový protokol long polling.
WebSockets	Viz níže.	Další možnosti specifické pro přenos webSocket.
MinimumProtocolVersion	0	Zadejte minimální verzi dohadovacího protokolu. Slouží k omezení klientů na novější verze.
CloseOnAuthenticationExpiration	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 Java klientovi, ale HttpHubConnectionBuilder podtřída obsahuje možnosti konfigurace tvůrce, stejně jako v HubConnection.

Konfigurujte 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. Zavolejte metodu rozšíření AddConsole:

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é po ní v tabulce budou zaznamenány.

Řetězec	Úroveň protokolu
trace	LogLevel.Trace
debug	LogLevel.Debug
info neboinformation	LogLevel.Information
warn nebowarning	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 je možné nakonfigurovat ve volání WithUrl (withUrl v JavaScriptu). 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í 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 JavaScript klientovi se konfigurace přenosů provádí nastavením pole transport v objektu možností poskytnutém do 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 pomocí metody 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 ověřování nositele

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 klientu .NET lze možnost AccessTokenProvider 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<>. 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 udržování vlastností spojení:

.SÍŤ

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 (Closedv JavaScriptuonclose). 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ň dvojnásobek hodnoty intervalu uchování WithKeepAliveInterval serveru, aby měly pingly dostatek času dorazit.
HandshakeTimeout	15 sekund	Časový limit pro počáteční handshake serveru je k dispozici přímo na samotném objektu HubConnection. Pokud server v tomto intervalu neodešle odpověď handshake, klient zruší handshake a aktivuje událost (Closedv JavaScriptuonclose). 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 Centrální specifikaci protokoluSignalR.
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 časovém intervalu nastaveném na serveru, server ho považuje za odpojeného.

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ň dvojnásobek hodnoty intervalu uchování withKeepAliveInterval serveru, aby měly pingly dostatek času dorazit.
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 časovém intervalu nastaveném na serveru, server ho považuje za odpojeného. Příkaz ping se vyskytuje nanejvýš tak často, jak server provádí ping. Pokud server odešle příkaz ping každých pět sekund, přiřazení hodnoty nižší než 5000 (5 sekund) způsobí, že server stále odesílá 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 času vypršení 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, které je alespoň dvojnásobkem hodnoty serveru KeepAliveInterval, aby měly pingly čas dorazit.
withHandshakeResponseTimeout	15 sekund	Časový limit pro počáteční handshake serveru Pokud server během tohoto časového intervalu neodesílá odpověď handshake, klient zruší handshake a aktivuje událost onClose. 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 Hub protokoluSignalR.
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 časovém intervalu nastaveném na serveru, server ho považuje za odpojeného.

Konfigurujte stavové opětovné 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 na klientovi.
• Potvrzení přijatých zpráv (ACK-ing) serverem i klientem
• Rozpoznává se, kdy je připojení aktivní a přehrávají se zprávy, které mohly být odeslány, když bylo připojení přerušené.

Stavové opětovné připojení je k dispozici v .NET 8 nebo novějším.

Povolte stavové opětovné připojení na serveru i klientovi.

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

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

  Volitelně lze maximální velikost vyrovnávací paměti v bajtech povolenou serverem nastavit globálně nebo pro konkrétní středisko pomocí volby StatefulReconnectBufferSize.

  Globální nastavení StatefulReconnectBufferSize možnosti:

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

  Sada možností StatefulReconnectBufferSize pro určitý hub:

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

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

• Aktualizujte klientský kód v JavaScriptu nebo TypeScriptu, abyste povolili možnost 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 byla možnost WithStatefulReconnect povolena.

    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ě WithUrl (withUrlv JavaScriptu HubConnectionBuilder ) nebo v různých konfiguračních rozhraních HttpHubConnectionBuilder API v klientovi Java je možné nakonfigurovat další možnosti:

.SÍŤ

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 k odesílání za účelem ověření žádostí.
Cookies	Prázdný	Kolekce souborů cookie HTTP, která se má odesílat 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 uzavření, aby server 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 soubory cookie 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čet bajtů přijatých ze serveru, které klient vyrovnává před použitím zpětného tlaku. 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 uchovává ve vyrovnávací paměti před sledováním zpětného tlaku. Zvýšení této hodnoty umožňuje klientovi rychleji ukládat větší zprávy do vyrovnávací paměti, aniž by čekal na zpětný tlak (backpressure), ale může to 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 stream.
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. Azure App Service používá soubory cookie pro stabilní relace a potřebuje tuto možnost povolit, aby fungovala správně. Další informace oCORch 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 typu Long Polling, 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();

Dodatečné zdroje

• 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žijte protokol hubu MessagePack v rámci SignalR ASP.NET Core
• podporované platformy ASP.NET Core SignalR