Configuração do ASP.NET Core SignalR

Opções de serialização JSON/MessagePack

ASP.NET Core SignalR suporta dois protocolos para codificação de mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.

A serialização JSON pode ser configurada no servidor usando o AddJsonProtocol método de extensão. AddJsonProtocol pode ser adicionado depois AddSignalR em Startup.ConfigureServices. O AddJsonProtocol método usa um delegado que recebe um options objeto. A PayloadSerializerOptions propriedade nesse objeto é um System.Text.JsonJsonSerializerOptions objeto que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, consulte a documentação System.Text.Json.

Por exemplo, para configurar o serializador para não alterar a capitalização dos nomes das propriedades, ao invés de usar os nomes em formato padrão camel case, utilize o seguinte código em :

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe no HubConnectionBuilder. O Microsoft.Extensions.DependencyInjection namespace deve ser importado para resolver o método de extensão:

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

Troque para Newtonsoft.Json

Se precisar de funcionalidades Newtonsoft.Json que não são suportadas no System.Text.Json, consulte Considere mudar para Newtonsoft.Json.

Opções de serialização do MessagePack

A serialização do MessagePack pode ser configurada fornecendo um delegado para a AddMessagePackProtocol chamada. Consulte MessagePack em SignalR para obter mais detalhes.

Configure as opções do servidor

A tabela a seguir descreve as opções para configurar SignalR hubs:

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções à chamada em AddSignalRProgram.cs.

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

As opções de um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas através de AddHubOptions.

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

Opções avançadas de configuração HTTP

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um delegado para MapHub em 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();

A tabela a seguir descreve as opções para configurar as opções avançadas de HTTP do ASP.NET Core SignalR:

O transporte Long Polling tem opções adicionais que podem ser configuradas usando a LongPolling propriedade:

O transporte WebSocket tem opções adicionais que podem ser configuradas usando a WebSockets propriedade:

Configurar opções do cliente

As opções do cliente podem ser configuradas no HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é o que contém as opções de configuração do construtor, bem como no HubConnection próprio cliente.

Configurar registo de logs

O registro em log é configurado no cliente .NET usando o ConfigureLogging método. Os provedores e filtros de provisionamento de logs podem ser registados da mesma forma que no servidor. Consulte a documentação Logging in ASP.NET Core para obter mais informações.

Por exemplo, para habilitar o log do console, instale o Microsoft.Extensions.Logging.Console pacote NuGet. Chame o método de AddConsole extensão:

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

No cliente JavaScript, existe um método semelhante configureLogging . Forneça um LogLevel valor que indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do console do navegador.

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

Em vez de um LogLevel valor, você também pode fornecer um string valor que represente um nome de nível de log. Isso é útil ao configurar os registos de SignalR em ambientes onde não tens acesso às LogLevel constantes.

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

A tabela a seguir lista os níveis de log disponíveis. O valor fornecido para configureLogging define o nível mínimo de log que será registrado. As mensagens registradas nesse nível, ou os níveis listados depois dele na tabela, serão registradas.

Para obter mais informações sobre registo, consulte a Documentação deSignalR Diagnóstico.

O cliente SignalR Java utiliza a biblioteca SLF4J para registo. É uma API de registo de alto nível que permite que os utilizadores da biblioteca escolham a sua própria implementação específica de registo, adicionando uma dependência específica de registo. O trecho de código a seguir mostra como usar java.util.logging com o cliente SignalR Java.

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

Se não configurar o registo das operações nas dependências, o SLF4J carregará um registador de não-operação padrão com a seguinte mensagem de aviso:

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.

Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes utilizados por SignalR podem ser configurados na chamada WithUrl (withUrl em JavaScript). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes estão habilitados por padrão.

Por exemplo, para desativar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Long Polling:

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

No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto options fornecido para withUrl:

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

Nesta versão do cliente Java WebSockets é o único transporte disponível.

No cliente Java, o transporte é selecionado através do método withTransport no HttpHubConnectionBuilder. O cliente Java usa como padrão o transporte WebSockets.

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

Configurar a autenticação do portador

Para fornecer dados de autenticação junto com SignalR solicitações, use a AccessTokenProvider opção (accessTokenFactory em JavaScript) para especificar uma função que retorna o token de acesso desejado. No cliente .NET, este token de acesso é passado como um token de autenticação HTTP "Bearer" (usando o tipo Authorization no cabeçalho Bearer). No cliente JavaScript, o token de acesso é usado como um token Bearer, exceto em alguns casos onde as APIs do navegador restringem a possibilidade de aplicar cabeçalhos (especificamente, em Server-Sent Eventos e solicitações WebSockets). Nesses casos, o token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.

No cliente .NET, a AccessTokenProvider opção pode ser especificada usando as opções delegadas em WithUrl:

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

No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no objeto options em 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();

SignalR No cliente Java, você pode configurar um token de portador para usar para autenticação fornecendo uma fábrica de token de acesso ao HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJavaSingle<String>. Com uma chamada para Single.defer , você pode escrever a lógica para produzir tokens de acesso para o seu cliente.

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

Configurar opções de tempo limite e persistência de conexão

Opções adicionais para configurar o tempo limite e o comportamento keep-alive:

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

Configurar a reconexão com monitoração de estado

SignalR A reconexão com estado reduz o tempo de inatividade percebido dos clientes que têm uma desconexão temporária na sua conexão de rede, como ao alternar conexões de rede ou durante uma breve perda de acesso.

A reconexão com estado alcança isso ao:

• Armazenamento temporário de dados em buffer no servidor e no cliente.
• Confirmação de mensagens recebidas (ACK-ing) pelo servidor e pelo cliente.
• Reconhecer quando uma conexão está ativa e reproduzir mensagens que poderiam ter sido enviadas enquanto a conexão estava inativa.

A reconexão preservando o estado está disponível no .NET 8 ou posterior.

Opte pela reconexão com monitoração de estado no ponto de extremidade do hub do servidor e no cliente:

