konfiguration av ASP.NET Core SignalR

Serialiseringsalternativ för JSON/MessagePack

ASP.NET Core SignalR stöder två protokoll för kodning av meddelanden: JSON och MessagePack. Varje protokoll har konfigurationsalternativ för serialisering.

JSON-serialisering kan konfigureras på servern med hjälp av AddJsonProtocol tilläggsmetoden. AddJsonProtocol kan läggas till efter AddSignalR i Startup.ConfigureServices. Metoden AddJsonProtocol tar en delegat som tar emot ett options objekt. Egenskapen PayloadSerializerOptions för objektet är ett System.Text.JsonJsonSerializerOptions objekt som kan användas för att konfigurera serialisering av argument och returvärden. Mer information finns i dokumentationen om System.Text.Json.

Om du till exempel vill konfigurera serialiseraren så att den inte ändrar versaliseringen för egenskapsnamn, i stället för standardnamnen för kamelfall, använder du följande kod i Program.cs:

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

I .NET-klienten finns samma AddJsonProtocol tilläggsmetod på HubConnectionBuilder. Namnområdet Microsoft.Extensions.DependencyInjection måste importeras för att matcha tilläggsmetoden:

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

Växla till Newtonsoft.Json

Om du behöver funktioner i Newtonsoft.Json som inte stöds i System.Text.Json, kan du se Växla till Newtonsoft.Json.

Serialiseringsalternativ för MessagePack

MessagePack-serialisering kan konfigureras genom att tillhandahålla ett ombud för anropet AddMessagePackProtocol . Mer information finns i MessagePack i SignalR.

Konfigurera serveralternativ

I följande tabell beskrivs alternativ för att SignalR konfigurera hubbar:

Alternativ kan konfigureras för alla hubbar genom att ange ett alternativdelegat till anropet AddSignalR i Program.cs.

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

Alternativ för en enskild hubb åsidosätter de globala alternativ som anges i AddSignalR och kan konfigureras med hjälp av AddHubOptions:

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

Avancerade HTTP-konfigurationsalternativ

Använd HttpConnectionDispatcherOptions för att konfigurera avancerade inställningar som rör transport och hantering av minnesbuffertar. De här alternativen konfigureras genom att ett ombud skickas till MapHub i 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();

I följande tabell beskrivs alternativ för att konfigurera ASP.NET Cores SignalRavancerade HTTP-alternativ:

Long Polling-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen LongPolling :

WebSocket-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen WebSockets :

Konfigurera klientalternativ

Klientalternativ kan konfigureras för HubConnectionBuilder typen (finns i .NET- och JavaScript-klienterna). Den är också tillgänglig i Java-klienten, men underklassen HttpHubConnectionBuilder är det som innehåller konfigurationsalternativen för builder, samt finns dessa också på HubConnection själv.

Konfigurera loggning

Loggning konfigureras i .NET-klienten med hjälp av ConfigureLogging metoden . Loggningsleverantörer och filter kan registreras på samma sätt som de registreras på servern. Mer information finns i dokumentationen om loggning i ASP.NET Core .

Om du till exempel vill aktivera konsolloggning installerar du Microsoft.Extensions.Logging.Console NuGet-paketet. AddConsole Anropa tilläggsmetoden:

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

Det finns en liknande configureLogging metod i JavaScript-klienten. Ange ett LogLevel värde som anger den minsta nivån av loggmeddelanden som ska skapas. Loggar skrivs till webbläsarkonsolfönstret.

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

I stället för ett LogLevel värde kan du också ange ett string värde som representerar ett namn på loggnivå. Detta är användbart när du konfigurerar loggning SignalR i miljöer där du inte har åtkomst till konstanterna LogLevel .

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

I följande tabell visas de tillgängliga loggnivåerna. Det värde som du anger för anger configureLogging den minsta loggnivå som ska loggas. Meddelanden som loggas på den här nivån , eller de nivåer som anges efter det i tabellen, loggas.

Mer information om loggning finns i dokumentationen omSignalR diagnostik.

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

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

Om du inte konfigurerar loggning i dina beroenden laddar SLF4J en standardlogger utan operation med följande varningsmeddelande:

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.

Detta kan ignoreras på ett säkert sätt.

Konfigurera tillåtna transporter

De transporter som används av SignalR kan konfigureras i anropet WithUrl (withUrl i JavaScript). En bitvis OR-operation av värdena HttpTransportType kan användas för att begränsa klienten till att använda endast de angivna transporterna. Alla transporter är aktiverade som standard.

Om du till exempel vill inaktivera Server-Sent Events-transporten, men tillåta WebSockets- och Long Polling-anslutningar:

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

I JavaScript-klienten konfigureras transporterna genom att ställa in transport-fältet på de alternativ som ges till withUrl:

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

I den här versionen av Java-klienten är WebSockets den enda tillgängliga transporten.

I Java-klienten väljs transporten med withTransport -metoden på HttpHubConnectionBuilder. Java-klienten använder som standard WebSockets-transporten.

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

Konfigurera ägarautentisering

Om du vill tillhandahålla autentiseringsdata tillsammans med SignalR begäranden använder du AccessTokenProvider alternativet (accessTokenFactory i JavaScript) för att ange en funktion som returnerar önskad åtkomsttoken. I .NET-klienten skickas den här åtkomsttoken som en HTTP-token för bärarautentisering (Använd Authorization header med en typ av Bearer). I JavaScript-klienten används åtkomsttoken som en Bearer-token, förutom i några fall där webbläsar-API:er begränsar möjligheten att tillämpa rubriker (särskilt i Server-Sent-händelser och WebSockets-begäranden). I dessa fall anges åtkomsttoken som ett frågesträngsvärde access_token.

I .NET-klienten kan AccessTokenProvider-alternativet anges med hjälp av alternativens delegering i WithUrl:

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

I JavaScript-klienten konfigureras åtkomsttoken genom att ange accessTokenFactory fältet på alternativobjektet i 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();

I Java-klienten SignalR kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en åtkomsttokenfabrik till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

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

Konfigurera timeout- och keep-alive-alternativ

Ytterligare alternativ för att konfigurera timeout och keep-alive-beteende:

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

Konfigurera tillståndskänslig återanslutning

SignalR tillståndsbevarande återanslutning minskar den upplevda nedtiden för klienter som upplever en tillfällig frånkoppling i sin nätverksanslutning, till exempel vid byte av nätverksanslutning eller ett kortvarigt avbrott i åtkomsten.

Tillståndsbevarande återanslutning uppnår detta genom att:

• Buffrar tillfälligt data på servern och klienten.
• Bekräfta mottagna meddelanden (ACK-ing) av både servern och klienten.
• Identifiera när en anslutning är igång och spela upp meddelanden som kan ha skickats när anslutningen var nere.

Tillståndsbaserad återanslutning är tillgänglig i .NET 8 eller senare.

Aktivera tillståndsberoende återanslutning vid både server-hubbens slutpunkt och klienten.

