Konfiguracja ASP.NET Core SignalR

Opcje serializacji JSON/MessagePack

ASP.NET Core SignalR obsługuje dwa protokoły kodowania komunikatów: JSON i MessagePack. Każdy protokół ma opcje konfiguracji serializacji.

Serializację JSON można skonfigurować na serwerze za pomocą metody rozszerzenia AddJsonProtocol. AddJsonProtocol można dodać po AddSignalR w pliku Startup.ConfigureServices. Metoda AddJsonProtocol przyjmuje delegata, który otrzymuje obiekt options. Właściwość PayloadSerializerOptions tego obiektu jest obiektem System.Text.JsonJsonSerializerOptions , który może służyć do konfigurowania serializacji argumentów i zwracanych wartości. Aby uzyskać więcej informacji, zobacz dokumentację System.Text.Json.

Aby na przykład skonfigurować serializator tak, aby nie zmieniał wielkości liter nazw właściwości, zamiast domyślnej notacji camel case, użyj następującego kodu w Program.cs.

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

W kliencie .NET istnieje ta sama metoda rozszerzenia AddJsonProtocol na HubConnectionBuilder. Aby rozwiązać metodę rozszerzenia, należy zaimportować przestrzeń nazw Microsoft.Extensions.DependencyInjection.

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

Przełącz na Newtonsoft.Json

Jeśli potrzebujesz funkcji Newtonsoft.Json, które nie są obsługiwane w System.Text.Json, zajrzyj do Przejdź na Newtonsoft.Json.

Opcje serializacji MessagePack

Można skonfigurować serializację MessagePack, podając delegata do wywołania AddMessagePackProtocol. Aby uzyskać więcej informacji, zobacz MessagePack w pliku SignalR .

Konfigurowanie opcji serwera

W poniższej tabeli opisano opcje konfiguracji koncentratorów SignalR:

Opcje można skonfigurować dla wszystkich centrów, udostępniając delegat opcji do wywołania AddSignalR w programie Program.cs.

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

Opcje pojedynczego koncentratora zastępują opcje globalne dostępne w programie AddSignalR i można je skonfigurować przy użyciu polecenia AddHubOptions:

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

Zaawansowane opcje konfiguracji PROTOKOŁU HTTP

Służy HttpConnectionDispatcherOptions do konfigurowania ustawień zaawansowanych związanych z transportami i zarządzaniem buforem pamięci. Te opcje są konfigurowane przez przekazanie delegata do MapHub elementu w programie 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();

W poniższej tabeli opisano opcje konfigurowania zaawansowanych opcji http platformy ASP.NET Core SignalR:

Transport Long Polling ma dodatkowe opcje, które można skonfigurować przy użyciu LongPolling właściwości :

Transport protokołu WebSocket ma dodatkowe opcje, które można skonfigurować przy użyciu WebSockets właściwości :

Konfigurowanie opcji klienta

Opcje klienta można skonfigurować na typie HubConnectionBuilder (dostępnym na klientach .NET i JavaScript). Jest ona również dostępna w kliencie Java, ale podklasa HttpHubConnectionBuilder zawiera opcje konfiguracji konstruktora, a także na HubConnection samym kliencie.

Konfigurowanie rejestrowania

Rejestrowanie jest konfigurowane w kliencie .NET przy użyciu ConfigureLogging metody . Dostawcy rejestrowania i filtry można zarejestrować w taki sam sposób, jak na serwerze. Aby uzyskać więcej informacji, zobacz dokumentację rejestrowanie w usłudze ASP.NET Core .

Aby na przykład włączyć rejestrowanie konsoli, zainstaluj Microsoft.Extensions.Logging.Console pakiet NuGet. Wywołaj metodę AddConsole rozszerzenia:

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

W kliencie JavaScript istnieje podobna configureLogging metoda. Podaj wartość wskazującą LogLevel minimalny poziom komunikatów dziennika do utworzenia. Dzienniki są zapisywane w oknie konsoli przeglądarki.

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

Zamiast wartości LogLevel, można także podać wartość string będącą nazwą poziomu dziennika. Jest to przydatne podczas konfigurowania SignalR rejestrowania w środowiskach, w których nie masz dostępu do LogLevel stałych.

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

W poniższej tabeli wymieniono dostępne poziomy dziennika. Wartość, którą podajesz, ustawia configureLoggingminimalny poziom dziennika, który zostanie zarejestrowany. Komunikaty zarejestrowane na tym poziomie lub poziomy wymienione po niej w tabeli zostaną zarejestrowane.

Aby uzyskać więcej informacji na temat rejestrowania, zobacz dokumentacjęSignalR diagnostyki.

Klient SignalR Java używa biblioteki SLF4J do rejestrowania. Jest to interfejs API rejestrowania wysokiego poziomu, który umożliwia użytkownikom biblioteki wybranie własnej implementacji rejestrowania przez wprowadzenie określonej zależności rejestrowania. Poniższy fragment kodu pokazuje, jak używać go java.util.logging z klientem SignalR Java.

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

Jeśli nie skonfigurujesz rejestrowania w zależnościach, SLF4J ładuje domyślny rejestrator bez operacji z następującym komunikatem ostrzegawczym:

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.

Można to bezpiecznie zignorować.

Konfigurowanie dozwolonych transportów

Transporty używane przez SignalR program można skonfigurować w wywołaniu WithUrl (withUrl w języku JavaScript). Bitowe or wartości parametru HttpTransportType można użyć do ograniczenia klienta do używania tylko określonych transportów. Wszystkie transporty są domyślnie włączone.

Na przykład, aby wyłączyć transport zdarzeń Server-Sent, ale nadal zezwalać na połączenia za pomocą technologii WebSocket i Long Polling:

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

W kliencie JavaScript transporty są konfigurowane przez ustawienie pola transport w obiekcie opcji przekazanym do withUrl:

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

W tej wersji klienta Java WebSockets jest jedynym dostępnym transportem.

W kliencie Java transport jest wybierany przy użyciu withTransport metody w pliku HttpHubConnectionBuilder. Klient Java domyślnie używa transportu WebSocket.

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

Konfigurowanie uwierzytelniania elementu nośnego

Aby udostępnić dane uwierzytelniania wraz z żądaniami SignalR , użyj AccessTokenProvider opcji (accessTokenFactory w języku JavaScript), aby określić funkcję zwracającą żądany token dostępu. W kliencie platformy .NET ten token dostępu jest przekazywany jako token HTTP "Uwierzytelnianie Bearer" (przy użyciu nagłówka Authorization o typie Bearer). W kliencie JavaScript token dostępu jest używany jako Bearer token, z wyjątkiem kilku przypadków, w których interfejsy API przeglądarki ograniczają możliwość stosowania nagłówków (w szczególności w żądaniach Server-Sent Events i WebSockets). W takich przypadkach token dostępu jest udostępniany jako wartość ciągu zapytania access_token.

W kliencie AccessTokenProvider platformy .NET można określić opcję przy użyciu delegata opcji w programie WithUrl:

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

W kliencie JavaScript token dostępu jest konfigurowany przez ustawienie pola accessTokenFactory w obiekcie options w 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();

W kliencie SignalR języka Java można skonfigurować token typu bearer do uwierzytelniania, przekazując fabrykę tokenów dostępu do programu HttpHubConnectionBuilder. Użyj funkcji withAccessTokenFactory, aby udostępnić <. Wywołanie metody Single.defer umożliwia napisanie logiki w celu utworzenia tokenów dostępu dla klienta.

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

Konfiguruj opcje limitu czasu i utrzymywania aktywności

Dodatkowe opcje konfigurowania limitu czasu i zachowania utrzymania aktywności:

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

Konfigurowanie stanowego ponownego nawiązywania połączenia

SignalR przywracanie połączenia z zachowaniem stanu zmniejsza postrzegany przestój klientów, którzy doświadczają przerwy w połączeniu sieciowym, na przykład podczas przełączania połączeń sieciowych lub krótkiej tymczasowej utraty dostępu.

Stanowe ponowne nawiązywanie połączenia umożliwia wykonanie następujących kroków:

• Tymczasowo buforowanie danych na serwerze i kliencie.
• Potwierdzenie odebranych komunikatów (ACK-ing) zarówno przez serwer, jak i klienta.
• Rozpoznawanie, gdy połączenie zostało przywrócone i ponowne odtwarzanie komunikatów, które mogły zostać wysłane w czasie przerwy w połączeniu.

Stanowe ponowne połączenie jest dostępne na platformie .NET 8 lub nowszym.

Włącz stanowe wznawianie połączeń zarówno na końcówce serwera, jak i po stronie klienta.

