Configuração do SignalR ASP.NET Core

Este artigo aborda a configuração do ASP.NET Core SignalR.

Para obter diretrizes do BlazorSignalR, que adicionam ou substituem as diretrizes deste artigo, consulte diretrizes do ASP.NET CoreBlazorSignalR.

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

ASP.NET Core SignalR dá suporte a dois protocolos para codificar 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 método de extensão AddJsonProtocol. AddJsonProtocol podem ser adicionados após AddSignalR em Startup.ConfigureServices. O método AddJsonProtocol usa um delegado que recebe um objeto options. A propriedade PayloadSerializerOptions nesse objeto é um objeto System.Text.Json JsonSerializerOptions que pode ser usado para configurar a serialização de argumentos e valores de retorno. Para obter mais informações, confira a documentação System.Text.Json.

Por exemplo, para configurar o serializador para não alterar a caixa dos nomes de propriedades, em vez dos nomes padrão em caixa alta, use o seguinte código em Program.cs:

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

No cliente .NET, o mesmo AddJsonProtocol método de extensão existe em HubConnectionBuilder. O namespace Microsoft.Extensions.DependencyInjection deve ser importado para resolve 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();

Observação

Não é possível configurar a serialização JSON no cliente JavaScript no momento.

Alternar para Newtonsoft.Json

Se você precisar de recursos que Newtonsoft.Json não têm suporte no System.Text.Json, consulte Alternar para Newtonsoft.Json.

Opções de serialização do MessagePack

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

Observação

Não é possível configurar a serialização MessagePack no cliente JavaScript no momento.

Configurar opções de servidor

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

Opção	Valor padrão	Descrição
ClientTimeoutInterval	30 segundos	O servidor considerará o cliente desconectado se ele não tiver recebido uma mensagem (incluindo manter conexão) nesse intervalo. Pode levar mais tempo do que esse intervalo de tempo limite para que o cliente seja marcado como desconectado devido à forma como isso é implementado. O valor recomendado é o dobro do valor KeepAliveInterval.
HandshakeTimeout	15 s	Se o cliente não enviar uma mensagem de handshake inicial dentro desse intervalo de tempo, a conexão será fechada. Essa é uma configuração avançada que só deve ser modificada se erros de tempo limite de handshake estiverem ocorrendo devido à latência de rede grave. Para obter mais detalhes sobre o processo de handshake, consulte a SignalREspecificação do Protocolo Hub.
KeepAliveInterval	15 s	Se o servidor não tiver enviado uma mensagem dentro desse intervalo, uma mensagem de ping será enviada automaticamente para manter a conexão aberta. Ao alterar KeepAliveInterval, altere a ServerTimeout ou serverTimeoutInMilliseconds configuração no cliente. O valor recomendado ServerTimeout ou serverTimeoutInMilliseconds é o dobro do valor KeepAliveInterval.
SupportedProtocols	Todos os protocolos instalados	Protocolos compatíveis com esse hub. Por padrão, todos os protocolos registrados no servidor são permitidos. Os protocolos podem ser removidos dessa lista para desabilitar protocolos específicos para hubs individuais.
EnableDetailedErrors	false	Se for true, as mensagens de exceção detalhadas serão retornadas aos clientes quando uma exceção for gerada em um método de Hub. O padrão é false porque essas mensagens de exceção podem conter informações confidenciais.
StreamBufferCapacity	10	O número máximo de itens que podem ser armazenados em buffer para fluxos de upload do cliente. Se esse limite for atingido, o processamento de invocações será bloqueado até que o servidor processe itens de fluxo.
MaximumReceiveMessageSize	32 KB	Tamanho máximo de uma única mensagem de hub de entrada. O aumento do valor pode aumentar o risco de ataques de negação de serviço (DoS).
MaximumParallelInvocationsPerClient	1	O número máximo de métodos de hub que cada cliente pode chamar em paralelo antes da fila.
DisableImplicitFromServicesParameters	false	Os argumentos do método de hub são resolvidos a partir da DI, quando possível.