• Uppdatera serverhubbens slutpunktskonfiguration för att aktivera alternativet AllowStatefulReconnects:

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

  Du kan också ange den maximala buffertstorleken i byte som tillåts av servern globalt eller för en specifik hubb med alternativet StatefulReconnectBufferSize:

  Alternativet StatefulReconnectBufferSize är inställt globalt.

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

  Inställningarna StatefulReconnectBufferSize för en specifik hubb:

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

  Alternativet StatefulReconnectBufferSize är valfritt med standardvärdet 100 000 byte.

• Uppdatera JavaScript- eller TypeScript-klientkoden för att aktivera alternativet withStatefulReconnect:

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

  Alternativet bufferSize är valfritt med standardvärdet 100 000 byte.

• Uppdatera .NET-klientkoden för att aktivera alternativet WithStatefulReconnect:

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

  Alternativet StatefulReconnectBufferSize är valfritt med standardvärdet 100 000 byte.

Konfigurera ytterligare alternativ

Ytterligare alternativ kan konfigureras i WithUrl metoden (withUrl i JavaScript) på HubConnectionBuilder eller på de olika konfigurations-API:erna på HttpHubConnectionBuilder i Java-klienten:

I .NET-klienten kan dessa alternativ ändras via alternativdelegaten som tillhandahålls till 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();

I JavaScript-klienten kan dessa alternativ anges i ett JavaScript-objekt som tillhandahålls till 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();

I Java-klienten kan dessa alternativ konfigureras med metoderna för de HttpHubConnectionBuilder som returneras från HubConnectionBuilder.create("HUB URL")

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

Ytterligare resurser

• Kom igång med ASP.NET Core SignalR
• Använda hubbar i ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient
• Använda MessagePack Hub Protocol i SignalR för ASP.NET Core
• ASP.NET Core SignalR plattformar som stöds

Serialiseringsalternativ för JSON/MessagePack

ASP.NET Core SignalR stöder två protokoll för kodning av meddelanden: JSON och MessagePack. Varje protokoll har konfigurationsalternativ för serialisering.

JSON-serialisering kan konfigureras på servern med hjälp av AddJsonProtocol tilläggsmetoden, som kan läggas till efter AddSignalR i din Startup.ConfigureServices metod. Metoden AddJsonProtocol tar en delegat som tar emot ett options objekt. Egenskapen PayloadSerializerSettings för objektet är ett Json.NET JsonSerializerSettings objekt som kan användas för att konfigurera serialisering av argument och returvärden. Mer information finns i dokumentationen om Json.NET.

Om du till exempel vill konfigurera serialiseraren för att använda "PascalCase"-egenskapsnamn istället för de standardmässiga camelCase-namnen, använd följande kod i Startup.ConfigureServices.

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

I .NET-klienten finns samma AddJsonProtocol tilläggsmetod på HubConnectionBuilder. Namnområdet Microsoft.Extensions.DependencyInjection måste importeras för att matcha tilläggsmetoden:

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

Serialiseringsalternativ för MessagePack

MessagePack-serialisering kan konfigureras genom att tillhandahålla ett ombud för anropet AddMessagePackProtocol . Mer information finns i MessagePack i SignalR.

Konfigurera serveralternativ

I följande tabell beskrivs alternativ för att SignalR konfigurera hubbar:

Alternativ kan konfigureras för alla hubbar genom att ange ett alternativdelegat till anropet AddSignalR i Startup.ConfigureServices.

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

Alternativ för en enskild hubb åsidosätter de globala alternativ som anges i AddSignalR och kan konfigureras med hjälp av AddHubOptions:

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

Avancerade HTTP-konfigurationsalternativ

Använd HttpConnectionDispatcherOptions för att konfigurera avancerade inställningar som rör transport och hantering av minnesbuffertar. De här alternativen konfigureras genom att ett ombud skickas till MapHub i 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;
        });
    });
}

I följande tabell beskrivs alternativ för att konfigurera ASP.NET Cores SignalRavancerade HTTP-alternativ:

Long Polling-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen LongPolling :

WebSocket-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen WebSockets :

Konfigurera klientalternativ

Klientalternativ kan konfigureras för HubConnectionBuilder typen (finns i .NET- och JavaScript-klienterna). Den är också tillgänglig i Java-klienten, men underklassen HttpHubConnectionBuilder är det som innehåller konfigurationsalternativen för builder, samt finns dessa också på HubConnection själv.

Konfigurera loggning

Loggning konfigureras i .NET-klienten med hjälp av ConfigureLogging metoden . Loggningsleverantörer och filter kan registreras på samma sätt som de registreras på servern. Mer information finns i dokumentationen om loggning i ASP.NET Core .

Om du till exempel vill aktivera konsolloggning installerar du Microsoft.Extensions.Logging.Console NuGet-paketet. AddConsole Anropa tilläggsmetoden:

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

Det finns en liknande configureLogging metod i JavaScript-klienten. Ange ett LogLevel värde som anger den minsta nivån av loggmeddelanden som ska skapas. Loggar skrivs till webbläsarkonsolfönstret.

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

Mer information om loggning finns i dokumentationen omSignalR diagnostik.

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

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

Om du inte konfigurerar loggning i dina beroenden laddar SLF4J en standardlogger utan operation med följande varningsmeddelande:

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.

Detta kan ignoreras på ett säkert sätt.

Konfigurera tillåtna transporter

De transporter som används av SignalR kan konfigureras i anropet WithUrl (withUrl i JavaScript). En bitvis OR-operation av värdena HttpTransportType kan användas för att begränsa klienten till att använda endast de angivna transporterna. Alla transporter är aktiverade som standard.

Om du till exempel vill inaktivera Server-Sent Events-transporten, men tillåta WebSockets- och Long Polling-anslutningar:

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

I JavaScript-klienten konfigureras transporterna genom att ställa in transport-fältet på de alternativ som ges till withUrl:

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

Konfigurera ägarautentisering

Om du vill tillhandahålla autentiseringsdata tillsammans med SignalR begäranden använder du AccessTokenProvider alternativet (accessTokenFactory i JavaScript) för att ange en funktion som returnerar önskad åtkomsttoken. I .NET-klienten skickas den här åtkomsttoken som en HTTP-token för bärarautentisering (Använd Authorization header med en typ av Bearer). I JavaScript-klienten används åtkomsttoken som en Bearer-token, förutom i några fall där webbläsar-API:er begränsar möjligheten att tillämpa rubriker (särskilt i Server-Sent-händelser och WebSockets-begäranden). I dessa fall anges åtkomsttoken som ett frågesträngsvärde access_token.

I .NET-klienten kan AccessTokenProvider-alternativet anges med hjälp av alternativens delegering i WithUrl:

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

I JavaScript-klienten konfigureras åtkomsttoken genom att ange accessTokenFactory fältet på alternativobjektet i 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();

I Java-klienten SignalR kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en åtkomsttokenfabrik till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

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

Konfigurera timeout- och keep-alive-alternativ

Ytterligare alternativ för att konfigurera timeout och keep-alive-beteende är tillgängliga för HubConnection själva objektet:

Konfigurera ytterligare alternativ