• Zaktualizuj konfigurację punktu końcowego centrum serwera, aby włączyć AllowStatefulReconnects opcję:

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

  Opcjonalnie maksymalny rozmiar buforu w bajtach dozwolonych przez serwer można ustawić globalnie lub dla określonego centrum z opcją StatefulReconnectBufferSize :

  Opcja StatefulReconnectBufferSize ustawiona globalnie:

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

  Zestaw opcji StatefulReconnectBufferSize dla konkretnego centrum:

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

  Opcja StatefulReconnectBufferSize jest opcjonalna z wartością domyślną 100 000 bajtów.

• Zaktualizuj kod klienta JavaScript lub TypeScript, aby włączyć withStatefulReconnect opcję.

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

  Opcja bufferSize jest opcjonalna z wartością domyślną 100 000 bajtów.

• Zaktualizuj kod klienta platformy .NET, aby włączyć WithStatefulReconnect opcję:

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

  Opcja StatefulReconnectBufferSize jest opcjonalna z wartością domyślną 100 000 bajtów.

Konfigurowanie dodatkowych opcji

Dodatkowe opcje można skonfigurować w metodzie WithUrl (withUrl w języku JavaScript) w systemie HubConnectionBuilder lub w różnych interfejsach API konfiguracji w kliencie HttpHubConnectionBuilder Java:

W kliencie platformy .NET opcje te można modyfikować za pomocą delegata opcji przekazanego do WithUrl.

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

W kliencie Języka JavaScript te opcje można podać w obiekcie JavaScript udostępnionym użytkownikowi withUrl:

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub", {
        // "Foo: Bar" will not be sent with WebSockets or Server-Sent Events requests
        headers: { "Foo": "Bar" },
        transport: signalR.HttpTransportType.LongPolling 
    })
    .build();

W kliencie Języka Java te opcje można skonfigurować przy użyciu metod zwróconych HttpHubConnectionBuilder z obiektu HubConnectionBuilder.create("HUB URL")

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

Dodatkowe zasoby

• Wprowadzenie do platformy ASP.NET Core SignalR
• Używanie hubów w ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• Klient ASP.NET Core dla platformy .NETSignalR
• Używanie protokołu MessagePack Hub w programie SignalR dla platformy ASP.NET Core
• Obsługiwane platformy ASP.NET Core SignalR

Opcje serializacji JSON/MessagePack

ASP.NET Core SignalR obsługuje dwa protokoły kodowania komunikatów: JSON i MessagePack. Każdy protokół ma opcje konfiguracji serializacji.

Konfigurację serializacji JSON można przeprowadzić na serwerze przy użyciu metody rozszerzenia AddJsonProtocol, którą można dodać po AddSignalR w metodzie Startup.ConfigureServices. Metoda AddJsonProtocol przyjmuje delegata, który otrzymuje obiekt options. Właściwość PayloadSerializerSettings tego obiektu jest obiektem Json.NET JsonSerializerSettings , który może służyć do konfigurowania serializacji argumentów i zwracanych wartości. Aby uzyskać więcej informacji, zobacz dokumentację Json.NET.

Na przykład, aby skonfigurować serializator do używania nazw właściwości "PascalCase", a nie domyślnych nazw camelCase, użyj następującego kodu w Startup.ConfigureServices.

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

W kliencie .NET istnieje ta sama metoda rozszerzenia AddJsonProtocol na HubConnectionBuilder. Aby rozwiązać metodę rozszerzenia, należy zaimportować przestrzeń nazw Microsoft.Extensions.DependencyInjection.

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

Opcje serializacji MessagePack

Można skonfigurować serializację MessagePack, podając delegata do wywołania AddMessagePackProtocol. Aby uzyskać więcej informacji, zobacz MessagePack w pliku SignalR .

Konfigurowanie opcji serwera

W poniższej tabeli opisano opcje konfiguracji koncentratorów SignalR:

Opcje można skonfigurować dla wszystkich centrów, udostępniając delegat opcji do wywołania AddSignalR w programie Startup.ConfigureServices.

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

Opcje pojedynczego koncentratora zastępują opcje globalne dostępne w programie AddSignalR i można je skonfigurować przy użyciu polecenia AddHubOptions:

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

Zaawansowane opcje konfiguracji PROTOKOŁU HTTP

Służy HttpConnectionDispatcherOptions do konfigurowania ustawień zaawansowanych związanych z transportami i zarządzaniem buforem pamięci. Te opcje są konfigurowane przez przekazanie delegata do MapHub elementu w programie 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;
        });
    });
}

W poniższej tabeli opisano opcje konfigurowania zaawansowanych opcji http platformy ASP.NET Core SignalR:

Transport Long Polling ma dodatkowe opcje, które można skonfigurować przy użyciu LongPolling właściwości :

Transport protokołu WebSocket ma dodatkowe opcje, które można skonfigurować przy użyciu WebSockets właściwości :

Konfigurowanie opcji klienta

Opcje klienta można skonfigurować na typie HubConnectionBuilder (dostępnym na klientach .NET i JavaScript). Jest ona również dostępna w kliencie Java, ale podklasa HttpHubConnectionBuilder zawiera opcje konfiguracji konstruktora, a także na HubConnection samym kliencie.

Konfigurowanie rejestrowania

Rejestrowanie jest konfigurowane w kliencie .NET przy użyciu ConfigureLogging metody . Dostawcy rejestrowania i filtry można zarejestrować w taki sam sposób, jak na serwerze. Aby uzyskać więcej informacji, zobacz dokumentację rejestrowanie w usłudze ASP.NET Core .

Aby na przykład włączyć rejestrowanie konsoli, zainstaluj Microsoft.Extensions.Logging.Console pakiet NuGet. Wywołaj metodę AddConsole rozszerzenia:

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

W kliencie JavaScript istnieje podobna configureLogging metoda. Podaj wartość wskazującą LogLevel minimalny poziom komunikatów dziennika do utworzenia. Dzienniki są zapisywane w oknie konsoli przeglądarki.

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

Aby uzyskać więcej informacji na temat rejestrowania, zobacz dokumentacjęSignalR diagnostyki.

Klient SignalR Java używa biblioteki SLF4J do rejestrowania. Jest to interfejs API rejestrowania wysokiego poziomu, który umożliwia użytkownikom biblioteki wybranie własnej implementacji rejestrowania przez wprowadzenie określonej zależności rejestrowania. Poniższy fragment kodu pokazuje, jak używać go java.util.logging z klientem SignalR Java.

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

Jeśli nie skonfigurujesz rejestrowania w zależnościach, SLF4J ładuje domyślny rejestrator bez operacji z następującym komunikatem ostrzegawczym:

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.

Można to bezpiecznie zignorować.

Konfigurowanie dozwolonych transportów

Transporty używane przez SignalR program można skonfigurować w wywołaniu WithUrl (withUrl w języku JavaScript). Bitowe or wartości parametru HttpTransportType można użyć do ograniczenia klienta do używania tylko określonych transportów. Wszystkie transporty są domyślnie włączone.

Na przykład, aby wyłączyć transport zdarzeń Server-Sent, ale nadal zezwalać na połączenia za pomocą technologii WebSocket i Long Polling:

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

W kliencie JavaScript transporty są konfigurowane przez ustawienie pola transport w obiekcie opcji przekazanym do withUrl:

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

Konfigurowanie uwierzytelniania elementu nośnego

Aby udostępnić dane uwierzytelniania wraz z żądaniami SignalR , użyj AccessTokenProvider opcji (accessTokenFactory w języku JavaScript), aby określić funkcję zwracającą żądany token dostępu. W kliencie platformy .NET ten token dostępu jest przekazywany jako token HTTP "Uwierzytelnianie Bearer" (przy użyciu nagłówka Authorization o typie Bearer). W kliencie JavaScript token dostępu jest używany jako Bearer token, z wyjątkiem kilku przypadków, w których interfejsy API przeglądarki ograniczają możliwość stosowania nagłówków (w szczególności w żądaniach Server-Sent Events i WebSockets). W takich przypadkach token dostępu jest udostępniany jako wartość ciągu zapytania access_token.

W kliencie AccessTokenProvider platformy .NET można określić opcję przy użyciu delegata opcji w programie WithUrl:

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

W kliencie JavaScript token dostępu jest konfigurowany przez ustawienie pola accessTokenFactory w obiekcie options w 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();

W kliencie SignalR języka Java można skonfigurować token typu bearer do uwierzytelniania, przekazując fabrykę tokenów dostępu do programu HttpHubConnectionBuilder. Użyj funkcji withAccessTokenFactory, aby udostępnić <. Wywołanie metody Single.defer umożliwia napisanie logiki w celu utworzenia tokenów dostępu dla klienta.

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

Konfiguruj opcje limitu czasu i utrzymywania aktywności

Dodatkowe opcje konfigurowania limitu czasu i zachowania utrzymania aktywności są dostępne bezpośrednio na obiekcie HubConnection.

Konfigurowanie dodatkowych opcji