As opções podem ser configuradas para todos os hubs por meio do fornecimento de um delegado de opções para a chamada AddSignalR em Program.cs:

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

As opções para um único hub substituem as opções globais fornecidas em AddSignalR e podem ser configuradas usando 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 no 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 de HTTP avançadas do ASP.NET CoreSignalR:

Opção	Valor padrão	Descrição
ApplicationMaxBufferSize	64 KB	O número máximo de bytes recebidos do cliente que o servidor armazena em buffer antes de aplicar a compactação inativa. Aumentar esse valor permite que o servidor receba mensagens maiores mais rapidamente sem aplicar a compactação inativa, mas pode aumentar o consumo de memória.
TransportMaxBufferSize	64 KB	O número máximo de bytes enviados pelo aplicativo que o servidor armazena em buffer antes de observar a compactação inativa. Aumentar esse valor permite que o servidor faça buffer de mensagens maiores mais rapidamente sem aguardar a compactação inativa, mas pode aumentar o consumo de memória.
AuthorizationData	Dados coletados automaticamente dos atributos Authorize aplicados à classe Hub.	Uma lista de IAuthorizeData objetos usados para determinar se um cliente está autorizado a se conectar ao hub.
Transports	Todos os transportes estão habilitados.	Um bit sinaliza a enumeração de HttpTransportType valores que podem restringir os transportes que um cliente pode usar para se conectar.
LongPolling	Veja abaixo.	Opções adicionais específicas para o transporte de sondagem longa.
WebSockets	Veja abaixo.	Opções adicionais específicas para o transporte WebSockets.
MinimumProtocolVersion	0	Especifique a versão mínima do protocolo de negociação. Isso é usado para limitar clientes a versões mais recentes.
CloseOnAuthenticationExpiration	falso	Defina essa opção para habilitar o controle de expiração da autenticação que fechará as conexões quando um token expirar.

O transporte de sondagem longa tem opções adicionais que podem ser configuradas usando a propriedade LongPolling:

Opção	Valor padrão	Descrição
PollTimeout	90 segundos	A quantidade máxima de tempo que o servidor aguarda que uma mensagem seja enviada ao cliente antes de encerrar uma única solicitação de sondagem. Diminuir esse valor faz com que o cliente emita novas solicitações de pesquisa com mais frequência.

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

Opção	Valor padrão	Descrição
CloseTimeout	5 segundos	Após o fechamento do servidor, se o cliente não for fechado dentro desse intervalo de tempo, a conexão será encerrada.
SubProtocolSelector	null	Um delegado que pode ser usado para definir o cabeçalho Sec-WebSocket-Protocol como um valor personalizado. O delegado recebe os valores solicitados pelo cliente como entrada e deve retornar o valor desejado.

Configurar opções de cliente

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

Configurar o registro em log

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

Observação

Para registrar provedores de log, você deve instalar os pacotes necessários. Consulte a seção Provedores de log internos dos documentos para obter uma lista completa.

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

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

No cliente JavaScript, existe um configureLoggingmétodo semelhante. Forneça um LogLevel valor que indica 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 representa um nome de nível de log. Isso é útil ao configurar SignalR o registro em log em ambientes em que você não tem acesso às LogLevel constantes.

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

A tabela a seguir lista os níveis de registro disponíveis: O valor que você fornece para configureLogging definir o nível mínimo de log que será registrado. As mensagens registradas nesse nível ou os níveis listados após ele na tabela serão registrados.

String	LogLevel
trace	LogLevel.Trace
debug	LogLevel.Debug
info ou information	LogLevel.Information
warn ou warning	LogLevel.Warning
error	LogLevel.Error
critical	LogLevel.Critical
none	LogLevel.None

Observação

Para desabilitar totalmente o registro em log, especifique signalR.LogLevel.None no método configureLogging.

Para obter mais informações sobre o registro em log, consulte a SignalR documentação diagnóstico.