Ytterligare alternativ kan konfigureras i WithUrl metoden (withUrl i JavaScript) på HubConnectionBuilder eller på de olika konfigurations-API:erna på HttpHubConnectionBuilder i Java-klienten:

I .NET-klienten kan dessa alternativ ändras via alternativdelegaten som tillhandahålls till WithUrl:

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

I JavaScript-klienten kan dessa alternativ anges i ett JavaScript-objekt som tillhandahålls till withUrl:

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

I Java-klienten kan dessa alternativ konfigureras med metoderna för de HttpHubConnectionBuilder som returneras från HubConnectionBuilder.create("HUB URL")

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

Ytterligare resurser

• Kom igång med ASP.NET Core SignalR
• Använda hubbar i ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient
• Använda MessagePack Hub Protocol i SignalR för ASP.NET Core
• ASP.NET Core SignalR plattformar som stöds

Serialiseringsalternativ för JSON/MessagePack

ASP.NET Core SignalR stöder två protokoll för kodning av meddelanden: JSON och MessagePack. Varje protokoll har konfigurationsalternativ för serialisering.

JSON-serialisering kan konfigureras på servern med hjälp av AddJsonProtocol tilläggsmetoden, som kan läggas till efter AddSignalR i din Startup.ConfigureServices metod. Metoden AddJsonProtocol tar en delegat som tar emot ett options objekt. Egenskapen PayloadSerializerSettings för objektet är ett Json.NET JsonSerializerSettings objekt som kan användas för att konfigurera serialisering av argument och returvärden. Mer information finns i dokumentationen om Json.NET.

Om du till exempel vill konfigurera serialiseraren för att använda "PascalCase"-egenskapsnamn istället för de standardmässiga camelCase-namnen, använd följande kod i Startup.ConfigureServices.

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

I .NET-klienten finns samma AddJsonProtocol tilläggsmetod på HubConnectionBuilder. Namnområdet Microsoft.Extensions.DependencyInjection måste importeras för att matcha tilläggsmetoden:

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

Serialiseringsalternativ för MessagePack

MessagePack-serialisering kan konfigureras genom att tillhandahålla ett ombud för anropet AddMessagePackProtocol . Mer information finns i MessagePack i SignalR.

Konfigurera serveralternativ

I följande tabell beskrivs alternativ för att SignalR konfigurera hubbar:

Alternativ kan konfigureras för alla hubbar genom att ange ett alternativdelegat till anropet AddSignalR i Startup.ConfigureServices.

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

Alternativ för en enskild hubb åsidosätter de globala alternativ som anges i AddSignalR och kan konfigureras med hjälp av AddHubOptions:

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

Avancerade HTTP-konfigurationsalternativ

Använd HttpConnectionDispatcherOptions för att konfigurera avancerade inställningar som rör transport och hantering av minnesbuffertar. De här alternativen konfigureras genom att ett ombud skickas till MapHub i 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;
        });
    });
}

I följande tabell beskrivs alternativ för att konfigurera ASP.NET Cores SignalRavancerade HTTP-alternativ:

Long Polling-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen LongPolling :

WebSocket-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen WebSockets :

Konfigurera klientalternativ

Klientalternativ kan konfigureras för HubConnectionBuilder typen (finns i .NET- och JavaScript-klienterna). Den är också tillgänglig i Java-klienten, men underklassen HttpHubConnectionBuilder är det som innehåller konfigurationsalternativen för builder, samt finns dessa också på HubConnection själv.

Konfigurera loggning

Loggning konfigureras i .NET-klienten med hjälp av ConfigureLogging metoden . Loggningsleverantörer och filter kan registreras på samma sätt som de registreras på servern. Mer information finns i dokumentationen om loggning i ASP.NET Core .

Om du till exempel vill aktivera konsolloggning installerar du Microsoft.Extensions.Logging.Console NuGet-paketet. AddConsole Anropa tilläggsmetoden:

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

Det finns en liknande configureLogging metod i JavaScript-klienten. Ange ett LogLevel värde som anger den minsta nivån av loggmeddelanden som ska skapas. Loggar skrivs till webbläsarkonsolfönstret.

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

Mer information om loggning finns i dokumentationen omSignalR diagnostik.

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

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

Om du inte konfigurerar loggning i dina beroenden laddar SLF4J en standardlogger utan operation med följande varningsmeddelande:

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.

Detta kan ignoreras på ett säkert sätt.

Konfigurera tillåtna transporter

De transporter som används av SignalR kan konfigureras i anropet WithUrl (withUrl i JavaScript). En bitvis OR-operation av värdena HttpTransportType kan användas för att begränsa klienten till att använda endast de angivna transporterna. Alla transporter är aktiverade som standard.

Om du till exempel vill inaktivera Server-Sent Events-transporten, men tillåta WebSockets- och Long Polling-anslutningar:

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

I JavaScript-klienten konfigureras transporterna genom att ställa in transport-fältet på de alternativ som ges till withUrl:

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

I den här versionen av Java-klienten är WebSockets den enda tillgängliga transporten.

Konfigurera ägarautentisering

Om du vill tillhandahålla autentiseringsdata tillsammans med SignalR begäranden använder du AccessTokenProvider alternativet (accessTokenFactory i JavaScript) för att ange en funktion som returnerar önskad åtkomsttoken. I .NET-klienten skickas den här åtkomsttoken som en HTTP-token för bärarautentisering (Använd Authorization header med en typ av Bearer). I JavaScript-klienten används åtkomsttoken som en Bearer-token, förutom i några fall där webbläsar-API:er begränsar möjligheten att tillämpa rubriker (särskilt i Server-Sent-händelser och WebSockets-begäranden). I dessa fall anges åtkomsttoken som ett frågesträngsvärde access_token.

I .NET-klienten kan AccessTokenProvider-alternativet anges med hjälp av alternativens delegering i WithUrl:

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

I JavaScript-klienten konfigureras åtkomsttoken genom att ange accessTokenFactory fältet på alternativobjektet i 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();

I Java-klienten SignalR kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en åtkomsttokenfabrik till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

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

Konfigurera timeout- och keep-alive-alternativ

Ytterligare alternativ för att konfigurera timeout och keep-alive-beteende är tillgängliga för HubConnection själva objektet:

Konfigurera ytterligare alternativ

Ytterligare alternativ kan konfigureras i WithUrl metoden (withUrl i JavaScript) på HubConnectionBuilder eller på de olika konfigurations-API:erna på HttpHubConnectionBuilder i Java-klienten:

I .NET-klienten kan dessa alternativ ändras via alternativdelegaten som tillhandahålls till WithUrl:

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

I JavaScript-klienten kan dessa alternativ anges i ett JavaScript-objekt som tillhandahålls till withUrl:

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

I Java-klienten kan dessa alternativ konfigureras med metoderna för de HttpHubConnectionBuilder som returneras från HubConnectionBuilder.create("HUB URL")

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

Ytterligare resurser

• Kom igång med ASP.NET Core SignalR
• Använda hubbar i ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient
• Använda MessagePack Hub Protocol i SignalR för ASP.NET Core
• ASP.NET Core SignalR plattformar som stöds