Dodatkowe opcje można skonfigurować w metodzie WithUrl (withUrl w języku JavaScript) w systemie HubConnectionBuilder lub w różnych interfejsach API konfiguracji w kliencie HttpHubConnectionBuilder Java:

W kliencie platformy .NET opcje te można modyfikować za pomocą delegata opcji przekazanego do WithUrl.

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

W kliencie Języka JavaScript te opcje można podać w obiekcie JavaScript udostępnionym użytkownikowi withUrl:

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

W kliencie Języka Java te opcje można skonfigurować przy użyciu metod zwróconych HttpHubConnectionBuilder z obiektu HubConnectionBuilder.create("HUB URL")

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

Dodatkowe zasoby

• Wprowadzenie do platformy ASP.NET Core SignalR
• Używanie hubów w ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• Klient ASP.NET Core dla platformy .NETSignalR
• Używanie protokołu MessagePack Hub w programie SignalR dla platformy ASP.NET Core
• Obsługiwane platformy ASP.NET Core SignalR

Opcje serializacji JSON/MessagePack

ASP.NET Core SignalR obsługuje dwa protokoły kodowania komunikatów: JSON i MessagePack. Każdy protokół ma opcje konfiguracji serializacji.

Konfigurację serializacji JSON można przeprowadzić na serwerze przy użyciu metody rozszerzenia AddJsonProtocol, którą można dodać po AddSignalR w metodzie Startup.ConfigureServices. Metoda AddJsonProtocol przyjmuje delegata, który otrzymuje obiekt options. Właściwość PayloadSerializerSettings tego obiektu jest obiektem Json.NET JsonSerializerSettings , który może służyć do konfigurowania serializacji argumentów i zwracanych wartości. Aby uzyskać więcej informacji, zobacz dokumentację Json.NET.

Na przykład, aby skonfigurować serializator do używania nazw właściwości "PascalCase", a nie domyślnych nazw camelCase, użyj następującego kodu w Startup.ConfigureServices.

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

W kliencie .NET istnieje ta sama metoda rozszerzenia AddJsonProtocol na HubConnectionBuilder. Aby rozwiązać metodę rozszerzenia, należy zaimportować przestrzeń nazw Microsoft.Extensions.DependencyInjection.

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

Opcje serializacji MessagePack

Można skonfigurować serializację MessagePack, podając delegata do wywołania AddMessagePackProtocol. Aby uzyskać więcej informacji, zobacz MessagePack w pliku SignalR .

Konfigurowanie opcji serwera

W poniższej tabeli opisano opcje konfiguracji koncentratorów SignalR:

Opcje można skonfigurować dla wszystkich centrów, udostępniając delegat opcji do wywołania AddSignalR w programie Startup.ConfigureServices.

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

Opcje pojedynczego koncentratora zastępują opcje globalne dostępne w programie AddSignalR i można je skonfigurować przy użyciu polecenia AddHubOptions:

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

Zaawansowane opcje konfiguracji PROTOKOŁU HTTP

Służy HttpConnectionDispatcherOptions do konfigurowania ustawień zaawansowanych związanych z transportami i zarządzaniem buforem pamięci. Te opcje są konfigurowane przez przekazanie delegata do MapHub elementu w programie 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;
        });
    });
}

W poniższej tabeli opisano opcje konfigurowania zaawansowanych opcji http platformy ASP.NET Core SignalR:

Transport Long Polling ma dodatkowe opcje, które można skonfigurować przy użyciu LongPolling właściwości :

Transport protokołu WebSocket ma dodatkowe opcje, które można skonfigurować przy użyciu WebSockets właściwości :

Konfigurowanie opcji klienta

Opcje klienta można skonfigurować na typie HubConnectionBuilder (dostępnym na klientach .NET i JavaScript). Jest ona również dostępna w kliencie Java, ale podklasa HttpHubConnectionBuilder zawiera opcje konfiguracji konstruktora, a także na HubConnection samym kliencie.

Konfigurowanie rejestrowania

Rejestrowanie jest konfigurowane w kliencie .NET przy użyciu ConfigureLogging metody . Dostawcy rejestrowania i filtry można zarejestrować w taki sam sposób, jak na serwerze. Aby uzyskać więcej informacji, zobacz dokumentację rejestrowanie w usłudze ASP.NET Core .

Aby na przykład włączyć rejestrowanie konsoli, zainstaluj Microsoft.Extensions.Logging.Console pakiet NuGet. Wywołaj metodę AddConsole rozszerzenia:

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

W kliencie JavaScript istnieje podobna configureLogging metoda. Podaj wartość wskazującą LogLevel minimalny poziom komunikatów dziennika do utworzenia. Dzienniki są zapisywane w oknie konsoli przeglądarki.

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

Aby uzyskać więcej informacji na temat rejestrowania, zobacz dokumentacjęSignalR diagnostyki.

Klient SignalR Java używa biblioteki SLF4J do rejestrowania. Jest to interfejs API rejestrowania wysokiego poziomu, który umożliwia użytkownikom biblioteki wybranie własnej implementacji rejestrowania przez wprowadzenie określonej zależności rejestrowania. Poniższy fragment kodu pokazuje, jak używać go java.util.logging z klientem SignalR Java.

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

Jeśli nie skonfigurujesz rejestrowania w zależnościach, SLF4J ładuje domyślny rejestrator bez operacji z następującym komunikatem ostrzegawczym:

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.

Można to bezpiecznie zignorować.

Konfigurowanie dozwolonych transportów

Transporty używane przez SignalR program można skonfigurować w wywołaniu WithUrl (withUrl w języku JavaScript). Bitowe or wartości parametru HttpTransportType można użyć do ograniczenia klienta do używania tylko określonych transportów. Wszystkie transporty są domyślnie włączone.

Na przykład, aby wyłączyć transport zdarzeń Server-Sent, ale nadal zezwalać na połączenia za pomocą technologii WebSocket i Long Polling:

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

W kliencie JavaScript transporty są konfigurowane przez ustawienie pola transport w obiekcie opcji przekazanym do withUrl:

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

W tej wersji klienta Java WebSockets jest jedynym dostępnym transportem.

Konfigurowanie uwierzytelniania elementu nośnego

Aby udostępnić dane uwierzytelniania wraz z żądaniami SignalR , użyj AccessTokenProvider opcji (accessTokenFactory w języku JavaScript), aby określić funkcję zwracającą żądany token dostępu. W kliencie platformy .NET ten token dostępu jest przekazywany jako token HTTP "Uwierzytelnianie Bearer" (przy użyciu nagłówka Authorization o typie Bearer). W kliencie JavaScript token dostępu jest używany jako Bearer token, z wyjątkiem kilku przypadków, w których interfejsy API przeglądarki ograniczają możliwość stosowania nagłówków (w szczególności w żądaniach Server-Sent Events i WebSockets). W takich przypadkach token dostępu jest udostępniany jako wartość ciągu zapytania access_token.

W kliencie AccessTokenProvider platformy .NET można określić opcję przy użyciu delegata opcji w programie WithUrl:

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

W kliencie JavaScript token dostępu jest konfigurowany przez ustawienie pola accessTokenFactory w obiekcie options w 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();

W kliencie SignalR języka Java można skonfigurować token typu bearer do uwierzytelniania, przekazując fabrykę tokenów dostępu do programu HttpHubConnectionBuilder. Użyj funkcji withAccessTokenFactory, aby udostępnić <. Wywołanie metody Single.defer umożliwia napisanie logiki w celu utworzenia tokenów dostępu dla klienta.

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

Konfiguruj opcje limitu czasu i utrzymywania aktywności

Dodatkowe opcje konfigurowania limitu czasu i zachowania utrzymania aktywności są dostępne bezpośrednio na obiekcie HubConnection.

Konfigurowanie dodatkowych opcji

Dodatkowe opcje można skonfigurować w metodzie WithUrl (withUrl w języku JavaScript) w systemie HubConnectionBuilder lub w różnych interfejsach API konfiguracji w kliencie HttpHubConnectionBuilder Java:

W kliencie platformy .NET opcje te można modyfikować za pomocą delegata opcji przekazanego do WithUrl.

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

W kliencie Języka JavaScript te opcje można podać w obiekcie JavaScript udostępnionym użytkownikowi withUrl:

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

W kliencie Języka Java te opcje można skonfigurować przy użyciu metod zwróconych HttpHubConnectionBuilder z obiektu HubConnectionBuilder.create("HUB URL")

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

Dodatkowe zasoby

• Wprowadzenie do platformy ASP.NET Core SignalR
• Używanie hubów w ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• Klient ASP.NET Core dla platformy .NETSignalR
• Używanie protokołu MessagePack Hub w programie SignalR dla platformy ASP.NET Core
• Obsługiwane platformy ASP.NET Core SignalR

Opcje serializacji JSON/MessagePack