• Atualize a configuração do ponto de extremidade do hub do servidor para habilitar a opção AllowStatefulReconnects:

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

  Opcionalmente, o tamanho máximo do buffer em bytes permitido pelo servidor pode ser definido globalmente ou para um hub específico com a opção StatefulReconnectBufferSize:

  As opções StatefulReconnectBufferSize definidas globalmente:

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

  A opção StatefulReconnectBufferSize definida para um hub específico:

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

  A opção StatefulReconnectBufferSize é opcional com um padrão de 100.000 bytes.

• Atualize o código do cliente JavaScript ou TypeScript para ativar a opção withStatefulReconnect:

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

  A opção bufferSize é opcional com um padrão de 100.000 bytes.

• Atualize o código do cliente .NET para habilitar a opção WithStatefulReconnect:

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

  A opção StatefulReconnectBufferSize é opcional com um padrão de 100.000 bytes.

Configurar opções adicionais

Opções adicionais podem ser configuradas no método WithUrl (withUrl em JavaScript) no HubConnectionBuilder ou nas várias APIs de configuração no cliente Java HttpHubConnectionBuilder.

No cliente .NET, essas opções podem ser modificadas pelo delegado de opções fornecido para 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();

No Cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido para 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();

No cliente Java, essas opções podem ser configuradas com os métodos no HttpHubConnectionBuilder retornados pelo HubConnectionBuilder.create("HUB URL").

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

Recursos adicionais

• Introdução ao ASP.NET Core SignalR
• Usar concentradores no ASP.NET Core SignalR
• ASP.NET Core SignalR cliente JavaScript
• ASP.NET Core SignalR Cliente .NET
• Utilizar o Protocolo MessagePack Hub no SignalR ASP.NET Core
• ASP.NET Core SignalR plataformas suportadas

Opções de serialização JSON/MessagePack

ASP.NET Core SignalR suporta dois protocolos para codificação de mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.

A serialização JSON pode ser configurada no servidor usando o AddJsonProtocol método de extensão, que pode ser adicionado depois AddSignalR em seu Startup.ConfigureServices método. O AddJsonProtocol método usa um delegado que recebe um options objeto. A PayloadSerializerSettings propriedade nesse objeto é um objeto Json.NET JsonSerializerSettings que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, consulte a documentação do Json.NET.

Por exemplo, para configurar o serializador para usar nomes de propriedade "PascalCase", em vez de nomes padrão em "camel case", use o seguinte código em :

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe no HubConnectionBuilder. O Microsoft.Extensions.DependencyInjection namespace deve ser importado para resolver o método de extensão:

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

Opções de serialização do MessagePack

A serialização do MessagePack pode ser configurada fornecendo um delegado para a AddMessagePackProtocol chamada. Consulte MessagePack em SignalR para obter mais detalhes.

Configure as opções do servidor

A tabela a seguir descreve as opções para configurar SignalR hubs:

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções à chamada em AddSignalRStartup.ConfigureServices.

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

As opções de um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas através de AddHubOptions.

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

Opções avançadas de configuração HTTP

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um delegado para MapHub em 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;
        });
    });
}

A tabela a seguir descreve as opções para configurar as opções avançadas de HTTP do ASP.NET Core SignalR:

O transporte Long Polling tem opções adicionais que podem ser configuradas usando a LongPolling propriedade:

O transporte WebSocket tem opções adicionais que podem ser configuradas usando a WebSockets propriedade:

Configurar opções do cliente

As opções do cliente podem ser configuradas no HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é o que contém as opções de configuração do construtor, bem como no HubConnection próprio cliente.

Configurar registo de logs

O registro em log é configurado no cliente .NET usando o ConfigureLogging método. Os provedores e filtros de provisionamento de logs podem ser registados da mesma forma que no servidor. Consulte a documentação Logging in ASP.NET Core para obter mais informações.

Por exemplo, para habilitar o log do console, instale o Microsoft.Extensions.Logging.Console pacote NuGet. Chame o método de AddConsole extensão:

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

No cliente JavaScript, existe um método semelhante configureLogging . Forneça um LogLevel valor que indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do console do navegador.

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

Para obter mais informações sobre registo, consulte a Documentação deSignalR Diagnóstico.

O cliente SignalR Java utiliza a biblioteca SLF4J para registo. É uma API de registo de alto nível que permite que os utilizadores da biblioteca escolham a sua própria implementação específica de registo, adicionando uma dependência específica de registo. O trecho de código a seguir mostra como usar java.util.logging com o cliente SignalR Java.

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

Se não configurar o registo das operações nas dependências, o SLF4J carregará um registador de não-operação padrão com a seguinte mensagem de aviso:

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.

Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes utilizados por SignalR podem ser configurados na chamada WithUrl (withUrl em JavaScript). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes estão habilitados por padrão.

Por exemplo, para desativar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Long Polling:

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

No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto options fornecido para withUrl:

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

Configurar a autenticação do portador

Para fornecer dados de autenticação junto com SignalR solicitações, use a AccessTokenProvider opção (accessTokenFactory em JavaScript) para especificar uma função que retorna o token de acesso desejado. No cliente .NET, este token de acesso é passado como um token de autenticação HTTP "Bearer" (usando o tipo Authorization no cabeçalho Bearer). No cliente JavaScript, o token de acesso é usado como um token Bearer, exceto em alguns casos onde as APIs do navegador restringem a possibilidade de aplicar cabeçalhos (especificamente, em Server-Sent Eventos e solicitações WebSockets). Nesses casos, o token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.

No cliente .NET, a AccessTokenProvider opção pode ser especificada usando as opções delegadas em WithUrl:

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

No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no objeto options em 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();

SignalR No cliente Java, você pode configurar um token de portador para usar para autenticação fornecendo uma fábrica de token de acesso ao HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJavaSingle<String>. Com uma chamada para Single.defer , você pode escrever a lógica para produzir tokens de acesso para o seu cliente.

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

Configurar opções de tempo limite e persistência de conexão

Opções adicionais para configurar o tempo limite e o comportamento manter-vivo estão disponíveis no próprio objeto:

Configurar opções adicionais