Serialiseringsalternativ för JSON/MessagePack

ASP.NET Core SignalR stöder två protokoll för kodning av meddelanden: JSON och MessagePack. Varje protokoll har konfigurationsalternativ för serialisering.

JSON-serialisering kan konfigureras på servern med hjälp av AddJsonProtocol tilläggsmetoden. AddJsonProtocol kan läggas till efter AddSignalR i Startup.ConfigureServices. Metoden AddJsonProtocol tar en delegat som tar emot ett options objekt. Egenskapen PayloadSerializerOptions för objektet är ett System.Text.JsonJsonSerializerOptions objekt som kan användas för att konfigurera serialisering av argument och returvärden. Mer information finns i dokumentationen om System.Text.Json.

Om du till exempel vill konfigurera serialiseraren så att den inte ändrar versaliseringen för egenskapsnamn, i stället för standardnamnen för kamelfall, använder du följande kod i Startup.ConfigureServices:

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

I .NET-klienten finns samma AddJsonProtocol tilläggsmetod på HubConnectionBuilder. Namnområdet Microsoft.Extensions.DependencyInjection måste importeras för att matcha tilläggsmetoden:

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

Växla till Newtonsoft.Json

Om du behöver funktioner i Newtonsoft.Json som inte stöds i System.Text.Json, kan du se Växla till Newtonsoft.Json.

Serialiseringsalternativ för MessagePack

MessagePack-serialisering kan konfigureras genom att tillhandahålla ett ombud för anropet AddMessagePackProtocol . Mer information finns i MessagePack i SignalR.

Konfigurera serveralternativ

I följande tabell beskrivs alternativ för att SignalR konfigurera hubbar:

Alternativ kan konfigureras för alla hubbar genom att ange ett alternativdelegat till anropet AddSignalR i Startup.ConfigureServices.

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

Alternativ för en enskild hubb åsidosätter de globala alternativ som anges i AddSignalR och kan konfigureras med hjälp av AddHubOptions:

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

Avancerade HTTP-konfigurationsalternativ

Använd HttpConnectionDispatcherOptions för att konfigurera avancerade inställningar som rör transport och hantering av minnesbuffertar. De här alternativen konfigureras genom att ett ombud skickas till MapHub i 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;
        });
    });
}

I följande tabell beskrivs alternativ för att konfigurera ASP.NET Cores SignalRavancerade HTTP-alternativ:

Long Polling-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen LongPolling :

WebSocket-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen WebSockets :

Konfigurera klientalternativ

Klientalternativ kan konfigureras för HubConnectionBuilder typen (finns i .NET- och JavaScript-klienterna). Den är också tillgänglig i Java-klienten, men underklassen HttpHubConnectionBuilder är det som innehåller konfigurationsalternativen för builder, samt finns dessa också på HubConnection själv.

Konfigurera loggning

Loggning konfigureras i .NET-klienten med hjälp av ConfigureLogging metoden . Loggningsleverantörer och filter kan registreras på samma sätt som de registreras på servern. Mer information finns i dokumentationen om loggning i ASP.NET Core .

Om du till exempel vill aktivera konsolloggning installerar du Microsoft.Extensions.Logging.Console NuGet-paketet. AddConsole Anropa tilläggsmetoden:

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

Det finns en liknande configureLogging metod i JavaScript-klienten. Ange ett LogLevel värde som anger den minsta nivån av loggmeddelanden som ska skapas. Loggar skrivs till webbläsarkonsolfönstret.

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

I stället för ett LogLevel värde kan du också ange ett string värde som representerar ett namn på loggnivå. Detta är användbart när du konfigurerar loggning SignalR i miljöer där du inte har åtkomst till konstanterna LogLevel .

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

I följande tabell visas de tillgängliga loggnivåerna. Det värde som du anger för anger configureLogging den minsta loggnivå som ska loggas. Meddelanden som loggas på den här nivån , eller de nivåer som anges efter det i tabellen, loggas.

Mer information om loggning finns i dokumentationen omSignalR diagnostik.

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

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

Om du inte konfigurerar loggning i dina beroenden laddar SLF4J en standardlogger utan operation med följande varningsmeddelande:

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.

Detta kan ignoreras på ett säkert sätt.

Konfigurera tillåtna transporter

De transporter som används av SignalR kan konfigureras i anropet WithUrl (withUrl i JavaScript). En bitvis OR-operation av värdena HttpTransportType kan användas för att begränsa klienten till att använda endast de angivna transporterna. Alla transporter är aktiverade som standard.

Om du till exempel vill inaktivera Server-Sent Events-transporten, men tillåta WebSockets- och Long Polling-anslutningar:

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

I JavaScript-klienten konfigureras transporterna genom att ställa in transport-fältet på de alternativ som ges till withUrl:

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

I den här versionen av Java-klienten är WebSockets den enda tillgängliga transporten.

I Java-klienten väljs transporten med withTransport -metoden på HttpHubConnectionBuilder. Java-klienten använder som standard WebSockets-transporten.

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

Konfigurera ägarautentisering

Om du vill tillhandahålla autentiseringsdata tillsammans med SignalR begäranden använder du AccessTokenProvider alternativet (accessTokenFactory i JavaScript) för att ange en funktion som returnerar önskad åtkomsttoken. I .NET-klienten skickas den här åtkomsttoken som en HTTP-token för bärarautentisering (Använd Authorization header med en typ av Bearer). I JavaScript-klienten används åtkomsttoken som en Bearer-token, förutom i några fall där webbläsar-API:er begränsar möjligheten att tillämpa rubriker (särskilt i Server-Sent-händelser och WebSockets-begäranden). I dessa fall anges åtkomsttoken som ett frågesträngsvärde access_token.

I .NET-klienten kan AccessTokenProvider-alternativet anges med hjälp av alternativens delegering i WithUrl:

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

I JavaScript-klienten konfigureras åtkomsttoken genom att ange accessTokenFactory fältet på alternativobjektet i 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();

I Java-klienten SignalR kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en åtkomsttokenfabrik till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

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

Konfigurera timeout- och keep-alive-alternativ

Ytterligare alternativ för att konfigurera timeout och keep-alive-beteende är tillgängliga för HubConnection själva objektet:

Konfigurera ytterligare alternativ

Ytterligare alternativ kan konfigureras i WithUrl metoden (withUrl i JavaScript) på HubConnectionBuilder eller på de olika konfigurations-API:erna på HttpHubConnectionBuilder i Java-klienten:

I .NET-klienten kan dessa alternativ ändras via alternativdelegaten som tillhandahålls till WithUrl:

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

I JavaScript-klienten kan dessa alternativ anges i ett JavaScript-objekt som tillhandahålls till withUrl:

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

I Java-klienten kan dessa alternativ konfigureras med metoderna för de HttpHubConnectionBuilder som returneras från HubConnectionBuilder.create("HUB URL")

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

Ytterligare resurser

• Kom igång med ASP.NET Core SignalR
• Använda hubbar i ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient
• Använda MessagePack Hub Protocol i SignalR för ASP.NET Core
• ASP.NET Core SignalR plattformar som stöds