ASP.NET Core SignalR obsługuje dwa protokoły kodowania komunikatów: JSON i MessagePack. Każdy protokół ma opcje konfiguracji serializacji.

Serializację JSON można skonfigurować na serwerze za pomocą metody rozszerzenia AddJsonProtocol. AddJsonProtocol można dodać po AddSignalR w pliku Startup.ConfigureServices. Metoda AddJsonProtocol przyjmuje delegata, który otrzymuje obiekt options. Właściwość PayloadSerializerOptions tego obiektu jest obiektem System.Text.JsonJsonSerializerOptions , który może służyć do konfigurowania serializacji argumentów i zwracanych wartości. Aby uzyskać więcej informacji, zobacz dokumentację System.Text.Json.

Aby na przykład skonfigurować serializator tak, aby nie zmieniał wielkości liter nazw właściwości, zamiast domyślnej notacji camel case, użyj następującego kodu w Startup.ConfigureServices.

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

W kliencie .NET istnieje ta sama metoda rozszerzenia AddJsonProtocol na HubConnectionBuilder. Aby rozwiązać metodę rozszerzenia, należy zaimportować przestrzeń nazw Microsoft.Extensions.DependencyInjection.

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

Przełącz na Newtonsoft.Json

Jeśli potrzebujesz funkcji Newtonsoft.Json, które nie są obsługiwane w System.Text.Json, zajrzyj do Przejdź na Newtonsoft.Json.

Opcje serializacji MessagePack

Można skonfigurować serializację MessagePack, podając delegata do wywołania AddMessagePackProtocol. Aby uzyskać więcej informacji, zobacz MessagePack w pliku SignalR .

Konfigurowanie opcji serwera

W poniższej tabeli opisano opcje konfiguracji koncentratorów SignalR:

Opcje można skonfigurować dla wszystkich centrów, udostępniając delegat opcji do wywołania AddSignalR w programie Startup.ConfigureServices.

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

Opcje pojedynczego koncentratora zastępują opcje globalne dostępne w programie AddSignalR i można je skonfigurować przy użyciu polecenia AddHubOptions:

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

Zaawansowane opcje konfiguracji PROTOKOŁU HTTP

Służy HttpConnectionDispatcherOptions do konfigurowania ustawień zaawansowanych związanych z transportami i zarządzaniem buforem pamięci. Te opcje są konfigurowane przez przekazanie delegata do MapHub elementu w programie 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;
        });
    });
}

W poniższej tabeli opisano opcje konfigurowania zaawansowanych opcji http platformy ASP.NET Core SignalR:

Transport Long Polling ma dodatkowe opcje, które można skonfigurować przy użyciu LongPolling właściwości :

Transport protokołu WebSocket ma dodatkowe opcje, które można skonfigurować przy użyciu WebSockets właściwości :

Konfigurowanie opcji klienta

Opcje klienta można skonfigurować na typie HubConnectionBuilder (dostępnym na klientach .NET i JavaScript). Jest ona również dostępna w kliencie Java, ale podklasa HttpHubConnectionBuilder zawiera opcje konfiguracji konstruktora, a także na HubConnection samym kliencie.

Konfigurowanie rejestrowania

Rejestrowanie jest konfigurowane w kliencie .NET przy użyciu ConfigureLogging metody . Dostawcy rejestrowania i filtry można zarejestrować w taki sam sposób, jak na serwerze. Aby uzyskać więcej informacji, zobacz dokumentację rejestrowanie w usłudze ASP.NET Core .

Aby na przykład włączyć rejestrowanie konsoli, zainstaluj Microsoft.Extensions.Logging.Console pakiet NuGet. Wywołaj metodę AddConsole rozszerzenia:

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

W kliencie JavaScript istnieje podobna configureLogging metoda. Podaj wartość wskazującą LogLevel minimalny poziom komunikatów dziennika do utworzenia. Dzienniki są zapisywane w oknie konsoli przeglądarki.

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

Zamiast wartości LogLevel, można także podać wartość string będącą nazwą poziomu dziennika. Jest to przydatne podczas konfigurowania SignalR rejestrowania w środowiskach, w których nie masz dostępu do LogLevel stałych.

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

W poniższej tabeli wymieniono dostępne poziomy dziennika. Wartość, którą podajesz, ustawia configureLoggingminimalny poziom dziennika, który zostanie zarejestrowany. Komunikaty zarejestrowane na tym poziomie lub poziomy wymienione po niej w tabeli zostaną zarejestrowane.

Aby uzyskać więcej informacji na temat rejestrowania, zobacz dokumentacjęSignalR diagnostyki.

Klient SignalR Java używa biblioteki SLF4J do rejestrowania. Jest to interfejs API rejestrowania wysokiego poziomu, który umożliwia użytkownikom biblioteki wybranie własnej implementacji rejestrowania przez wprowadzenie określonej zależności rejestrowania. Poniższy fragment kodu pokazuje, jak używać go java.util.logging z klientem SignalR Java.

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

Jeśli nie skonfigurujesz rejestrowania w zależnościach, SLF4J ładuje domyślny rejestrator bez operacji z następującym komunikatem ostrzegawczym:

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.

Można to bezpiecznie zignorować.

Konfigurowanie dozwolonych transportów

Transporty używane przez SignalR program można skonfigurować w wywołaniu WithUrl (withUrl w języku JavaScript). Bitowe or wartości parametru HttpTransportType można użyć do ograniczenia klienta do używania tylko określonych transportów. Wszystkie transporty są domyślnie włączone.

Na przykład, aby wyłączyć transport zdarzeń Server-Sent, ale nadal zezwalać na połączenia za pomocą technologii WebSocket i Long Polling:

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

W kliencie JavaScript transporty są konfigurowane przez ustawienie pola transport w obiekcie opcji przekazanym do withUrl:

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

W tej wersji klienta Java WebSockets jest jedynym dostępnym transportem.

W kliencie Java transport jest wybierany przy użyciu withTransport metody w pliku HttpHubConnectionBuilder. Klient Java domyślnie używa transportu WebSocket.

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

Konfigurowanie uwierzytelniania elementu nośnego

Aby udostępnić dane uwierzytelniania wraz z żądaniami SignalR , użyj AccessTokenProvider opcji (accessTokenFactory w języku JavaScript), aby określić funkcję zwracającą żądany token dostępu. W kliencie platformy .NET ten token dostępu jest przekazywany jako token HTTP "Uwierzytelnianie Bearer" (przy użyciu nagłówka Authorization o typie Bearer). W kliencie JavaScript token dostępu jest używany jako Bearer token, z wyjątkiem kilku przypadków, w których interfejsy API przeglądarki ograniczają możliwość stosowania nagłówków (w szczególności w żądaniach Server-Sent Events i WebSockets). W takich przypadkach token dostępu jest udostępniany jako wartość ciągu zapytania access_token.

W kliencie AccessTokenProvider platformy .NET można określić opcję przy użyciu delegata opcji w programie WithUrl:

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

W kliencie JavaScript token dostępu jest konfigurowany przez ustawienie pola accessTokenFactory w obiekcie options w 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();

W kliencie SignalR języka Java można skonfigurować token typu bearer do uwierzytelniania, przekazując fabrykę tokenów dostępu do programu HttpHubConnectionBuilder. Użyj funkcji withAccessTokenFactory, aby udostępnić <. Wywołanie metody Single.defer umożliwia napisanie logiki w celu utworzenia tokenów dostępu dla klienta.

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

Konfiguruj opcje limitu czasu i utrzymywania aktywności

Dodatkowe opcje konfigurowania limitu czasu i zachowania utrzymania aktywności są dostępne bezpośrednio na obiekcie HubConnection.

Konfigurowanie dodatkowych opcji

Dodatkowe opcje można skonfigurować w metodzie WithUrl (withUrl w języku JavaScript) w systemie HubConnectionBuilder lub w różnych interfejsach API konfiguracji w kliencie HttpHubConnectionBuilder Java:

W kliencie platformy .NET opcje te można modyfikować za pomocą delegata opcji przekazanego do WithUrl.

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

W kliencie Języka JavaScript te opcje można podać w obiekcie JavaScript udostępnionym użytkownikowi withUrl:

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

W kliencie Języka Java te opcje można skonfigurować przy użyciu metod zwróconych HttpHubConnectionBuilder z obiektu HubConnectionBuilder.create("HUB URL")

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

Dodatkowe zasoby

• Wprowadzenie do platformy ASP.NET Core SignalR
• Używanie hubów w ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• Klient ASP.NET Core dla platformy .NETSignalR
• Używanie protokołu MessagePack Hub w programie SignalR dla platformy ASP.NET Core
• Obsługiwane platformy ASP.NET Core SignalR

Opcje serializacji JSON/MessagePack

ASP.NET Core SignalR obsługuje dwa protokoły kodowania komunikatów: JSON i MessagePack. Każdy protokół ma opcje konfiguracji serializacji.