Opções adicionais podem ser configuradas no método WithUrl (withUrl em JavaScript) no HubConnectionBuilder ou nas várias APIs de configuração no cliente Java HttpHubConnectionBuilder.

No cliente .NET, essas opções podem ser modificadas pelo delegado de opções fornecido para WithUrl:

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

No Cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido para withUrl:

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

No cliente Java, essas opções podem ser configuradas com os métodos no HttpHubConnectionBuilder retornados pelo HubConnectionBuilder.create("HUB URL").

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

Recursos adicionais

• Introdução ao ASP.NET Core SignalR
• Usar concentradores no ASP.NET Core SignalR
• ASP.NET Core SignalR cliente JavaScript
• ASP.NET Core SignalR Cliente .NET
• Utilizar o Protocolo MessagePack Hub no SignalR ASP.NET Core
• ASP.NET Core SignalR plataformas suportadas

Opções de serialização JSON/MessagePack

ASP.NET Core SignalR suporta dois protocolos para codificação de mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.

A serialização JSON pode ser configurada no servidor usando o AddJsonProtocol método de extensão, que pode ser adicionado depois AddSignalR em seu Startup.ConfigureServices método. O AddJsonProtocol método usa um delegado que recebe um options objeto. A PayloadSerializerSettings propriedade nesse objeto é um objeto Json.NET JsonSerializerSettings que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, consulte a documentação do Json.NET.

Por exemplo, para configurar o serializador para usar nomes de propriedade "PascalCase", em vez de nomes padrão em "camel case", use o seguinte código em :

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe no HubConnectionBuilder. O Microsoft.Extensions.DependencyInjection namespace deve ser importado para resolver o método de extensão:

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

Opções de serialização do MessagePack

A serialização do MessagePack pode ser configurada fornecendo um delegado para a AddMessagePackProtocol chamada. Consulte MessagePack em SignalR para obter mais detalhes.

Configure as opções do servidor

A tabela a seguir descreve as opções para configurar SignalR hubs:

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções à chamada em AddSignalRStartup.ConfigureServices.

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

As opções de um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas através de AddHubOptions.

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

Opções avançadas de configuração HTTP

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um delegado para MapHub em 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;
        });
    });
}

A tabela a seguir descreve as opções para configurar as opções avançadas de HTTP do ASP.NET Core SignalR:

O transporte Long Polling tem opções adicionais que podem ser configuradas usando a LongPolling propriedade:

O transporte WebSocket tem opções adicionais que podem ser configuradas usando a WebSockets propriedade:

Configurar opções do cliente

As opções do cliente podem ser configuradas no HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é o que contém as opções de configuração do construtor, bem como no HubConnection próprio cliente.

Configurar registo de logs

O registro em log é configurado no cliente .NET usando o ConfigureLogging método. Os provedores e filtros de provisionamento de logs podem ser registados da mesma forma que no servidor. Consulte a documentação Logging in ASP.NET Core para obter mais informações.

Por exemplo, para habilitar o log do console, instale o Microsoft.Extensions.Logging.Console pacote NuGet. Chame o método de AddConsole extensão:

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

No cliente JavaScript, existe um método semelhante configureLogging . Forneça um LogLevel valor que indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do console do navegador.

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

Para obter mais informações sobre registo, consulte a Documentação deSignalR Diagnóstico.

O cliente SignalR Java utiliza a biblioteca SLF4J para registo. É uma API de registo de alto nível que permite que os utilizadores da biblioteca escolham a sua própria implementação específica de registo, adicionando uma dependência específica de registo. O trecho de código a seguir mostra como usar java.util.logging com o cliente SignalR Java.

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

Se não configurar o registo das operações nas dependências, o SLF4J carregará um registador de não-operação padrão com a seguinte mensagem de aviso:

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.

Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes utilizados por SignalR podem ser configurados na chamada WithUrl (withUrl em JavaScript). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes estão habilitados por padrão.

Por exemplo, para desativar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Long Polling:

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

No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto options fornecido para withUrl:

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

Nesta versão do cliente Java WebSockets é o único transporte disponível.

Configurar a autenticação do portador

Para fornecer dados de autenticação junto com SignalR solicitações, use a AccessTokenProvider opção (accessTokenFactory em JavaScript) para especificar uma função que retorna o token de acesso desejado. No cliente .NET, este token de acesso é passado como um token de autenticação HTTP "Bearer" (usando o tipo Authorization no cabeçalho Bearer). No cliente JavaScript, o token de acesso é usado como um token Bearer, exceto em alguns casos onde as APIs do navegador restringem a possibilidade de aplicar cabeçalhos (especificamente, em Server-Sent Eventos e solicitações WebSockets). Nesses casos, o token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.

No cliente .NET, a AccessTokenProvider opção pode ser especificada usando as opções delegadas em WithUrl:

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

No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no objeto options em 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();

SignalR No cliente Java, você pode configurar um token de portador para usar para autenticação fornecendo uma fábrica de token de acesso ao HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJavaSingle<String>. Com uma chamada para Single.defer , você pode escrever a lógica para produzir tokens de acesso para o seu cliente.

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

Configurar opções de tempo limite e persistência de conexão

Opções adicionais para configurar o tempo limite e o comportamento manter-vivo estão disponíveis no próprio objeto:

Configurar opções adicionais

Opções adicionais podem ser configuradas no método WithUrl (withUrl em JavaScript) no HubConnectionBuilder ou nas várias APIs de configuração no cliente Java HttpHubConnectionBuilder.

No cliente .NET, essas opções podem ser modificadas pelo delegado de opções fornecido para WithUrl:

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

No Cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido para withUrl:

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

No cliente Java, essas opções podem ser configuradas com os métodos no HttpHubConnectionBuilder retornados pelo HubConnectionBuilder.create("HUB URL").

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

Recursos adicionais

• Introdução ao ASP.NET Core SignalR
• Usar concentradores no ASP.NET Core SignalR
• ASP.NET Core SignalR cliente JavaScript
• ASP.NET Core SignalR Cliente .NET
• Utilizar o Protocolo MessagePack Hub no SignalR ASP.NET Core
• ASP.NET Core SignalR plataformas suportadas