O cliente Java SignalR usa a biblioteca SLF4J para registro em log. É uma API de log de alto nível que permite que os usuários da biblioteca escolham sua própria implementação de log específica trazendo uma dependência de log específica. O snippet de código a seguir mostra como usar java.util.logging com o cliente Java SignalR.

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

Se você não configurar o registro em log em suas dependências, o SLF4J carregará um agente sem 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 usados por SignalR podem ser configurados na chamada WithUrl (em JavaScript withUrl). Um bitwise-OR dos valores de HttpTransportType pode ser usado para restringir o cliente a usar apenas os transportes especificados. Todos os transportes são habilitados por padrão.

Por exemplo, para desabilitar o transporte de Eventos Server-Sent, mas permitir conexões WebSockets e Sondagem Longa:

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 de opções 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 com o withTransport método no HttpHubConnectionBuilder. O cliente Java usa como padrão o transporte WebSockets.

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

Observação

O SignalR cliente Java ainda não dá suporte ao fallback de transporte.

Configurar a autenticação de portador

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

No cliente .NET, a opção AccessTokenProvider pode ser especificada usando o delegado de opções 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 campo accessTokenFactory no objeto opções 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();

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

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

Configurar o tempo limite e as opções keep alive

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

.NET

Opção	Valor padrão	Descrição
WithServerTimeout	30 segundos (30.000 milissegundos)	O tempo limite para a atividade do servidor e é definido diretamente em HubConnectionBuilder. Se o servidor não tiver enviado uma mensagem nesse intervalo, o cliente considerará o servidor desconectado e disparará o Closed evento (onclose em JavaScript). Esse valor deve ser grande o suficiente para que uma mensagem de ping seja enviada do servidor e recebida pelo cliente dentro do intervalo de tempo limite. O valor recomendado é um número pelo menos o dobro do valor de intervalo keep alive (WithKeepAliveInterval) do servidor para permitir que os pings cheguem.
HandshakeTimeout	15 s	Tempo limite para handshake inicial do servidor e está disponível no HubConnection próprio objeto. Se o servidor não enviar uma resposta de handshake nesse intervalo, o cliente cancelará o handshake e disparará o Closed evento (onclose em JavaScript). Essa é uma configuração avançada que só deve ser modificada se erros de tempo limite de handshake estiverem ocorrendo devido à latência de rede grave. Para obter mais detalhes sobre o processo de handshake, consulte a SignalREspecificação do Protocolo Hub.
WithKeepAliveInterval	15 s	Determina o intervalo no qual o cliente envia mensagens de ping e é definido diretamente em HubConnectionBuilder. Essa configuração permite que o servidor detecte desconexões físicas, como quando um cliente desconecta o computador da rede. Enviar qualquer mensagem do cliente redefine o temporizador para o início do intervalo. Se o cliente não tiver enviado uma mensagem no ClientTimeoutInterval conjunto no servidor, o servidor considerará o cliente desconectado.

No cliente .NET, os valores de tempo limite são especificados como valores TimeSpan.

O exemplo a seguir mostra valores que são o dobro dos valores padrão:

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

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

await builder.StartAsync();

JavaScript

Opção	Valor padrão	Descrição
withServerTimeout	30 segundos (30.000 milissegundos)	O tempo limite para a atividade do servidor e é definido diretamente em HubConnectionBuilder. Se o servidor não tiver enviado uma mensagem nesse intervalo, o cliente considerará o servidor desconectado e disparará o evento onclose. Essa configuração permite que o servidor detecte desconexões físicas, como quando um cliente desconecta o computador da rede. Esse valor deve ser grande o suficiente para que uma mensagem de ping seja enviada do servidor e recebida pelo cliente dentro do intervalo de tempo limite. O valor recomendado é um número pelo menos o dobro do valor de intervalo keep alive (withKeepAliveInterval) do servidor para permitir que os pings cheguem.
withKeepAliveInterval	15 segundos (15.000 milissegundos)	Determina o intervalo no qual o cliente envia mensagens de ping e é definido diretamente em HubConnectionBuilder. Essa configuração permite que o servidor detecte desconexões físicas, como quando um cliente desconecta o computador da rede. Enviar qualquer mensagem do cliente redefine o temporizador para o início do intervalo. Se o cliente não tiver enviado uma mensagem no ClientTimeoutInterval conjunto no servidor, o servidor considerará o cliente desconectado. O ping ocorre no máximo com a frequência em que o servidor realiza o ping. Se o servidor executar pings a cada cinco segundos, atribuir um valor menor que 5000 (5 segundos) executará pings a cada cinco segundos. O valor padrão é 15 segundos. O intervalo de keep alive deve ser inferior ou igual à metade do valor atribuído ao tempo limite do servidor (withServerTimeout).