Serializację JSON można skonfigurować na serwerze za pomocą metody rozszerzenia AddJsonProtocol. AddJsonProtocol można dodać po AddSignalR w pliku Startup.ConfigureServices. Metoda AddJsonProtocol przyjmuje delegata, który otrzymuje obiekt options. Właściwość PayloadSerializerOptions tego obiektu jest obiektem System.Text.JsonJsonSerializerOptions , który może służyć do konfigurowania serializacji argumentów i zwracanych wartości. Aby uzyskać więcej informacji, zobacz dokumentację System.Text.Json.

Aby na przykład skonfigurować serializator tak, aby nie zmieniał wielkości liter nazw właściwości, zamiast domyślnej notacji camel case, użyj następującego kodu w Startup.ConfigureServices.

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

W kliencie .NET istnieje ta sama metoda rozszerzenia AddJsonProtocol na HubConnectionBuilder. Aby rozwiązać metodę rozszerzenia, należy zaimportować przestrzeń nazw Microsoft.Extensions.DependencyInjection.

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

Przełącz na Newtonsoft.Json

Jeśli potrzebujesz funkcji Newtonsoft.Json, które nie są obsługiwane w System.Text.Json, zajrzyj do Przejdź na Newtonsoft.Json.

Opcje serializacji MessagePack

Można skonfigurować serializację MessagePack, podając delegata do wywołania AddMessagePackProtocol. Aby uzyskać więcej informacji, zobacz MessagePack w pliku SignalR .

Konfigurowanie opcji serwera

W poniższej tabeli opisano opcje konfiguracji koncentratorów SignalR:

Opcje można skonfigurować dla wszystkich centrów, udostępniając delegat opcji do wywołania AddSignalR w programie Startup.ConfigureServices.

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

Opcje pojedynczego koncentratora zastępują opcje globalne dostępne w programie AddSignalR i można je skonfigurować przy użyciu polecenia AddHubOptions:

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

Zaawansowane opcje konfiguracji PROTOKOŁU HTTP

Służy HttpConnectionDispatcherOptions do konfigurowania ustawień zaawansowanych związanych z transportami i zarządzaniem buforem pamięci. Te opcje są konfigurowane przez przekazanie delegata do MapHub elementu w programie 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;
        });
    });
}

W poniższej tabeli opisano opcje konfigurowania zaawansowanych opcji http platformy ASP.NET Core SignalR:

Transport Long Polling ma dodatkowe opcje, które można skonfigurować przy użyciu LongPolling właściwości :

Transport protokołu WebSocket ma dodatkowe opcje, które można skonfigurować przy użyciu WebSockets właściwości :

Konfigurowanie opcji klienta

Opcje klienta można skonfigurować na typie HubConnectionBuilder (dostępnym na klientach .NET i JavaScript). Jest ona również dostępna w kliencie Java, ale podklasa HttpHubConnectionBuilder zawiera opcje konfiguracji konstruktora, a także na HubConnection samym kliencie.

Konfigurowanie rejestrowania

Rejestrowanie jest konfigurowane w kliencie .NET przy użyciu ConfigureLogging metody . Dostawcy rejestrowania i filtry można zarejestrować w taki sam sposób, jak na serwerze. Aby uzyskać więcej informacji, zobacz dokumentację rejestrowanie w usłudze ASP.NET Core .

Aby na przykład włączyć rejestrowanie konsoli, zainstaluj Microsoft.Extensions.Logging.Console pakiet NuGet. Wywołaj metodę AddConsole rozszerzenia:

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

W kliencie JavaScript istnieje podobna configureLogging metoda. Podaj wartość wskazującą LogLevel minimalny poziom komunikatów dziennika do utworzenia. Dzienniki są zapisywane w oknie konsoli przeglądarki.

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

Zamiast wartości LogLevel, można także podać wartość string będącą nazwą poziomu dziennika. Jest to przydatne podczas konfigurowania SignalR rejestrowania w środowiskach, w których nie masz dostępu do LogLevel stałych.

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

W poniższej tabeli wymieniono dostępne poziomy dziennika. Wartość, którą podajesz, ustawia configureLoggingminimalny poziom dziennika, który zostanie zarejestrowany. Komunikaty zarejestrowane na tym poziomie lub poziomy wymienione po niej w tabeli zostaną zarejestrowane.

Aby uzyskać więcej informacji na temat rejestrowania, zobacz dokumentacjęSignalR diagnostyki.

Klient SignalR Java używa biblioteki SLF4J do rejestrowania. Jest to interfejs API rejestrowania wysokiego poziomu, który umożliwia użytkownikom biblioteki wybranie własnej implementacji rejestrowania przez wprowadzenie określonej zależności rejestrowania. Poniższy fragment kodu pokazuje, jak używać go java.util.logging z klientem SignalR Java.

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

Jeśli nie skonfigurujesz rejestrowania w zależnościach, SLF4J ładuje domyślny rejestrator bez operacji z następującym komunikatem ostrzegawczym:

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.

Można to bezpiecznie zignorować.

Konfigurowanie dozwolonych transportów

Transporty używane przez SignalR program można skonfigurować w wywołaniu WithUrl (withUrl w języku JavaScript). Bitowe or wartości parametru HttpTransportType można użyć do ograniczenia klienta do używania tylko określonych transportów. Wszystkie transporty są domyślnie włączone.

Na przykład, aby wyłączyć transport zdarzeń Server-Sent, ale nadal zezwalać na połączenia za pomocą technologii WebSocket i Long Polling:

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

W kliencie JavaScript transporty są konfigurowane przez ustawienie pola transport w obiekcie opcji przekazanym do withUrl:

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

W tej wersji klienta Java WebSockets jest jedynym dostępnym transportem.

W kliencie Java transport jest wybierany przy użyciu withTransport metody w pliku HttpHubConnectionBuilder. Klient Java domyślnie używa transportu WebSocket.

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

Konfigurowanie uwierzytelniania elementu nośnego

Aby udostępnić dane uwierzytelniania wraz z żądaniami SignalR , użyj AccessTokenProvider opcji (accessTokenFactory w języku JavaScript), aby określić funkcję zwracającą żądany token dostępu. W kliencie platformy .NET ten token dostępu jest przekazywany jako token HTTP "Uwierzytelnianie Bearer" (przy użyciu nagłówka Authorization o typie Bearer). W kliencie JavaScript token dostępu jest używany jako Bearer token, z wyjątkiem kilku przypadków, w których interfejsy API przeglądarki ograniczają możliwość stosowania nagłówków (w szczególności w żądaniach Server-Sent Events i WebSockets). W takich przypadkach token dostępu jest udostępniany jako wartość ciągu zapytania access_token.

W kliencie AccessTokenProvider platformy .NET można określić opcję przy użyciu delegata opcji w programie WithUrl:

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

W kliencie JavaScript token dostępu jest konfigurowany przez ustawienie pola accessTokenFactory w obiekcie options w 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();

W kliencie SignalR języka Java można skonfigurować token typu bearer do uwierzytelniania, przekazując fabrykę tokenów dostępu do programu HttpHubConnectionBuilder. Użyj funkcji withAccessTokenFactory, aby udostępnić <. Wywołanie metody Single.defer umożliwia napisanie logiki w celu utworzenia tokenów dostępu dla klienta.

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

Konfiguruj opcje limitu czasu i utrzymywania aktywności

Dodatkowe opcje konfigurowania limitu czasu i zachowania utrzymania aktywności są dostępne bezpośrednio na obiekcie HubConnection.

Konfigurowanie dodatkowych opcji

Dodatkowe opcje można skonfigurować w metodzie WithUrl (withUrl w języku JavaScript) w systemie HubConnectionBuilder lub w różnych interfejsach API konfiguracji w kliencie HttpHubConnectionBuilder Java:

W kliencie platformy .NET opcje te można modyfikować za pomocą delegata opcji przekazanego do WithUrl.

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

W kliencie Języka JavaScript te opcje można podać w obiekcie JavaScript udostępnionym użytkownikowi withUrl:

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

W kliencie Języka Java te opcje można skonfigurować przy użyciu metod zwróconych HttpHubConnectionBuilder z obiektu HubConnectionBuilder.create("HUB URL")

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

Dodatkowe zasoby

• Wprowadzenie do platformy ASP.NET Core SignalR
• Używanie hubów w ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• Klient ASP.NET Core dla platformy .NETSignalR
• Używanie protokołu MessagePack Hub w programie SignalR dla platformy ASP.NET Core
• Obsługiwane platformy ASP.NET Core SignalR

Opcje serializacji JSON/MessagePack

ASP.NET Core SignalR obsługuje dwa protokoły kodowania komunikatów: JSON i MessagePack. Każdy protokół ma opcje konfiguracji serializacji.