Serialiseringsalternativ för JSON/MessagePack

ASP.NET Core SignalR stöder två protokoll för kodning av meddelanden: JSON och MessagePack. Varje protokoll har konfigurationsalternativ för serialisering.

JSON-serialisering kan konfigureras på servern med hjälp av AddJsonProtocol tilläggsmetoden. AddJsonProtocol kan läggas till efter AddSignalR i Startup.ConfigureServices. Metoden AddJsonProtocol tar en delegat som tar emot ett options objekt. Egenskapen PayloadSerializerOptions för objektet är ett System.Text.JsonJsonSerializerOptions objekt som kan användas för att konfigurera serialisering av argument och returvärden. Mer information finns i dokumentationen om System.Text.Json.

Om du till exempel vill konfigurera serialiseraren så att den inte ändrar versaliseringen för egenskapsnamn, i stället för standardnamnen för kamelfall, använder du följande kod i Startup.ConfigureServices:

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

I .NET-klienten finns samma AddJsonProtocol tilläggsmetod på HubConnectionBuilder. Namnområdet Microsoft.Extensions.DependencyInjection måste importeras för att matcha tilläggsmetoden:

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

Växla till Newtonsoft.Json

Om du behöver funktioner i Newtonsoft.Json som inte stöds i System.Text.Json, kan du se Växla till Newtonsoft.Json.

Serialiseringsalternativ för MessagePack

MessagePack-serialisering kan konfigureras genom att tillhandahålla ett ombud för anropet AddMessagePackProtocol . Mer information finns i MessagePack i SignalR.

Konfigurera serveralternativ

I följande tabell beskrivs alternativ för att SignalR konfigurera hubbar:

Alternativ kan konfigureras för alla hubbar genom att ange ett alternativdelegat till anropet AddSignalR i Startup.ConfigureServices.

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

Alternativ för en enskild hubb åsidosätter de globala alternativ som anges i AddSignalR och kan konfigureras med hjälp av AddHubOptions:

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

Avancerade HTTP-konfigurationsalternativ

Använd HttpConnectionDispatcherOptions för att konfigurera avancerade inställningar som rör transport och hantering av minnesbuffertar. De här alternativen konfigureras genom att ett ombud skickas till MapHub i 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;
        });
    });
}

I följande tabell beskrivs alternativ för att konfigurera ASP.NET Cores SignalRavancerade HTTP-alternativ:

Long Polling-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen LongPolling :

WebSocket-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen WebSockets :

Konfigurera klientalternativ

Klientalternativ kan konfigureras för HubConnectionBuilder typen (finns i .NET- och JavaScript-klienterna). Den är också tillgänglig i Java-klienten, men underklassen HttpHubConnectionBuilder är det som innehåller konfigurationsalternativen för builder, samt finns dessa också på HubConnection själv.

Konfigurera loggning

Loggning konfigureras i .NET-klienten med hjälp av ConfigureLogging metoden . Loggningsleverantörer och filter kan registreras på samma sätt som de registreras på servern. Mer information finns i dokumentationen om loggning i ASP.NET Core .

Om du till exempel vill aktivera konsolloggning installerar du Microsoft.Extensions.Logging.Console NuGet-paketet. AddConsole Anropa tilläggsmetoden:

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

Det finns en liknande configureLogging metod i JavaScript-klienten. Ange ett LogLevel värde som anger den minsta nivån av loggmeddelanden som ska skapas. Loggar skrivs till webbläsarkonsolfönstret.

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

I stället för ett LogLevel värde kan du också ange ett string värde som representerar ett namn på loggnivå. Detta är användbart när du konfigurerar loggning SignalR i miljöer där du inte har åtkomst till konstanterna LogLevel .

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

I följande tabell visas de tillgängliga loggnivåerna. Det värde som du anger för anger configureLogging den minsta loggnivå som ska loggas. Meddelanden som loggas på den här nivån , eller de nivåer som anges efter det i tabellen, loggas.

Mer information om loggning finns i dokumentationen omSignalR diagnostik.

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

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

Om du inte konfigurerar loggning i dina beroenden laddar SLF4J en standardlogger utan operation med följande varningsmeddelande:

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.

Detta kan ignoreras på ett säkert sätt.

Konfigurera tillåtna transporter

De transporter som används av SignalR kan konfigureras i anropet WithUrl (withUrl i JavaScript). En bitvis OR-operation av värdena HttpTransportType kan användas för att begränsa klienten till att använda endast de angivna transporterna. Alla transporter är aktiverade som standard.

Om du till exempel vill inaktivera Server-Sent Events-transporten, men tillåta WebSockets- och Long Polling-anslutningar:

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

I JavaScript-klienten konfigureras transporterna genom att ställa in transport-fältet på de alternativ som ges till withUrl:

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

I den här versionen av Java-klienten är WebSockets den enda tillgängliga transporten.

I Java-klienten väljs transporten med withTransport -metoden på HttpHubConnectionBuilder. Java-klienten använder som standard WebSockets-transporten.

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

Konfigurera ägarautentisering

Om du vill tillhandahålla autentiseringsdata tillsammans med SignalR begäranden använder du AccessTokenProvider alternativet (accessTokenFactory i JavaScript) för att ange en funktion som returnerar önskad åtkomsttoken. I .NET-klienten skickas den här åtkomsttoken som en HTTP-token för bärarautentisering (Använd Authorization header med en typ av Bearer). I JavaScript-klienten används åtkomsttoken som en Bearer-token, förutom i några fall där webbläsar-API:er begränsar möjligheten att tillämpa rubriker (särskilt i Server-Sent-händelser och WebSockets-begäranden). I dessa fall anges åtkomsttoken som ett frågesträngsvärde access_token.

I .NET-klienten kan AccessTokenProvider-alternativet anges med hjälp av alternativens delegering i WithUrl:

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

I JavaScript-klienten konfigureras åtkomsttoken genom att ange accessTokenFactory fältet på alternativobjektet i 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();

I Java-klienten SignalR kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en åtkomsttokenfabrik till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

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

Konfigurera timeout- och keep-alive-alternativ

Ytterligare alternativ för att konfigurera timeout och keep-alive-beteende är tillgängliga för HubConnection själva objektet:

Konfigurera ytterligare alternativ

Ytterligare alternativ kan konfigureras i WithUrl metoden (withUrl i JavaScript) på HubConnectionBuilder eller på de olika konfigurations-API:erna på HttpHubConnectionBuilder i Java-klienten:

I .NET-klienten kan dessa alternativ ändras via alternativdelegaten som tillhandahålls till WithUrl:

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

I JavaScript-klienten kan dessa alternativ anges i ett JavaScript-objekt som tillhandahålls till withUrl:

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

I Java-klienten kan dessa alternativ konfigureras med metoderna för de HttpHubConnectionBuilder som returneras från HubConnectionBuilder.create("HUB URL")

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

Ytterligare resurser

• Kom igång med ASP.NET Core SignalR
• Använda hubbar i ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient
• Använda MessagePack Hub Protocol i SignalR för ASP.NET Core
• ASP.NET Core SignalR plattformar som stöds

