konfigurace ASP.NET Core SignalR

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

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.

Konfigurace možností serveru

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

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:

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

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

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.

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í.

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

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í:

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

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

await builder.StartAsync();

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

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:

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

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í, která se dá přidat za AddSignalR metodu Startup.ConfigureServices . Metoda AddJsonProtocol přebírá delegáta, který přijímá options objekt. Vlastnost PayloadSerializerSettings tohoto objektu je Json.NET JsonSerializerSettings objekt, který lze použít ke konfiguraci serializace argumentů a návratových hodnot. Další informace najdete v Json.NET dokumentaci.

Chcete-li například nakonfigurovat serializátor tak, aby používal názvy vlastností "PascalCase", nikoli výchozí názvy malých a malých písmen , použijte následující kód v Startup.ConfigureServices:

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

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

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.

Konfigurace možností serveru

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

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta možností na AddSignalR hovor 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, které AddSignalR jsou k dispozici, a lze je 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 se správou přenosů a vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do MapHub 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 pokročilých možností PROTOKOLU HTTP ASP.NET Core SignalR:

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

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

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.

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

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

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 chování udržování naživu jsou k dispozici u samotného objektu HubConnection :

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:

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

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í, která se dá přidat za AddSignalR metodu Startup.ConfigureServices . Metoda AddJsonProtocol přebírá delegáta, který přijímá options objekt. Vlastnost PayloadSerializerSettings tohoto objektu je Json.NET JsonSerializerSettings objekt, který lze použít ke konfiguraci serializace argumentů a návratových hodnot. Další informace najdete v Json.NET dokumentaci.

Chcete-li například nakonfigurovat serializátor tak, aby používal názvy vlastností "PascalCase", nikoli výchozí názvy malých a malých písmen , použijte následující kód v Startup.ConfigureServices:

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

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

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.

Konfigurace možností serveru

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

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta možností na AddSignalR hovor 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, které AddSignalR jsou k dispozici, a lze je 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 se správou přenosů a vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do MapHub 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 pokročilých možností PROTOKOLU HTTP ASP.NET Core SignalR:

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

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

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.

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

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.

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 chování udržování naživu jsou k dispozici u samotného objektu HubConnection :

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:

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

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

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

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.

Konfigurace možností serveru

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

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta možností na AddSignalR hovor 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, které AddSignalR jsou k dispozici, a lze je 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 se správou přenosů a vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do MapHub 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 pokročilých možností PROTOKOLU HTTP ASP.NET Core SignalR:

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

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

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.

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í.

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

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 chování udržování naživu jsou k dispozici u samotného objektu HubConnection :

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:

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

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

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

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.

Konfigurace možností serveru

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

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta možností na AddSignalR hovor 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, které AddSignalR jsou k dispozici, a lze je 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 se správou přenosů a vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do MapHub 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 pokročilých možností PROTOKOLU HTTP ASP.NET Core SignalR:

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

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

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.

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í.

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

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 chování udržování naživu jsou k dispozici u samotného objektu HubConnection :

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:

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

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

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

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.

Konfigurace možností serveru

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

Možnosti lze nakonfigurovat pro všechna centra poskytnutím delegáta možností na AddSignalR hovor 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, které AddSignalR jsou k dispozici, a lze je 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 se správou přenosů a vyrovnávací paměti. Tyto možnosti jsou nakonfigurovány předáním delegáta do MapHub 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 pokročilých možností PROTOKOLU HTTP ASP.NET Core SignalR:

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

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

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.

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í.

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

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 chování udržování naživu jsou k dispozici u samotného objektu HubConnection :

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:

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

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

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.

Konfigurace možností serveru

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

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:

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

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

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.

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í.

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

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 chování udržování naživu jsou k dispozici u samotného objektu HubConnection :

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:

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

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

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.

Konfigurace možností serveru

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

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:

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

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

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.

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í.

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

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 chování udržování naživu jsou k dispozici u samotného objektu HubConnection :

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:

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