Opções de serialização JSON/MessagePack

ASP.NET Core SignalR suporta dois protocolos para codificação de mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.

A serialização JSON pode ser configurada no servidor usando o AddJsonProtocol método de extensão. AddJsonProtocol pode ser adicionado depois AddSignalR em Startup.ConfigureServices. O AddJsonProtocol método usa um delegado que recebe um options objeto. A PayloadSerializerOptions propriedade nesse objeto é um System.Text.JsonJsonSerializerOptions objeto que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, consulte a documentação System.Text.Json.

Por exemplo, para configurar o serializador para não alterar a capitalização dos nomes das propriedades, ao invés de usar os nomes em formato padrão camel case, utilize o seguinte código em :

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe no HubConnectionBuilder. O Microsoft.Extensions.DependencyInjection namespace deve ser importado para resolver o método de extensão:

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

Troque para Newtonsoft.Json

Se precisar de funcionalidades Newtonsoft.Json que não são suportadas no System.Text.Json, consulte Considere mudar para Newtonsoft.Json.

Opções de serialização do MessagePack

A serialização do MessagePack pode ser configurada fornecendo um delegado para a AddMessagePackProtocol chamada. Consulte MessagePack em SignalR para obter mais detalhes.

Configure as opções do servidor

A tabela a seguir descreve as opções para configurar SignalR hubs:

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções à chamada em AddSignalRStartup.ConfigureServices.

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

As opções de um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas através de AddHubOptions.

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

Opções avançadas de configuração HTTP

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um delegado para MapHub em 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;
        });
    });
}

A tabela a seguir descreve as opções para configurar as opções avançadas de HTTP do ASP.NET Core SignalR:

O transporte Long Polling tem opções adicionais que podem ser configuradas usando a LongPolling propriedade:

O transporte WebSocket tem opções adicionais que podem ser configuradas usando a WebSockets propriedade:

Configurar opções do cliente

As opções do cliente podem ser configuradas no HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é o que contém as opções de configuração do construtor, bem como no HubConnection próprio cliente.

Configurar registo de logs

O registro em log é configurado no cliente .NET usando o ConfigureLogging método. Os provedores e filtros de provisionamento de logs podem ser registados da mesma forma que no servidor. Consulte a documentação Logging in ASP.NET Core para obter mais informações.

Por exemplo, para habilitar o log do console, instale o Microsoft.Extensions.Logging.Console pacote NuGet. Chame o método de AddConsole extensão:

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

No cliente JavaScript, existe um método semelhante configureLogging . Forneça um LogLevel valor que indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do console do navegador.

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

Em vez de um LogLevel valor, você também pode fornecer um string valor que represente um nome de nível de log. Isso é útil ao configurar os registos de SignalR em ambientes onde não tens acesso às LogLevel constantes.

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

A tabela a seguir lista os níveis de log disponíveis. O valor fornecido para configureLogging define o nível mínimo de log que será registrado. As mensagens registradas nesse nível, ou os níveis listados depois dele na tabela, serão registradas.

Para obter mais informações sobre registo, consulte a Documentação deSignalR Diagnóstico.

O cliente SignalR Java utiliza a biblioteca SLF4J para registo. É uma API de registo de alto nível que permite que os utilizadores da biblioteca escolham a sua própria implementação específica de registo, adicionando uma dependência específica de registo. O trecho de código a seguir mostra como usar java.util.logging com o cliente SignalR Java.

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

Se não configurar o registo das operações nas dependências, o SLF4J carregará um registador de não-operação padrão com a seguinte mensagem de aviso:

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.

Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes utilizados por SignalR podem ser configurados na chamada WithUrl (withUrl em JavaScript). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes estão habilitados por padrão.

Por exemplo, para desativar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Long Polling:

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

No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto options fornecido para withUrl:

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

Nesta versão do cliente Java WebSockets é o único transporte disponível.

No cliente Java, o transporte é selecionado através do método withTransport no HttpHubConnectionBuilder. O cliente Java usa como padrão o transporte WebSockets.

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

Configurar a autenticação do portador

Para fornecer dados de autenticação junto com SignalR solicitações, use a AccessTokenProvider opção (accessTokenFactory em JavaScript) para especificar uma função que retorna o token de acesso desejado. No cliente .NET, este token de acesso é passado como um token de autenticação HTTP "Bearer" (usando o tipo Authorization no cabeçalho Bearer). No cliente JavaScript, o token de acesso é usado como um token Bearer, exceto em alguns casos onde as APIs do navegador restringem a possibilidade de aplicar cabeçalhos (especificamente, em Server-Sent Eventos e solicitações WebSockets). Nesses casos, o token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.

No cliente .NET, a AccessTokenProvider opção pode ser especificada usando as opções delegadas em WithUrl:

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

No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no objeto options em 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();

SignalR No cliente Java, você pode configurar um token de portador para usar para autenticação fornecendo uma fábrica de token de acesso ao HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJavaSingle<String>. Com uma chamada para Single.defer , você pode escrever a lógica para produzir tokens de acesso para o seu cliente.

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

Configurar opções de tempo limite e persistência de conexão

Opções adicionais para configurar o tempo limite e o comportamento manter-vivo estão disponíveis no próprio objeto:

Configurar opções adicionais

Opções adicionais podem ser configuradas no método WithUrl (withUrl em JavaScript) no HubConnectionBuilder ou nas várias APIs de configuração no cliente Java HttpHubConnectionBuilder.

No cliente .NET, essas opções podem ser modificadas pelo delegado de opções fornecido para WithUrl:

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

No Cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido para withUrl:

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

No cliente Java, essas opções podem ser configuradas com os métodos no HttpHubConnectionBuilder retornados pelo HubConnectionBuilder.create("HUB URL").

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

Recursos adicionais

• Introdução ao ASP.NET Core SignalR
• Usar concentradores no ASP.NET Core SignalR
• ASP.NET Core SignalR cliente JavaScript
• ASP.NET Core SignalR Cliente .NET
• Utilizar o Protocolo MessagePack Hub no SignalR ASP.NET Core
• ASP.NET Core SignalR plataformas suportadas