Serialiseringsalternativ för JSON/MessagePack

ASP.NET Core SignalR stöder två protokoll för kodning av meddelanden: JSON och MessagePack. Varje protokoll har konfigurationsalternativ för serialisering.

JSON-serialisering kan konfigureras på servern med hjälp av AddJsonProtocol tilläggsmetoden. AddJsonProtocol kan läggas till efter AddSignalR i Startup.ConfigureServices. Metoden AddJsonProtocol tar en delegat som tar emot ett options objekt. Egenskapen PayloadSerializerOptions för objektet är ett System.Text.JsonJsonSerializerOptions objekt som kan användas för att konfigurera serialisering av argument och returvärden. Mer information finns i dokumentationen om System.Text.Json.

Om du till exempel vill konfigurera serialiseraren så att den inte ändrar versaliseringen för egenskapsnamn, i stället för standardnamnen för kamelfall, använder du följande kod i Startup.ConfigureServices:

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

I .NET-klienten finns samma AddJsonProtocol tilläggsmetod på HubConnectionBuilder. Namnområdet Microsoft.Extensions.DependencyInjection måste importeras för att matcha tilläggsmetoden:

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

Växla till Newtonsoft.Json

Om du behöver funktioner i Newtonsoft.Json som inte stöds i System.Text.Json, kan du se Växla till Newtonsoft.Json.

Serialiseringsalternativ för MessagePack

MessagePack-serialisering kan konfigureras genom att tillhandahålla ett ombud för anropet AddMessagePackProtocol . Mer information finns i MessagePack i SignalR.

Konfigurera serveralternativ

I följande tabell beskrivs alternativ för att SignalR konfigurera hubbar:

Alternativ kan konfigureras för alla hubbar genom att ange ett alternativdelegat till anropet AddSignalR i Startup.ConfigureServices.

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

Alternativ för en enskild hubb åsidosätter de globala alternativ som anges i AddSignalR och kan konfigureras med hjälp av AddHubOptions:

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

Avancerade HTTP-konfigurationsalternativ

Använd HttpConnectionDispatcherOptions för att konfigurera avancerade inställningar som rör transport och hantering av minnesbuffertar. De här alternativen konfigureras genom att ett ombud skickas till MapHub i 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;
        });
    });
}

I följande tabell beskrivs alternativ för att konfigurera ASP.NET Cores SignalRavancerade HTTP-alternativ:

Long Polling-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen LongPolling :

WebSocket-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen WebSockets :

Konfigurera klientalternativ

Klientalternativ kan konfigureras för HubConnectionBuilder typen (finns i .NET- och JavaScript-klienterna). Den är också tillgänglig i Java-klienten, men underklassen HttpHubConnectionBuilder är det som innehåller konfigurationsalternativen för builder, samt finns dessa också på HubConnection själv.

Konfigurera loggning

Loggning konfigureras i .NET-klienten med hjälp av ConfigureLogging metoden . Loggningsleverantörer och filter kan registreras på samma sätt som de registreras på servern. Mer information finns i dokumentationen om loggning i ASP.NET Core .

Om du till exempel vill aktivera konsolloggning installerar du Microsoft.Extensions.Logging.Console NuGet-paketet. AddConsole Anropa tilläggsmetoden:

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

Det finns en liknande configureLogging metod i JavaScript-klienten. Ange ett LogLevel värde som anger den minsta nivån av loggmeddelanden som ska skapas. Loggar skrivs till webbläsarkonsolfönstret.

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

I stället för ett LogLevel värde kan du också ange ett string värde som representerar ett namn på loggnivå. Detta är användbart när du konfigurerar loggning SignalR i miljöer där du inte har åtkomst till konstanterna LogLevel .

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

I följande tabell visas de tillgängliga loggnivåerna. Det värde som du anger för anger configureLogging den minsta loggnivå som ska loggas. Meddelanden som loggas på den här nivån , eller de nivåer som anges efter det i tabellen, loggas.

Mer information om loggning finns i dokumentationen omSignalR diagnostik.

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

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

Om du inte konfigurerar loggning i dina beroenden laddar SLF4J en standardlogger utan operation med följande varningsmeddelande:

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.

Detta kan ignoreras på ett säkert sätt.

Konfigurera tillåtna transporter

De transporter som används av SignalR kan konfigureras i anropet WithUrl (withUrl i JavaScript). En bitvis OR-operation av värdena HttpTransportType kan användas för att begränsa klienten till att använda endast de angivna transporterna. Alla transporter är aktiverade som standard.

Om du till exempel vill inaktivera Server-Sent Events-transporten, men tillåta WebSockets- och Long Polling-anslutningar:

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

I JavaScript-klienten konfigureras transporterna genom att ställa in transport-fältet på de alternativ som ges till withUrl:

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

I den här versionen av Java-klienten är WebSockets den enda tillgängliga transporten.

I Java-klienten väljs transporten med withTransport -metoden på HttpHubConnectionBuilder. Java-klienten använder som standard WebSockets-transporten.

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

Konfigurera ägarautentisering

Om du vill tillhandahålla autentiseringsdata tillsammans med SignalR begäranden använder du AccessTokenProvider alternativet (accessTokenFactory i JavaScript) för att ange en funktion som returnerar önskad åtkomsttoken. I .NET-klienten skickas den här åtkomsttoken som en HTTP-token för bärarautentisering (Använd Authorization header med en typ av Bearer). I JavaScript-klienten används åtkomsttoken som en Bearer-token, förutom i några fall där webbläsar-API:er begränsar möjligheten att tillämpa rubriker (särskilt i Server-Sent-händelser och WebSockets-begäranden). I dessa fall anges åtkomsttoken som ett frågesträngsvärde access_token.

I .NET-klienten kan AccessTokenProvider-alternativet anges med hjälp av alternativens delegering i WithUrl:

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

I JavaScript-klienten konfigureras åtkomsttoken genom att ange accessTokenFactory fältet på alternativobjektet i 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();

I Java-klienten SignalR kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en åtkomsttokenfabrik till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

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

Konfigurera timeout- och keep-alive-alternativ

Ytterligare alternativ för att konfigurera timeout och keep-alive-beteende är tillgängliga för HubConnection själva objektet:

Konfigurera ytterligare alternativ

Ytterligare alternativ kan konfigureras i WithUrl metoden (withUrl i JavaScript) på HubConnectionBuilder eller på de olika konfigurations-API:erna på HttpHubConnectionBuilder i Java-klienten:

I .NET-klienten kan dessa alternativ ändras via alternativdelegaten som tillhandahålls till 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();

I JavaScript-klienten kan dessa alternativ anges i ett JavaScript-objekt som tillhandahålls till 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();

I Java-klienten kan dessa alternativ konfigureras med metoderna för de HttpHubConnectionBuilder som returneras från HubConnectionBuilder.create("HUB URL")

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

Ytterligare resurser

• Kom igång med ASP.NET Core SignalR
• Använda hubbar i ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient
• Använda MessagePack Hub Protocol i SignalR för ASP.NET Core
• ASP.NET Core SignalR plattformar som stöds