O exemplo a seguir mostra valores que são o dobro dos valores padrão:

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

Java

Opção	Valor padrão	Descrição
getServerTimeout / setServerTimeout	30 segundos (30.000 milissegundos)	Timeout paa atividade do servidor. Se o servidor não tiver enviado uma mensagem nesse intervalo, o cliente considerará o servidor desconectado e disparará o evento onClose. Esse valor deve ser grande o suficiente para que uma mensagem de ping seja enviada do servidor e recebida pelo cliente dentro do intervalo de tempo limite. O valor recomendado é um número pelo menos o dobro do valor KeepAliveInterval do servidor para permitir que os pings cheguem.
withHandshakeResponseTimeout	15 s	Tempo limite para handshake inicial do servidor. Se o servidor não enviar uma resposta de handshake nesse intervalo, o cliente cancelará o handshake e disparará o evento onClose. Essa é uma configuração avançada que só deve ser modificada se erros de tempo limite de handshake estiverem ocorrendo devido à latência de rede grave. Para obter mais detalhes sobre o processo de handshake, consulte a SignalREspecificação do Protocolo Hub.
getKeepAliveInterval / setKeepAliveInterval	15 segundos (15.000 milissegundos)	Determina o intervalo no qual o cliente envia mensagens de ping. Enviar qualquer mensagem do cliente redefine o temporizador para o início do intervalo. Se o cliente não tiver enviado uma mensagem no ClientTimeoutInterval conjunto no servidor, o servidor considerará o cliente desconectado.

Configurar a reconexão com estado

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

A reconexão com estado alcança esse objetivo:

• Armazenando dados em buffer temporariamente no servidor e no cliente.
• Confirmando mensagens recebidas (ACK-ing) pelo servidor e pelo cliente.
• Reconhecendo quando uma conexão está ativa e reproduzindo mensagens que podem ter sido enviadas enquanto a conexão estava inativa.

A reconexão com estado está disponível no ASP.NET Core 8.0 e posterior.

Aceite se reconectar com estado no ponto de extremidade do hub de servidor e no cliente:

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

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

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

  A opção StatefulReconnectBufferSize definida 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 habilitar 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) em HubConnectionBuilder ou nas várias APIs de configuração no HttpHubConnectionBuilder cliente Java:

.NET