Opções de serialização JSON/MessagePack

ASP.NET Core SignalR suporta dois protocolos para codificação de mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.

A serialização JSON pode ser configurada no servidor usando o AddJsonProtocol método de extensão. AddJsonProtocol pode ser adicionado depois AddSignalR em Startup.ConfigureServices. O AddJsonProtocol método usa um delegado que recebe um options objeto. A PayloadSerializerOptions propriedade nesse objeto é um System.Text.JsonJsonSerializerOptions objeto que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, consulte a documentação System.Text.Json.

Por exemplo, para configurar o serializador para não alterar a capitalização dos nomes das propriedades, ao invés de usar os nomes em formato padrão camel case, utilize o seguinte código em :

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe no HubConnectionBuilder. O Microsoft.Extensions.DependencyInjection namespace deve ser importado para resolver o método de extensão:

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

Troque para Newtonsoft.Json

Se precisar de funcionalidades Newtonsoft.Json que não são suportadas no System.Text.Json, consulte Considere mudar para Newtonsoft.Json.

Opções de serialização do MessagePack

A serialização do MessagePack pode ser configurada fornecendo um delegado para a AddMessagePackProtocol chamada. Consulte MessagePack em SignalR para obter mais detalhes.

Configure as opções do servidor

A tabela a seguir descreve as opções para configurar SignalR hubs:

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções à chamada em AddSignalRStartup.ConfigureServices.

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

As opções de um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas através de AddHubOptions.

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

Opções avançadas de configuração HTTP

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um delegado para MapHub em 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;
        });
    });
}

A tabela a seguir descreve as opções para configurar as opções avançadas de HTTP do ASP.NET Core SignalR:

O transporte Long Polling tem opções adicionais que podem ser configuradas usando a LongPolling propriedade:

O transporte WebSocket tem opções adicionais que podem ser configuradas usando a WebSockets propriedade:

Configurar opções do cliente

As opções do cliente podem ser configuradas no HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é o que contém as opções de configuração do construtor, bem como no HubConnection próprio cliente.

Configurar registo de logs

O registro em log é configurado no cliente .NET usando o ConfigureLogging método. Os provedores e filtros de provisionamento de logs podem ser registados da mesma forma que no servidor. Consulte a documentação Logging in ASP.NET Core para obter mais informações.

Por exemplo, para habilitar o log do console, instale o Microsoft.Extensions.Logging.Console pacote NuGet. Chame o método de AddConsole extensão:

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

No cliente JavaScript, existe um método semelhante configureLogging . Forneça um LogLevel valor que indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do console do navegador.

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

Em vez de um LogLevel valor, você também pode fornecer um string valor que represente um nome de nível de log. Isso é útil ao configurar os registos de SignalR em ambientes onde não tens acesso às LogLevel constantes.

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

A tabela a seguir lista os níveis de log disponíveis. O valor fornecido para configureLogging define o nível mínimo de log que será registrado. As mensagens registradas nesse nível, ou os níveis listados depois dele na tabela, serão registradas.

Para obter mais informações sobre registo, consulte a Documentação deSignalR Diagnóstico.

O cliente SignalR Java utiliza a biblioteca SLF4J para registo. É uma API de registo de alto nível que permite que os utilizadores da biblioteca escolham a sua própria implementação específica de registo, adicionando uma dependência específica de registo. O trecho de código a seguir mostra como usar java.util.logging com o cliente SignalR Java.

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

Se não configurar o registo das operações nas dependências, o SLF4J carregará um registador de não-operação padrão com a seguinte mensagem de aviso:

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.

Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes utilizados por SignalR podem ser configurados na chamada WithUrl (withUrl em JavaScript). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes estão habilitados por padrão.

Por exemplo, para desativar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Long Polling:

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

No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto options fornecido para withUrl:

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

Nesta versão do cliente Java WebSockets é o único transporte disponível.

No cliente Java, o transporte é selecionado através do método withTransport no HttpHubConnectionBuilder. O cliente Java usa como padrão o transporte WebSockets.

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

Configurar a autenticação do portador

Para fornecer dados de autenticação junto com SignalR solicitações, use a AccessTokenProvider opção (accessTokenFactory em JavaScript) para especificar uma função que retorna o token de acesso desejado. No cliente .NET, este token de acesso é passado como um token de autenticação HTTP "Bearer" (usando o tipo Authorization no cabeçalho Bearer). No cliente JavaScript, o token de acesso é usado como um token Bearer, exceto em alguns casos onde as APIs do navegador restringem a possibilidade de aplicar cabeçalhos (especificamente, em Server-Sent Eventos e solicitações WebSockets). Nesses casos, o token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.

No cliente .NET, a AccessTokenProvider opção pode ser especificada usando as opções delegadas em WithUrl:

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

No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no objeto options em 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();

SignalR No cliente Java, você pode configurar um token de portador para usar para autenticação fornecendo uma fábrica de token de acesso ao HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJavaSingle<String>. Com uma chamada para Single.defer , você pode escrever a lógica para produzir tokens de acesso para o seu cliente.

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

Configurar opções de tempo limite e persistência de conexão

Opções adicionais para configurar o tempo limite e o comportamento manter-vivo estão disponíveis no próprio objeto:

Configurar opções adicionais

Opções adicionais podem ser configuradas no método WithUrl (withUrl em JavaScript) no HubConnectionBuilder ou nas várias APIs de configuração no cliente Java HttpHubConnectionBuilder.

No cliente .NET, essas opções podem ser modificadas pelo delegado de opções fornecido para WithUrl:

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

No Cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido para withUrl:

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

No cliente Java, essas opções podem ser configuradas com os métodos no HttpHubConnectionBuilder retornados pelo HubConnectionBuilder.create("HUB URL").

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

Recursos adicionais

• Introdução ao ASP.NET Core SignalR
• Usar concentradores no ASP.NET Core SignalR
• ASP.NET Core SignalR cliente JavaScript
• ASP.NET Core SignalR Cliente .NET
• Utilizar o Protocolo MessagePack Hub no SignalR ASP.NET Core
• ASP.NET Core SignalR plataformas suportadas