Serializację JSON można skonfigurować na serwerze za pomocą metody rozszerzenia AddJsonProtocol. AddJsonProtocol można dodać po AddSignalR w pliku Startup.ConfigureServices. Metoda AddJsonProtocol przyjmuje delegata, który otrzymuje obiekt options. Właściwość PayloadSerializerOptions tego obiektu jest obiektem System.Text.JsonJsonSerializerOptions , który może służyć do konfigurowania serializacji argumentów i zwracanych wartości. Aby uzyskać więcej informacji, zobacz dokumentację System.Text.Json.

Aby na przykład skonfigurować serializator tak, aby nie zmieniał wielkości liter nazw właściwości, zamiast domyślnej notacji camel case, użyj następującego kodu w Startup.ConfigureServices.

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

W kliencie .NET istnieje ta sama metoda rozszerzenia AddJsonProtocol na HubConnectionBuilder. Aby rozwiązać metodę rozszerzenia, należy zaimportować przestrzeń nazw Microsoft.Extensions.DependencyInjection.

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

Przełącz na Newtonsoft.Json

Jeśli potrzebujesz funkcji Newtonsoft.Json, które nie są obsługiwane w System.Text.Json, zajrzyj do Przejdź na Newtonsoft.Json.

Opcje serializacji MessagePack

Można skonfigurować serializację MessagePack, podając delegata do wywołania AddMessagePackProtocol. Aby uzyskać więcej informacji, zobacz MessagePack w pliku SignalR .

Konfigurowanie opcji serwera

W poniższej tabeli opisano opcje konfiguracji koncentratorów SignalR:

Opcje można skonfigurować dla wszystkich centrów, udostępniając delegat opcji do wywołania AddSignalR w programie Startup.ConfigureServices.

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

Opcje pojedynczego koncentratora zastępują opcje globalne dostępne w programie AddSignalR i można je skonfigurować przy użyciu polecenia AddHubOptions:

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

Zaawansowane opcje konfiguracji PROTOKOŁU HTTP

Służy HttpConnectionDispatcherOptions do konfigurowania ustawień zaawansowanych związanych z transportami i zarządzaniem buforem pamięci. Te opcje są konfigurowane przez przekazanie delegata do MapHub elementu w programie 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;
        });
    });
}

W poniższej tabeli opisano opcje konfigurowania zaawansowanych opcji http platformy ASP.NET Core SignalR:

Transport Long Polling ma dodatkowe opcje, które można skonfigurować przy użyciu LongPolling właściwości :

Transport protokołu WebSocket ma dodatkowe opcje, które można skonfigurować przy użyciu WebSockets właściwości :

Konfigurowanie opcji klienta

Opcje klienta można skonfigurować na typie HubConnectionBuilder (dostępnym na klientach .NET i JavaScript). Jest ona również dostępna w kliencie Java, ale podklasa HttpHubConnectionBuilder zawiera opcje konfiguracji konstruktora, a także na HubConnection samym kliencie.

Konfigurowanie rejestrowania

Rejestrowanie jest konfigurowane w kliencie .NET przy użyciu ConfigureLogging metody . Dostawcy rejestrowania i filtry można zarejestrować w taki sam sposób, jak na serwerze. Aby uzyskać więcej informacji, zobacz dokumentację rejestrowanie w usłudze ASP.NET Core .

Aby na przykład włączyć rejestrowanie konsoli, zainstaluj Microsoft.Extensions.Logging.Console pakiet NuGet. Wywołaj metodę AddConsole rozszerzenia:

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

W kliencie JavaScript istnieje podobna configureLogging metoda. Podaj wartość wskazującą LogLevel minimalny poziom komunikatów dziennika do utworzenia. Dzienniki są zapisywane w oknie konsoli przeglądarki.

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

Zamiast wartości LogLevel, można także podać wartość string będącą nazwą poziomu dziennika. Jest to przydatne podczas konfigurowania SignalR rejestrowania w środowiskach, w których nie masz dostępu do LogLevel stałych.

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

W poniższej tabeli wymieniono dostępne poziomy dziennika. Wartość, którą podajesz, ustawia configureLoggingminimalny poziom dziennika, który zostanie zarejestrowany. Komunikaty zarejestrowane na tym poziomie lub poziomy wymienione po niej w tabeli zostaną zarejestrowane.

Aby uzyskać więcej informacji na temat rejestrowania, zobacz dokumentacjęSignalR diagnostyki.

Klient SignalR Java używa biblioteki SLF4J do rejestrowania. Jest to interfejs API rejestrowania wysokiego poziomu, który umożliwia użytkownikom biblioteki wybranie własnej implementacji rejestrowania przez wprowadzenie określonej zależności rejestrowania. Poniższy fragment kodu pokazuje, jak używać go java.util.logging z klientem SignalR Java.

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

Jeśli nie skonfigurujesz rejestrowania w zależnościach, SLF4J ładuje domyślny rejestrator bez operacji z następującym komunikatem ostrzegawczym:

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.

Można to bezpiecznie zignorować.

Konfigurowanie dozwolonych transportów

Transporty używane przez SignalR program można skonfigurować w wywołaniu WithUrl (withUrl w języku JavaScript). Bitowe or wartości parametru HttpTransportType można użyć do ograniczenia klienta do używania tylko określonych transportów. Wszystkie transporty są domyślnie włączone.

Na przykład, aby wyłączyć transport zdarzeń Server-Sent, ale nadal zezwalać na połączenia za pomocą technologii WebSocket i Long Polling:

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

W kliencie JavaScript transporty są konfigurowane przez ustawienie pola transport w obiekcie opcji przekazanym do withUrl:

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

W tej wersji klienta Java WebSockets jest jedynym dostępnym transportem.

W kliencie Java transport jest wybierany przy użyciu withTransport metody w pliku HttpHubConnectionBuilder. Klient Java domyślnie używa transportu WebSocket.

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

Konfigurowanie uwierzytelniania elementu nośnego

Aby udostępnić dane uwierzytelniania wraz z żądaniami SignalR , użyj AccessTokenProvider opcji (accessTokenFactory w języku JavaScript), aby określić funkcję zwracającą żądany token dostępu. W kliencie platformy .NET ten token dostępu jest przekazywany jako token HTTP "Uwierzytelnianie Bearer" (przy użyciu nagłówka Authorization o typie Bearer). W kliencie JavaScript token dostępu jest używany jako Bearer token, z wyjątkiem kilku przypadków, w których interfejsy API przeglądarki ograniczają możliwość stosowania nagłówków (w szczególności w żądaniach Server-Sent Events i WebSockets). W takich przypadkach token dostępu jest udostępniany jako wartość ciągu zapytania access_token.

W kliencie AccessTokenProvider platformy .NET można określić opcję przy użyciu delegata opcji w programie WithUrl:

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

W kliencie JavaScript token dostępu jest konfigurowany przez ustawienie pola accessTokenFactory w obiekcie options w 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();

W kliencie SignalR języka Java można skonfigurować token typu bearer do uwierzytelniania, przekazując fabrykę tokenów dostępu do programu HttpHubConnectionBuilder. Użyj funkcji withAccessTokenFactory, aby udostępnić <. Wywołanie metody Single.defer umożliwia napisanie logiki w celu utworzenia tokenów dostępu dla klienta.

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

Konfiguruj opcje limitu czasu i utrzymywania aktywności

Dodatkowe opcje konfigurowania limitu czasu i zachowania utrzymania aktywności są dostępne bezpośrednio na obiekcie HubConnection.

Konfigurowanie dodatkowych opcji

Dodatkowe opcje można skonfigurować w metodzie WithUrl (withUrl w języku JavaScript) w systemie HubConnectionBuilder lub w różnych interfejsach API konfiguracji w kliencie HttpHubConnectionBuilder Java:

W kliencie platformy .NET opcje te można modyfikować za pomocą delegata opcji przekazanego do WithUrl.

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

W kliencie Języka JavaScript te opcje można podać w obiekcie JavaScript udostępnionym użytkownikowi withUrl:

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub", {
        // "Foo: Bar" will not be sent with WebSockets or Server-Sent Events requests
        headers: { "Foo": "Bar" },
        transport: signalR.HttpTransportType.LongPolling 
    })
    .build();

W kliencie Języka Java te opcje można skonfigurować przy użyciu metod zwróconych HttpHubConnectionBuilder z obiektu HubConnectionBuilder.create("HUB URL")

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

Dodatkowe zasoby

• Wprowadzenie do platformy ASP.NET Core SignalR
• Używanie hubów w ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• Klient ASP.NET Core dla platformy .NETSignalR
• Używanie protokołu MessagePack Hub w programie SignalR dla platformy ASP.NET Core
• Obsługiwane platformy ASP.NET Core SignalR

Opcje serializacji JSON/MessagePack

ASP.NET Core SignalR obsługuje dwa protokoły kodowania komunikatów: JSON i MessagePack. Każdy protokół ma opcje konfiguracji serializacji.