Opção .NET	Valor padrão	Descrição
AccessTokenProvider	null	Uma função que retorna uma cadeia de caracteres fornecida como um token de autenticação de portador em solicitações HTTP.
SkipNegotiation	false	Defina isso para true ignorar a etapa de negociação. Só há suporte quando o transporte WebSockets é o único transporte habilitado. Essa configuração não pode ser habilitada ao usar o Serviço do Azure SignalR.
ClientCertificates	Vazio	Uma coleção de certificados TLS a serem enviados para autenticar solicitações.
Cookies	Vazio	Uma coleção de cookies HTTP a serem enviados com cada solicitação HTTP.
Credentials	Vazio	Credenciais a serem enviadas com cada solicitação HTTP.
CloseTimeout	5 segundos	Somente WebSockets. A quantidade máxima de tempo que o cliente aguarda após o fechamento para que o servidor reconheça a solicitação de fechamento. Se o servidor não reconhecer o fechamento dentro desse momento, o cliente se desconectará.
Headers	Vazio	Um mapa de cabeçalhos HTTP adicionais a serem enviados com cada solicitação HTTP.
HttpMessageHandlerFactory	null	Um delegado que pode ser usado para configurar ou substituir o HttpMessageHandler usado para enviar solicitações HTTP. Não usado para conexões WebSocket. Esse delegado deve retornar um valor não nulo e recebe o valor padrão como um parâmetro. Modifique as configurações nesse valor padrão e retorne-o ou retorne uma nova HttpMessageHandler instância. Ao substituir o manipulador, certifique-se de copiar as configurações que você deseja manter do manipulador fornecido, caso contrário, as opções configuradas (como cookies e cabeçalhos) não se aplicarão ao novo manipulador.
Proxy	null	Um proxy HTTP a ser usado ao enviar solicitações HTTP.
UseDefaultCredentials	false	Defina esse booliano para enviar as credenciais padrão para solicitações HTTP e WebSockets. Isso permite o uso de autenticação do Windows.
WebSocketConfiguration	null	Um delegado que pode ser usado para configurar opções adicionais do WebSocket. Recebe uma instância do ClientWebSocketOptions que pode ser usada para configurar as opções.
ApplicationMaxBufferSize	1 MB	O número máximo de bytes recebidos do servidor que o cliente armazena em buffer antes de aplicar a contrapressão. O aumento desse valor permite que o cliente receba mensagens maiores mais rapidamente sem aplicar contrapressão, mas pode aumentar o consumo de memória.
TransportMaxBufferSize	1 MB	O número máximo de bytes enviados pelo aplicativo de usuário que o cliente armazena em buffer antes de observar a compactação inativa. Aumentar esse valor permite que o servidor faça buffer de mensagens maiores mais rapidamente sem aguardar a compactação inativa, mas pode aumentar o consumo de memória.

JavaScript

Opções do JavaScript	Valor padrão	Descrição
accessTokenFactory	null	Uma função que retorna uma cadeia de caracteres fornecida como um token de autenticação de portador em solicitações HTTP.
transport	null	Um HttpTransportType valor que especifica o transporte a ser usado na conexão.
headers	null	Dicionário de cabeçalhos enviados com cada solicitação HTTP. O envio de cabeçalhos no navegador não funciona com os WebSockets ou com o ServerSentEvents fluxo.
logMessageContent	null	Defina como true para registrar os bytes/chars das mensagens enviadas e recebidas pelo cliente.
skipNegotiation	false	Defina isso para true ignorar a etapa de negociação. Só há suporte quando o transporte WebSockets é o único transporte habilitado. Essa configuração não pode ser habilitada ao usar o Serviço do Azure SignalR.
withCredentials	true	Especifica se as credenciais serão enviadas com a solicitação CORS. Serviço de Aplicativo do Azure usa cookies nas sessões persistentes e precisa dessa opção habilitada para funcionar corretamente. Para obter mais informações sobre CORS com SignalR, consulte Considerações de segurança no ASP.NET Core SignalR.
timeout	100,000	Tempo limite em milissegundos a ser aplicado nas solicitações HTTP. Isso não se aplica às solicitações de Sondagem Longa, EventSource ou WebSockets.

Java

Opção Java	Valor padrão	Descrição
withAccessTokenProvider	null	Uma função que retorna uma cadeia de caracteres fornecida como um token de autenticação de portador em solicitações HTTP.
shouldSkipNegotiate	false	Defina isso para true ignorar a etapa de negociação. Só há suporte quando o transporte WebSockets é o único transporte habilitado. Essa configuração não pode ser habilitada ao usar o Serviço do Azure SignalR.
withHeader withHeaders	Vazio	Um mapa de cabeçalhos HTTP adicionais a serem enviados com cada solicitação HTTP.

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 a 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 retornado do 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 CoreSignalR
• Usar hubs no ASP.NET Core SignalR
• Cliente ASP.NET Core JavaScriptSignalR
• ASP.NET Core SignalR Cliente .NET
• Usar o Protocolo de Hub do MessagePack no SignalR para ASP.NET Core
• Plataformas com suporte SignalR do ASP.NET Core