Opções de serialização JSON/MessagePack

ASP.NET Core SignalR suporta dois protocolos para codificação de mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.

A serialização JSON pode ser configurada no servidor usando o AddJsonProtocol método de extensão. AddJsonProtocol pode ser adicionado depois AddSignalR em Startup.ConfigureServices. O AddJsonProtocol método usa um delegado que recebe um options objeto. A PayloadSerializerOptions propriedade nesse objeto é um System.Text.JsonJsonSerializerOptions objeto que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, consulte a documentação System.Text.Json.

Por exemplo, para configurar o serializador para não alterar a capitalização dos nomes das propriedades, ao invés de usar os nomes em formato padrão camel case, utilize o seguinte código em :

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe no HubConnectionBuilder. O Microsoft.Extensions.DependencyInjection namespace deve ser importado para resolver o método de extensão:

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

Troque para Newtonsoft.Json

Se precisar de funcionalidades Newtonsoft.Json que não são suportadas no System.Text.Json, consulte Considere mudar para Newtonsoft.Json.

Opções de serialização do MessagePack

A serialização do MessagePack pode ser configurada fornecendo um delegado para a AddMessagePackProtocol chamada. Consulte MessagePack em SignalR para obter mais detalhes.

Configure as opções do servidor

A tabela a seguir descreve as opções para configurar SignalR hubs:

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções à chamada em AddSignalRStartup.ConfigureServices.

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

As opções de um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas através de AddHubOptions.

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

Opções avançadas de configuração HTTP

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um delegado para MapHub em 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;
        });
    });
}

A tabela a seguir descreve as opções para configurar as opções avançadas de HTTP do ASP.NET Core SignalR:

O transporte Long Polling tem opções adicionais que podem ser configuradas usando a LongPolling propriedade:

O transporte WebSocket tem opções adicionais que podem ser configuradas usando a WebSockets propriedade:

Configurar opções do cliente

As opções do cliente podem ser configuradas no HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é o que contém as opções de configuração do construtor, bem como no HubConnection próprio cliente.

Configurar registo de logs

O registro em log é configurado no cliente .NET usando o ConfigureLogging método. Os provedores e filtros de provisionamento de logs podem ser registados da mesma forma que no servidor. Consulte a documentação Logging in ASP.NET Core para obter mais informações.

Por exemplo, para habilitar o log do console, instale o Microsoft.Extensions.Logging.Console pacote NuGet. Chame o método de AddConsole extensão:

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

No cliente JavaScript, existe um método semelhante configureLogging . Forneça um LogLevel valor que indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do console do navegador.

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

Em vez de um LogLevel valor, você também pode fornecer um string valor que represente um nome de nível de log. Isso é útil ao configurar os registos de SignalR em ambientes onde não tens acesso às LogLevel constantes.

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

A tabela a seguir lista os níveis de log disponíveis. O valor fornecido para configureLogging define o nível mínimo de log que será registrado. As mensagens registradas nesse nível, ou os níveis listados depois dele na tabela, serão registradas.

Para obter mais informações sobre registo, consulte a Documentação deSignalR Diagnóstico.

O cliente SignalR Java utiliza a biblioteca SLF4J para registo. É uma API de registo de alto nível que permite que os utilizadores da biblioteca escolham a sua própria implementação específica de registo, adicionando uma dependência específica de registo. O trecho de código a seguir mostra como usar java.util.logging com o cliente SignalR Java.

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

Se não configurar o registo das operações nas dependências, o SLF4J carregará um registador de não-operação padrão com a seguinte mensagem de aviso:

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.

Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes utilizados por SignalR podem ser configurados na chamada WithUrl (withUrl em JavaScript). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes estão habilitados por padrão.

Por exemplo, para desativar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Long Polling:

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

No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto options fornecido para withUrl:

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

Nesta versão do cliente Java WebSockets é o único transporte disponível.

No cliente Java, o transporte é selecionado através do método withTransport no HttpHubConnectionBuilder. O cliente Java usa como padrão o transporte WebSockets.

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

Configurar a autenticação do portador

Para fornecer dados de autenticação junto com SignalR solicitações, use a AccessTokenProvider opção (accessTokenFactory em JavaScript) para especificar uma função que retorna o token de acesso desejado. No cliente .NET, este token de acesso é passado como um token de autenticação HTTP "Bearer" (usando o tipo Authorization no cabeçalho Bearer). No cliente JavaScript, o token de acesso é usado como um token Bearer, exceto em alguns casos onde as APIs do navegador restringem a possibilidade de aplicar cabeçalhos (especificamente, em Server-Sent Eventos e solicitações WebSockets). Nesses casos, o token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.

No cliente .NET, a AccessTokenProvider opção pode ser especificada usando as opções delegadas em WithUrl:

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

No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no objeto options em 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();

SignalR No cliente Java, você pode configurar um token de portador para usar para autenticação fornecendo uma fábrica de token de acesso ao HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJavaSingle<String>. Com uma chamada para Single.defer , você pode escrever a lógica para produzir tokens de acesso para o seu cliente.

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

Configurar opções de tempo limite e persistência de conexão

Opções adicionais para configurar o tempo limite e o comportamento manter-vivo estão disponíveis no próprio objeto:

Configurar opções adicionais

Opções adicionais podem ser configuradas no método WithUrl (withUrl em JavaScript) no HubConnectionBuilder ou nas várias APIs de configuração no cliente Java HttpHubConnectionBuilder.

No cliente .NET, essas opções podem ser modificadas pelo delegado de opções fornecido para 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();

No Cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido para 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();

No cliente Java, essas opções podem ser configuradas com os métodos no HttpHubConnectionBuilder retornados pelo HubConnectionBuilder.create("HUB URL").

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

Recursos adicionais

• Introdução ao ASP.NET Core SignalR
• Usar concentradores no ASP.NET Core SignalR
• ASP.NET Core SignalR cliente JavaScript
• ASP.NET Core SignalR Cliente .NET
• Utilizar o Protocolo MessagePack Hub no SignalR ASP.NET Core
• ASP.NET Core SignalR plataformas suportadas