Serializację JSON można skonfigurować na serwerze za pomocą metody rozszerzenia AddJsonProtocol. AddJsonProtocol można dodać po AddSignalR w pliku Program.cs. Metoda AddJsonProtocol przyjmuje delegata, który otrzymuje obiekt options. Właściwość PayloadSerializerOptions tego obiektu jest obiektem System.Text.JsonJsonSerializerOptions , który może służyć do konfigurowania serializacji argumentów i zwracanych wartości. Aby uzyskać więcej informacji, zobacz dokumentację System.Text.Json.

Aby na przykład skonfigurować serializator tak, aby nie zmieniał wielkości liter nazw właściwości, zamiast domyślnej notacji camel case, użyj następującego kodu w Program.cs.

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

W kliencie .NET istnieje ta sama metoda rozszerzenia AddJsonProtocol na HubConnectionBuilder. Aby rozwiązać metodę rozszerzenia, należy zaimportować przestrzeń nazw Microsoft.Extensions.DependencyInjection.

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

Przełącz na Newtonsoft.Json

Jeśli potrzebujesz funkcji Newtonsoft.Json, które nie są obsługiwane w System.Text.Json, zajrzyj do Przejdź na Newtonsoft.Json.

Opcje serializacji MessagePack

Można skonfigurować serializację MessagePack, podając delegata do wywołania AddMessagePackProtocol. Aby uzyskać więcej informacji, zobacz MessagePack w pliku SignalR .

Konfigurowanie opcji serwera

W poniższej tabeli opisano opcje konfiguracji koncentratorów SignalR:

Opcje można skonfigurować dla wszystkich centrów, udostępniając delegat opcji do wywołania AddSignalR w programie Program.cs.

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

Opcje pojedynczego koncentratora zastępują opcje globalne dostępne w programie AddSignalR i można je skonfigurować przy użyciu polecenia AddHubOptions:

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

Zaawansowane opcje konfiguracji PROTOKOŁU HTTP

Służy HttpConnectionDispatcherOptions do konfigurowania ustawień zaawansowanych związanych z transportami i zarządzaniem buforem pamięci. Te opcje są konfigurowane przez przekazanie delegata do MapHub elementu w programie 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();

W poniższej tabeli opisano opcje konfigurowania zaawansowanych opcji http platformy ASP.NET Core SignalR:

Transport Long Polling ma dodatkowe opcje, które można skonfigurować przy użyciu LongPolling właściwości :

Transport protokołu WebSocket ma dodatkowe opcje, które można skonfigurować przy użyciu WebSockets właściwości :

Konfigurowanie opcji klienta

Opcje klienta można skonfigurować na typie HubConnectionBuilder (dostępnym na klientach .NET i JavaScript). Jest ona również dostępna w kliencie Java, ale podklasa HttpHubConnectionBuilder zawiera opcje konfiguracji konstruktora, a także na HubConnection samym kliencie.

Konfigurowanie rejestrowania

Rejestrowanie jest konfigurowane w kliencie .NET przy użyciu ConfigureLogging metody . Dostawcy rejestrowania i filtry można zarejestrować w taki sam sposób, jak na serwerze. Aby uzyskać więcej informacji, zobacz dokumentację rejestrowanie w usłudze ASP.NET Core .

Aby na przykład włączyć rejestrowanie konsoli, zainstaluj Microsoft.Extensions.Logging.Console pakiet NuGet. Wywołaj metodę AddConsole rozszerzenia:

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

W kliencie JavaScript istnieje podobna configureLogging metoda. Podaj wartość wskazującą LogLevel minimalny poziom komunikatów dziennika do utworzenia. Dzienniki są zapisywane w oknie konsoli przeglądarki.

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

Zamiast wartości LogLevel, można także podać wartość string będącą nazwą poziomu dziennika. Jest to przydatne podczas konfigurowania SignalR rejestrowania w środowiskach, w których nie masz dostępu do LogLevel stałych.

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

W poniższej tabeli wymieniono dostępne poziomy dziennika. Wartość, którą podajesz, ustawia configureLoggingminimalny poziom dziennika, który zostanie zarejestrowany. Komunikaty zarejestrowane na tym poziomie lub poziomy wymienione po niej w tabeli zostaną zarejestrowane.

Aby uzyskać więcej informacji na temat rejestrowania, zobacz dokumentacjęSignalR diagnostyki.

Klient SignalR Java używa biblioteki SLF4J do rejestrowania. Jest to interfejs API rejestrowania wysokiego poziomu, który umożliwia użytkownikom biblioteki wybranie własnej implementacji rejestrowania przez wprowadzenie określonej zależności rejestrowania. Poniższy fragment kodu pokazuje, jak używać go java.util.logging z klientem SignalR Java.

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

Jeśli nie skonfigurujesz rejestrowania w zależnościach, SLF4J ładuje domyślny rejestrator bez operacji z następującym komunikatem ostrzegawczym:

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.

Można to bezpiecznie zignorować.

Konfigurowanie dozwolonych transportów

Transporty używane przez SignalR program można skonfigurować w wywołaniu WithUrl (withUrl w języku JavaScript). Bitowe or wartości parametru HttpTransportType można użyć do ograniczenia klienta do używania tylko określonych transportów. Wszystkie transporty są domyślnie włączone.

Na przykład, aby wyłączyć transport zdarzeń Server-Sent, ale nadal zezwalać na połączenia za pomocą technologii WebSocket i Long Polling:

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

W kliencie JavaScript transporty są konfigurowane przez ustawienie pola transport w obiekcie opcji przekazanym do withUrl:

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

W tej wersji klienta Java WebSockets jest jedynym dostępnym transportem.

W kliencie Java transport jest wybierany przy użyciu withTransport metody w pliku HttpHubConnectionBuilder. Klient Java domyślnie używa transportu WebSocket.

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

Konfigurowanie uwierzytelniania elementu nośnego

Aby udostępnić dane uwierzytelniania wraz z żądaniami SignalR , użyj AccessTokenProvider opcji (accessTokenFactory w języku JavaScript), aby określić funkcję zwracającą żądany token dostępu. W kliencie platformy .NET ten token dostępu jest przekazywany jako token HTTP "Uwierzytelnianie Bearer" (przy użyciu nagłówka Authorization o typie Bearer). W kliencie JavaScript token dostępu jest używany jako Bearer token, z wyjątkiem kilku przypadków, w których interfejsy API przeglądarki ograniczają możliwość stosowania nagłówków (w szczególności w żądaniach Server-Sent Events i WebSockets). W takich przypadkach token dostępu jest udostępniany jako wartość ciągu zapytania access_token.

W kliencie AccessTokenProvider platformy .NET można określić opcję przy użyciu delegata opcji w programie WithUrl:

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

W kliencie JavaScript token dostępu jest konfigurowany przez ustawienie pola accessTokenFactory w obiekcie options w 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();

W kliencie SignalR języka Java można skonfigurować token typu bearer do uwierzytelniania, przekazując fabrykę tokenów dostępu do programu HttpHubConnectionBuilder. Użyj funkcji withAccessTokenFactory, aby udostępnić <. Wywołanie metody Single.defer umożliwia napisanie logiki w celu utworzenia tokenów dostępu dla klienta.

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

Konfiguruj opcje limitu czasu i utrzymywania aktywności

Dodatkowe opcje konfigurowania limitu czasu i zachowania utrzymania aktywności są dostępne bezpośrednio na obiekcie HubConnection.

Konfigurowanie dodatkowych opcji

Dodatkowe opcje można skonfigurować w metodzie WithUrl (withUrl w języku JavaScript) w systemie HubConnectionBuilder lub w różnych interfejsach API konfiguracji w kliencie HttpHubConnectionBuilder Java:

W kliencie platformy .NET opcje te można modyfikować za pomocą delegata opcji przekazanego do WithUrl.

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

W kliencie Języka JavaScript te opcje można podać w obiekcie JavaScript udostępnionym użytkownikowi withUrl:

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub", {
        // "Foo: Bar" will not be sent with WebSockets or Server-Sent Events requests
        headers: { "Foo": "Bar" },
        transport: signalR.HttpTransportType.LongPolling 
    })
    .build();

W kliencie Języka Java te opcje można skonfigurować przy użyciu metod zwróconych HttpHubConnectionBuilder z obiektu HubConnectionBuilder.create("HUB URL")

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

Dodatkowe zasoby

• Wprowadzenie do platformy ASP.NET Core SignalR
• Używanie hubów w ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• Klient ASP.NET Core dla platformy .NETSignalR
• Używanie protokołu MessagePack Hub w programie SignalR dla platformy ASP.NET Core
• Obsługiwane platformy ASP.NET Core SignalR

Opcje serializacji JSON/MessagePack