Serialiseringsalternativ för JSON/MessagePack

ASP.NET Core SignalR stöder två protokoll för kodning av meddelanden: JSON och MessagePack. Varje protokoll har konfigurationsalternativ för serialisering.

JSON-serialisering kan konfigureras på servern med hjälp av AddJsonProtocol tilläggsmetoden. AddJsonProtocol kan läggas till efter AddSignalR i Program.cs. Metoden AddJsonProtocol tar en delegat som tar emot ett options objekt. Egenskapen PayloadSerializerOptions för objektet är ett System.Text.JsonJsonSerializerOptions objekt som kan användas för att konfigurera serialisering av argument och returvärden. Mer information finns i dokumentationen om System.Text.Json.

Om du till exempel vill konfigurera serialiseraren så att den inte ändrar versaliseringen för egenskapsnamn, i stället för standardnamnen för kamelfall, använder du följande kod i Program.cs:

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

I .NET-klienten finns samma AddJsonProtocol tilläggsmetod på HubConnectionBuilder. Namnområdet Microsoft.Extensions.DependencyInjection måste importeras för att matcha tilläggsmetoden:

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

Växla till Newtonsoft.Json

Om du behöver funktioner i Newtonsoft.Json som inte stöds i System.Text.Json, kan du se Växla till Newtonsoft.Json.

Serialiseringsalternativ för MessagePack

MessagePack-serialisering kan konfigureras genom att tillhandahålla ett ombud för anropet AddMessagePackProtocol . Mer information finns i MessagePack i SignalR.

Konfigurera serveralternativ

I följande tabell beskrivs alternativ för att SignalR konfigurera hubbar:

Alternativ kan konfigureras för alla hubbar genom att ange ett alternativdelegat till anropet AddSignalR i Program.cs.

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

Alternativ för en enskild hubb åsidosätter de globala alternativ som anges i AddSignalR och kan konfigureras med hjälp av AddHubOptions:

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

Avancerade HTTP-konfigurationsalternativ

Använd HttpConnectionDispatcherOptions för att konfigurera avancerade inställningar som rör transport och hantering av minnesbuffertar. De här alternativen konfigureras genom att ett ombud skickas till MapHub i 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();

I följande tabell beskrivs alternativ för att konfigurera ASP.NET Cores SignalRavancerade HTTP-alternativ:

Long Polling-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen LongPolling :

WebSocket-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen WebSockets :

Konfigurera klientalternativ

Klientalternativ kan konfigureras för HubConnectionBuilder typen (finns i .NET- och JavaScript-klienterna). Den är också tillgänglig i Java-klienten, men underklassen HttpHubConnectionBuilder är det som innehåller konfigurationsalternativen för builder, samt finns dessa också på HubConnection själv.

Konfigurera loggning

Loggning konfigureras i .NET-klienten med hjälp av ConfigureLogging metoden . Loggningsleverantörer och filter kan registreras på samma sätt som de registreras på servern. Mer information finns i dokumentationen om loggning i ASP.NET Core .

Om du till exempel vill aktivera konsolloggning installerar du Microsoft.Extensions.Logging.Console NuGet-paketet. AddConsole Anropa tilläggsmetoden:

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

Det finns en liknande configureLogging metod i JavaScript-klienten. Ange ett LogLevel värde som anger den minsta nivån av loggmeddelanden som ska skapas. Loggar skrivs till webbläsarkonsolfönstret.

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

I stället för ett LogLevel värde kan du också ange ett string värde som representerar ett namn på loggnivå. Detta är användbart när du konfigurerar loggning SignalR i miljöer där du inte har åtkomst till konstanterna LogLevel .

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

I följande tabell visas de tillgängliga loggnivåerna. Det värde som du anger för anger configureLogging den minsta loggnivå som ska loggas. Meddelanden som loggas på den här nivån , eller de nivåer som anges efter det i tabellen, loggas.

Mer information om loggning finns i dokumentationen omSignalR diagnostik.

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

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

Om du inte konfigurerar loggning i dina beroenden laddar SLF4J en standardlogger utan operation med följande varningsmeddelande:

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.

Detta kan ignoreras på ett säkert sätt.

Konfigurera tillåtna transporter

De transporter som används av SignalR kan konfigureras i anropet WithUrl (withUrl i JavaScript). En bitvis OR-operation av värdena HttpTransportType kan användas för att begränsa klienten till att använda endast de angivna transporterna. Alla transporter är aktiverade som standard.

Om du till exempel vill inaktivera Server-Sent Events-transporten, men tillåta WebSockets- och Long Polling-anslutningar:

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

I JavaScript-klienten konfigureras transporterna genom att ställa in transport-fältet på de alternativ som ges till withUrl:

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

I den här versionen av Java-klienten är WebSockets den enda tillgängliga transporten.

I Java-klienten väljs transporten med withTransport -metoden på HttpHubConnectionBuilder. Java-klienten använder som standard WebSockets-transporten.

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

Konfigurera ägarautentisering

Om du vill tillhandahålla autentiseringsdata tillsammans med SignalR begäranden använder du AccessTokenProvider alternativet (accessTokenFactory i JavaScript) för att ange en funktion som returnerar önskad åtkomsttoken. I .NET-klienten skickas den här åtkomsttoken som en HTTP-token för bärarautentisering (Använd Authorization header med en typ av Bearer). I JavaScript-klienten används åtkomsttoken som en Bearer-token, förutom i några fall där webbläsar-API:er begränsar möjligheten att tillämpa rubriker (särskilt i Server-Sent-händelser och WebSockets-begäranden). I dessa fall anges åtkomsttoken som ett frågesträngsvärde access_token.

I .NET-klienten kan AccessTokenProvider-alternativet anges med hjälp av alternativens delegering i WithUrl:

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

I JavaScript-klienten konfigureras åtkomsttoken genom att ange accessTokenFactory fältet på alternativobjektet i 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();

I Java-klienten SignalR kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en åtkomsttokenfabrik till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

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

Konfigurera timeout- och keep-alive-alternativ

Ytterligare alternativ för att konfigurera timeout och keep-alive-beteende är tillgängliga för HubConnection själva objektet:

Konfigurera ytterligare alternativ

Ytterligare alternativ kan konfigureras i WithUrl metoden (withUrl i JavaScript) på HubConnectionBuilder eller på de olika konfigurations-API:erna på HttpHubConnectionBuilder i Java-klienten:

I .NET-klienten kan dessa alternativ ändras via alternativdelegaten som tillhandahålls till 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();

I JavaScript-klienten kan dessa alternativ anges i ett JavaScript-objekt som tillhandahålls till 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();

I Java-klienten kan dessa alternativ konfigureras med metoderna för de HttpHubConnectionBuilder som returneras från HubConnectionBuilder.create("HUB URL")

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

Ytterligare resurser

• Kom igång med ASP.NET Core SignalR
• Använda hubbar i ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient
• Använda MessagePack Hub Protocol i SignalR för ASP.NET Core
• ASP.NET Core SignalR plattformar som stöds

Serialiseringsalternativ för JSON/MessagePack