Opções de serialização JSON/MessagePack

ASP.NET Core SignalR suporta dois protocolos para codificação de mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.

A serialização JSON pode ser configurada no servidor usando o AddJsonProtocol método de extensão. AddJsonProtocol pode ser adicionado depois AddSignalR em Program.cs. O AddJsonProtocol método usa um delegado que recebe um options objeto. A PayloadSerializerOptions propriedade nesse objeto é um System.Text.JsonJsonSerializerOptions objeto que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, consulte a documentação System.Text.Json.

Por exemplo, para configurar o serializador para não alterar a capitalização dos nomes das propriedades, ao invés de usar os nomes em formato padrão camel case, utilize o seguinte código em :

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe no HubConnectionBuilder. O Microsoft.Extensions.DependencyInjection namespace deve ser importado para resolver o método de extensão:

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

Troque para Newtonsoft.Json

Se precisar de funcionalidades Newtonsoft.Json que não são suportadas no System.Text.Json, consulte Considere mudar para Newtonsoft.Json.

Opções de serialização do MessagePack

A serialização do MessagePack pode ser configurada fornecendo um delegado para a AddMessagePackProtocol chamada. Consulte MessagePack em SignalR para obter mais detalhes.

Configure as opções do servidor

A tabela a seguir descreve as opções para configurar SignalR hubs:

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções à chamada em AddSignalRProgram.cs.

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

As opções de um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas através de AddHubOptions.

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

Opções avançadas de configuração HTTP

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um delegado para MapHub em 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();

A tabela a seguir descreve as opções para configurar as opções avançadas de HTTP do ASP.NET Core SignalR:

O transporte Long Polling tem opções adicionais que podem ser configuradas usando a LongPolling propriedade:

O transporte WebSocket tem opções adicionais que podem ser configuradas usando a WebSockets propriedade:

Configurar opções do cliente

As opções do cliente podem ser configuradas no HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é o que contém as opções de configuração do construtor, bem como no HubConnection próprio cliente.

Configurar registo de logs

O registro em log é configurado no cliente .NET usando o ConfigureLogging método. Os provedores e filtros de provisionamento de logs podem ser registados da mesma forma que no servidor. Consulte a documentação Logging in ASP.NET Core para obter mais informações.

Por exemplo, para habilitar o log do console, instale o Microsoft.Extensions.Logging.Console pacote NuGet. Chame o método de AddConsole extensão:

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

No cliente JavaScript, existe um método semelhante configureLogging . Forneça um LogLevel valor que indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do console do navegador.

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

Em vez de um LogLevel valor, você também pode fornecer um string valor que represente um nome de nível de log. Isso é útil ao configurar os registos de SignalR em ambientes onde não tens acesso às LogLevel constantes.

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

A tabela a seguir lista os níveis de log disponíveis. O valor fornecido para configureLogging define o nível mínimo de log que será registrado. As mensagens registradas nesse nível, ou os níveis listados depois dele na tabela, serão registradas.

Para obter mais informações sobre registo, consulte a Documentação deSignalR Diagnóstico.

O cliente SignalR Java utiliza a biblioteca SLF4J para registo. É uma API de registo de alto nível que permite que os utilizadores da biblioteca escolham a sua própria implementação específica de registo, adicionando uma dependência específica de registo. O trecho de código a seguir mostra como usar java.util.logging com o cliente SignalR Java.

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

Se não configurar o registo das operações nas dependências, o SLF4J carregará um registador de não-operação padrão com a seguinte mensagem de aviso:

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.

Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes utilizados por SignalR podem ser configurados na chamada WithUrl (withUrl em JavaScript). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes estão habilitados por padrão.

Por exemplo, para desativar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Long Polling:

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

No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto options fornecido para withUrl:

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

Nesta versão do cliente Java WebSockets é o único transporte disponível.

No cliente Java, o transporte é selecionado através do método withTransport no HttpHubConnectionBuilder. O cliente Java usa como padrão o transporte WebSockets.

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

Configurar a autenticação do portador

Para fornecer dados de autenticação junto com SignalR solicitações, use a AccessTokenProvider opção (accessTokenFactory em JavaScript) para especificar uma função que retorna o token de acesso desejado. No cliente .NET, este token de acesso é passado como um token de autenticação HTTP "Bearer" (usando o tipo Authorization no cabeçalho Bearer). No cliente JavaScript, o token de acesso é usado como um token Bearer, exceto em alguns casos onde as APIs do navegador restringem a possibilidade de aplicar cabeçalhos (especificamente, em Server-Sent Eventos e solicitações WebSockets). Nesses casos, o token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.

No cliente .NET, a AccessTokenProvider opção pode ser especificada usando as opções delegadas em WithUrl:

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

No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no objeto options em 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();

SignalR No cliente Java, você pode configurar um token de portador para usar para autenticação fornecendo uma fábrica de token de acesso ao HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJavaSingle<String>. Com uma chamada para Single.defer , você pode escrever a lógica para produzir tokens de acesso para o seu cliente.

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

Configurar opções de tempo limite e persistência de conexão

Opções adicionais para configurar o tempo limite e o comportamento manter-vivo estão disponíveis no próprio objeto:

Configurar opções adicionais

Opções adicionais podem ser configuradas no método WithUrl (withUrl em JavaScript) no HubConnectionBuilder ou nas várias APIs de configuração no cliente Java HttpHubConnectionBuilder.

No cliente .NET, essas opções podem ser modificadas pelo delegado de opções fornecido para 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();

No Cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido para 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();

No cliente Java, essas opções podem ser configuradas com os métodos no HttpHubConnectionBuilder retornados pelo HubConnectionBuilder.create("HUB URL").

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

Recursos adicionais

• Introdução ao ASP.NET Core SignalR
• Usar concentradores no ASP.NET Core SignalR
• ASP.NET Core SignalR cliente JavaScript
• ASP.NET Core SignalR Cliente .NET
• Utilizar o Protocolo MessagePack Hub no SignalR ASP.NET Core
• ASP.NET Core SignalR plataformas suportadas