ASP.NET Core SignalR obsługuje dwa protokoły kodowania komunikatów: JSON i MessagePack. Każdy protokół ma opcje konfiguracji serializacji.

Serializację JSON można skonfigurować na serwerze za pomocą metody rozszerzenia AddJsonProtocol. AddJsonProtocol można dodać po AddSignalR w pliku Startup.ConfigureServices. Metoda AddJsonProtocol przyjmuje delegata, który otrzymuje obiekt options. Właściwość PayloadSerializerOptions tego obiektu jest obiektem System.Text.JsonJsonSerializerOptions , który może służyć do konfigurowania serializacji argumentów i zwracanych wartości. Aby uzyskać więcej informacji, zobacz dokumentację System.Text.Json.

Aby na przykład skonfigurować serializator tak, aby nie zmieniał wielkości liter nazw właściwości, zamiast domyślnej notacji camel case, użyj następującego kodu w Program.cs.

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

W kliencie .NET istnieje ta sama metoda rozszerzenia AddJsonProtocol na HubConnectionBuilder. Aby rozwiązać metodę rozszerzenia, należy zaimportować przestrzeń nazw Microsoft.Extensions.DependencyInjection.

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

Przełącz na Newtonsoft.Json

Jeśli potrzebujesz funkcji Newtonsoft.Json, które nie są obsługiwane w System.Text.Json, zajrzyj do Przejdź na Newtonsoft.Json.

Opcje serializacji MessagePack

Można skonfigurować serializację MessagePack, podając delegata do wywołania AddMessagePackProtocol. Aby uzyskać więcej informacji, zobacz MessagePack w pliku SignalR .

Konfigurowanie opcji serwera

W poniższej tabeli opisano opcje konfiguracji koncentratorów SignalR:

Opcje można skonfigurować dla wszystkich centrów, udostępniając delegat opcji do wywołania AddSignalR w programie Program.cs.

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

Opcje pojedynczego koncentratora zastępują opcje globalne dostępne w programie AddSignalR i można je skonfigurować przy użyciu polecenia AddHubOptions:

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

Zaawansowane opcje konfiguracji PROTOKOŁU HTTP

Służy HttpConnectionDispatcherOptions do konfigurowania ustawień zaawansowanych związanych z transportami i zarządzaniem buforem pamięci. Te opcje są konfigurowane przez przekazanie delegata do MapHub elementu w programie 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();

W poniższej tabeli opisano opcje konfigurowania zaawansowanych opcji http platformy ASP.NET Core SignalR:

Transport Long Polling ma dodatkowe opcje, które można skonfigurować przy użyciu LongPolling właściwości :

Transport protokołu WebSocket ma dodatkowe opcje, które można skonfigurować przy użyciu WebSockets właściwości :

Konfigurowanie opcji klienta

Opcje klienta można skonfigurować na typie HubConnectionBuilder (dostępnym na klientach .NET i JavaScript). Jest ona również dostępna w kliencie Java, ale podklasa HttpHubConnectionBuilder zawiera opcje konfiguracji konstruktora, a także na HubConnection samym kliencie.

Konfigurowanie rejestrowania

Rejestrowanie jest konfigurowane w kliencie .NET przy użyciu ConfigureLogging metody . Dostawcy rejestrowania i filtry można zarejestrować w taki sam sposób, jak na serwerze. Aby uzyskać więcej informacji, zobacz dokumentację rejestrowanie w usłudze ASP.NET Core .

Aby na przykład włączyć rejestrowanie konsoli, zainstaluj Microsoft.Extensions.Logging.Console pakiet NuGet. Wywołaj metodę AddConsole rozszerzenia:

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

W kliencie JavaScript istnieje podobna configureLogging metoda. Podaj wartość wskazującą LogLevel minimalny poziom komunikatów dziennika do utworzenia. Dzienniki są zapisywane w oknie konsoli przeglądarki.

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

Zamiast wartości LogLevel, można także podać wartość string będącą nazwą poziomu dziennika. Jest to przydatne podczas konfigurowania SignalR rejestrowania w środowiskach, w których nie masz dostępu do LogLevel stałych.

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

W poniższej tabeli wymieniono dostępne poziomy dziennika. Wartość, którą podajesz, ustawia configureLoggingminimalny poziom dziennika, który zostanie zarejestrowany. Komunikaty zarejestrowane na tym poziomie lub poziomy wymienione po niej w tabeli zostaną zarejestrowane.

Aby uzyskać więcej informacji na temat rejestrowania, zobacz dokumentacjęSignalR diagnostyki.

Klient SignalR Java używa biblioteki SLF4J do rejestrowania. Jest to interfejs API rejestrowania wysokiego poziomu, który umożliwia użytkownikom biblioteki wybranie własnej implementacji rejestrowania przez wprowadzenie określonej zależności rejestrowania. Poniższy fragment kodu pokazuje, jak używać go java.util.logging z klientem SignalR Java.

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

Jeśli nie skonfigurujesz rejestrowania w zależnościach, SLF4J ładuje domyślny rejestrator bez operacji z następującym komunikatem ostrzegawczym:

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.

Można to bezpiecznie zignorować.

Konfigurowanie dozwolonych transportów

Transporty używane przez SignalR program można skonfigurować w wywołaniu WithUrl (withUrl w języku JavaScript). Bitowe or wartości parametru HttpTransportType można użyć do ograniczenia klienta do używania tylko określonych transportów. Wszystkie transporty są domyślnie włączone.

Na przykład, aby wyłączyć transport zdarzeń Server-Sent, ale nadal zezwalać na połączenia za pomocą technologii WebSocket i Long Polling:

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

W kliencie JavaScript transporty są konfigurowane przez ustawienie pola transport w obiekcie opcji przekazanym do withUrl:

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

W tej wersji klienta Java WebSockets jest jedynym dostępnym transportem.

W kliencie Java transport jest wybierany przy użyciu withTransport metody w pliku HttpHubConnectionBuilder. Klient Java domyślnie używa transportu WebSocket.

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

Konfigurowanie uwierzytelniania elementu nośnego

Aby udostępnić dane uwierzytelniania wraz z żądaniami SignalR , użyj AccessTokenProvider opcji (accessTokenFactory w języku JavaScript), aby określić funkcję zwracającą żądany token dostępu. W kliencie platformy .NET ten token dostępu jest przekazywany jako token HTTP "Uwierzytelnianie Bearer" (przy użyciu nagłówka Authorization o typie Bearer). W kliencie JavaScript token dostępu jest używany jako Bearer token, z wyjątkiem kilku przypadków, w których interfejsy API przeglądarki ograniczają możliwość stosowania nagłówków (w szczególności w żądaniach Server-Sent Events i WebSockets). W takich przypadkach token dostępu jest udostępniany jako wartość ciągu zapytania access_token.

W kliencie AccessTokenProvider platformy .NET można określić opcję przy użyciu delegata opcji w programie WithUrl:

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

W kliencie JavaScript token dostępu jest konfigurowany przez ustawienie pola accessTokenFactory w obiekcie options w 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();

W kliencie SignalR języka Java można skonfigurować token typu bearer do uwierzytelniania, przekazując fabrykę tokenów dostępu do programu HttpHubConnectionBuilder. Użyj funkcji withAccessTokenFactory, aby udostępnić <. Wywołanie metody Single.defer umożliwia napisanie logiki w celu utworzenia tokenów dostępu dla klienta.

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

Konfiguruj opcje limitu czasu i utrzymywania aktywności

Dodatkowe opcje konfigurowania limitu czasu i zachowania utrzymania aktywności są dostępne bezpośrednio na obiekcie HubConnection.

Konfigurowanie dodatkowych opcji

Dodatkowe opcje można skonfigurować w metodzie WithUrl (withUrl w języku JavaScript) w systemie HubConnectionBuilder lub w różnych interfejsach API konfiguracji w kliencie HttpHubConnectionBuilder Java:

W kliencie platformy .NET opcje te można modyfikować za pomocą delegata opcji przekazanego do WithUrl.

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

W kliencie Języka JavaScript te opcje można podać w obiekcie JavaScript udostępnionym użytkownikowi withUrl:

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chathub", {
        // "Foo: Bar" will not be sent with WebSockets or Server-Sent Events requests
        headers: { "Foo": "Bar" },
        transport: signalR.HttpTransportType.LongPolling 
    })
    .build();

W kliencie Języka Java te opcje można skonfigurować przy użyciu metod zwróconych HttpHubConnectionBuilder z obiektu HubConnectionBuilder.create("HUB URL")

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

Dodatkowe zasoby

• Wprowadzenie do platformy ASP.NET Core SignalR
• Używanie hubów w ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript client
• Klient ASP.NET Core dla platformy .NETSignalR
• Używanie protokołu MessagePack Hub w programie SignalR dla platformy ASP.NET Core
• Obsługiwane platformy ASP.NET Core SignalR