ASP.NET Core SignalR stöder två protokoll för kodning av meddelanden: JSON och MessagePack. Varje protokoll har konfigurationsalternativ för serialisering.

JSON-serialisering kan konfigureras på servern med hjälp av AddJsonProtocol tilläggsmetoden. AddJsonProtocol kan läggas till efter AddSignalR i Startup.ConfigureServices. Metoden AddJsonProtocol tar en delegat som tar emot ett options objekt. Egenskapen PayloadSerializerOptions för objektet är ett System.Text.JsonJsonSerializerOptions objekt som kan användas för att konfigurera serialisering av argument och returvärden. Mer information finns i dokumentationen om System.Text.Json.

Om du till exempel vill konfigurera serialiseraren så att den inte ändrar versaliseringen för egenskapsnamn, i stället för standardnamnen för kamelfall, använder du följande kod i Program.cs:

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

I .NET-klienten finns samma AddJsonProtocol tilläggsmetod på HubConnectionBuilder. Namnområdet Microsoft.Extensions.DependencyInjection måste importeras för att matcha tilläggsmetoden:

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

Växla till Newtonsoft.Json

Om du behöver funktioner i Newtonsoft.Json som inte stöds i System.Text.Json, kan du se Växla till Newtonsoft.Json.

Serialiseringsalternativ för MessagePack

MessagePack-serialisering kan konfigureras genom att tillhandahålla ett ombud för anropet AddMessagePackProtocol . Mer information finns i MessagePack i SignalR.

Konfigurera serveralternativ

I följande tabell beskrivs alternativ för att SignalR konfigurera hubbar:

Alternativ kan konfigureras för alla hubbar genom att ange ett alternativdelegat till anropet AddSignalR i Program.cs.

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

Alternativ för en enskild hubb åsidosätter de globala alternativ som anges i AddSignalR och kan konfigureras med hjälp av AddHubOptions:

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

Avancerade HTTP-konfigurationsalternativ

Använd HttpConnectionDispatcherOptions för att konfigurera avancerade inställningar som rör transport och hantering av minnesbuffertar. De här alternativen konfigureras genom att ett ombud skickas till MapHub i 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();

I följande tabell beskrivs alternativ för att konfigurera ASP.NET Cores SignalRavancerade HTTP-alternativ:

Long Polling-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen LongPolling :

WebSocket-transporten har ytterligare alternativ som kan konfigureras med hjälp av egenskapen WebSockets :

Konfigurera klientalternativ

Klientalternativ kan konfigureras för HubConnectionBuilder typen (finns i .NET- och JavaScript-klienterna). Den är också tillgänglig i Java-klienten, men underklassen HttpHubConnectionBuilder är det som innehåller konfigurationsalternativen för builder, samt finns dessa också på HubConnection själv.

Konfigurera loggning

Loggning konfigureras i .NET-klienten med hjälp av ConfigureLogging metoden . Loggningsleverantörer och filter kan registreras på samma sätt som de registreras på servern. Mer information finns i dokumentationen om loggning i ASP.NET Core .

Om du till exempel vill aktivera konsolloggning installerar du Microsoft.Extensions.Logging.Console NuGet-paketet. AddConsole Anropa tilläggsmetoden:

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

Det finns en liknande configureLogging metod i JavaScript-klienten. Ange ett LogLevel värde som anger den minsta nivån av loggmeddelanden som ska skapas. Loggar skrivs till webbläsarkonsolfönstret.

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

I stället för ett LogLevel värde kan du också ange ett string värde som representerar ett namn på loggnivå. Detta är användbart när du konfigurerar loggning SignalR i miljöer där du inte har åtkomst till konstanterna LogLevel .

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

I följande tabell visas de tillgängliga loggnivåerna. Det värde som du anger för anger configureLogging den minsta loggnivå som ska loggas. Meddelanden som loggas på den här nivån , eller de nivåer som anges efter det i tabellen, loggas.

Mer information om loggning finns i dokumentationen omSignalR diagnostik.

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

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

Om du inte konfigurerar loggning i dina beroenden laddar SLF4J en standardlogger utan operation med följande varningsmeddelande:

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.

Detta kan ignoreras på ett säkert sätt.

Konfigurera tillåtna transporter

De transporter som används av SignalR kan konfigureras i anropet WithUrl (withUrl i JavaScript). En bitvis OR-operation av värdena HttpTransportType kan användas för att begränsa klienten till att använda endast de angivna transporterna. Alla transporter är aktiverade som standard.

Om du till exempel vill inaktivera Server-Sent Events-transporten, men tillåta WebSockets- och Long Polling-anslutningar:

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

I JavaScript-klienten konfigureras transporterna genom att ställa in transport-fältet på de alternativ som ges till withUrl:

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

I den här versionen av Java-klienten är WebSockets den enda tillgängliga transporten.

I Java-klienten väljs transporten med withTransport -metoden på HttpHubConnectionBuilder. Java-klienten använder som standard WebSockets-transporten.

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

Konfigurera ägarautentisering

Om du vill tillhandahålla autentiseringsdata tillsammans med SignalR begäranden använder du AccessTokenProvider alternativet (accessTokenFactory i JavaScript) för att ange en funktion som returnerar önskad åtkomsttoken. I .NET-klienten skickas den här åtkomsttoken som en HTTP-token för bärarautentisering (Använd Authorization header med en typ av Bearer). I JavaScript-klienten används åtkomsttoken som en Bearer-token, förutom i några fall där webbläsar-API:er begränsar möjligheten att tillämpa rubriker (särskilt i Server-Sent-händelser och WebSockets-begäranden). I dessa fall anges åtkomsttoken som ett frågesträngsvärde access_token.

I .NET-klienten kan AccessTokenProvider-alternativet anges med hjälp av alternativens delegering i WithUrl:

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

I JavaScript-klienten konfigureras åtkomsttoken genom att ange accessTokenFactory fältet på alternativobjektet i 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();

I Java-klienten SignalR kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en åtkomsttokenfabrik till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

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

Konfigurera timeout- och keep-alive-alternativ

Ytterligare alternativ för att konfigurera timeout och keep-alive-beteende är tillgängliga för HubConnection själva objektet:

Konfigurera ytterligare alternativ

Ytterligare alternativ kan konfigureras i WithUrl metoden (withUrl i JavaScript) på HubConnectionBuilder eller på de olika konfigurations-API:erna på HttpHubConnectionBuilder i Java-klienten:

I .NET-klienten kan dessa alternativ ändras via alternativdelegaten som tillhandahålls till 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();

I JavaScript-klienten kan dessa alternativ anges i ett JavaScript-objekt som tillhandahålls till 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();

I Java-klienten kan dessa alternativ konfigureras med metoderna för de HttpHubConnectionBuilder som returneras från HubConnectionBuilder.create("HUB URL")

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

Ytterligare resurser

• Kom igång med ASP.NET Core SignalR
• Använda hubbar i ASP.NET Core SignalR
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient
• Använda MessagePack Hub Protocol i SignalR för ASP.NET Core
• ASP.NET Core SignalR plattformar som stöds