Opções de serialização JSON/MessagePack

ASP.NET Core SignalR suporta dois protocolos para codificação de mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.

A serialização JSON pode ser configurada no servidor usando o AddJsonProtocol método de extensão. AddJsonProtocol pode ser adicionado depois AddSignalR em Startup.ConfigureServices. O AddJsonProtocol método usa um delegado que recebe um options objeto. A PayloadSerializerOptions propriedade nesse objeto é um System.Text.JsonJsonSerializerOptions objeto que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, consulte a documentação System.Text.Json.

Por exemplo, para configurar o serializador para não alterar a capitalização dos nomes das propriedades, ao invés de usar os nomes em formato padrão camel case, utilize o seguinte código em :

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe no HubConnectionBuilder. O Microsoft.Extensions.DependencyInjection namespace deve ser importado para resolver o método de extensão:

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

Troque para Newtonsoft.Json

Se precisar de funcionalidades Newtonsoft.Json que não são suportadas no System.Text.Json, consulte Considere mudar para Newtonsoft.Json.

Opções de serialização do MessagePack

A serialização do MessagePack pode ser configurada fornecendo um delegado para a AddMessagePackProtocol chamada. Consulte MessagePack em SignalR para obter mais detalhes.

Configure as opções do servidor

A tabela a seguir descreve as opções para configurar SignalR hubs:

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções à chamada em AddSignalRProgram.cs.

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

As opções de um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas através de AddHubOptions.

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

Opções avançadas de configuração HTTP

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um delegado para MapHub em 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();

A tabela a seguir descreve as opções para configurar as opções avançadas de HTTP do ASP.NET Core SignalR:

O transporte Long Polling tem opções adicionais que podem ser configuradas usando a LongPolling propriedade:

O transporte WebSocket tem opções adicionais que podem ser configuradas usando a WebSockets propriedade:

Configurar opções do cliente

As opções do cliente podem ser configuradas no HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é o que contém as opções de configuração do construtor, bem como no HubConnection próprio cliente.

Configurar registo de logs

O registro em log é configurado no cliente .NET usando o ConfigureLogging método. Os provedores e filtros de provisionamento de logs podem ser registados da mesma forma que no servidor. Consulte a documentação Logging in ASP.NET Core para obter mais informações.

Por exemplo, para habilitar o log do console, instale o Microsoft.Extensions.Logging.Console pacote NuGet. Chame o método de AddConsole extensão:

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

No cliente JavaScript, existe um método semelhante configureLogging . Forneça um LogLevel valor que indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do console do navegador.

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

Em vez de um LogLevel valor, você também pode fornecer um string valor que represente um nome de nível de log. Isso é útil ao configurar os registos de SignalR em ambientes onde não tens acesso às LogLevel constantes.

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

A tabela a seguir lista os níveis de log disponíveis. O valor fornecido para configureLogging define o nível mínimo de log que será registrado. As mensagens registradas nesse nível, ou os níveis listados depois dele na tabela, serão registradas.

Para obter mais informações sobre registo, consulte a Documentação deSignalR Diagnóstico.

O cliente SignalR Java utiliza a biblioteca SLF4J para registo. É uma API de registo de alto nível que permite que os utilizadores da biblioteca escolham a sua própria implementação específica de registo, adicionando uma dependência específica de registo. O trecho de código a seguir mostra como usar java.util.logging com o cliente SignalR Java.

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

Se não configurar o registo das operações nas dependências, o SLF4J carregará um registador de não-operação padrão com a seguinte mensagem de aviso:

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.

Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes utilizados por SignalR podem ser configurados na chamada WithUrl (withUrl em JavaScript). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes estão habilitados por padrão.

Por exemplo, para desativar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Long Polling:

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

No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto options fornecido para withUrl:

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

Nesta versão do cliente Java WebSockets é o único transporte disponível.

No cliente Java, o transporte é selecionado através do método withTransport no HttpHubConnectionBuilder. O cliente Java usa como padrão o transporte WebSockets.

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

Configurar a autenticação do portador

Para fornecer dados de autenticação junto com SignalR solicitações, use a AccessTokenProvider opção (accessTokenFactory em JavaScript) para especificar uma função que retorna o token de acesso desejado. No cliente .NET, este token de acesso é passado como um token de autenticação HTTP "Bearer" (usando o tipo Authorization no cabeçalho Bearer). No cliente JavaScript, o token de acesso é usado como um token Bearer, exceto em alguns casos onde as APIs do navegador restringem a possibilidade de aplicar cabeçalhos (especificamente, em Server-Sent Eventos e solicitações WebSockets). Nesses casos, o token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.

No cliente .NET, a AccessTokenProvider opção pode ser especificada usando as opções delegadas em WithUrl:

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

No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no objeto options em 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();

SignalR No cliente Java, você pode configurar um token de portador para usar para autenticação fornecendo uma fábrica de token de acesso ao HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJavaSingle<String>. Com uma chamada para Single.defer , você pode escrever a lógica para produzir tokens de acesso para o seu cliente.

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

Configurar opções de tempo limite e persistência de conexão

Opções adicionais para configurar o tempo limite e o comportamento manter-vivo estão disponíveis no próprio objeto:

Configurar opções adicionais

Opções adicionais podem ser configuradas no método WithUrl (withUrl em JavaScript) no HubConnectionBuilder ou nas várias APIs de configuração no cliente Java HttpHubConnectionBuilder.

No cliente .NET, essas opções podem ser modificadas pelo delegado de opções fornecido para 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();

No Cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido para 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();

No cliente Java, essas opções podem ser configuradas com os métodos no HttpHubConnectionBuilder retornados pelo HubConnectionBuilder.create("HUB URL").

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

Recursos adicionais

• Introdução ao ASP.NET Core SignalR
• Usar concentradores no ASP.NET Core SignalR
• ASP.NET Core SignalR cliente JavaScript
• ASP.NET Core SignalR Cliente .NET
• Utilizar o Protocolo MessagePack Hub no SignalR ASP.NET Core
• ASP.NET Core SignalR plataformas suportadas