Configuração do ASP.NET Core SignalR

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

Para BlazorSignalR obter diretrizes, que adicionam ou substituem as diretrizes neste artigo, consulte ASP.NET Diretrizes principaisBlazorSignalR.

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 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 retornar valores. 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 de propriedade, em vez de usar os nomes padrão em 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 em 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();

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 do Newtonsoft.Json para os quais não há suporte no System.Text.Json, consulte 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 SignalR para obter mais detalhes.

Observação

Não é possível configurar a serialização do 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-se ativo) nesse intervalo. Pode levar mais tempo do que esse intervalo de tempo limite para que o cliente seja marcado desconectado devido à forma como isso é implementado. O valor recomendado é o dobro do KeepAliveInterval valor.
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 Especificação doSignalR 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 configuração ServerTimeout ou serverTimeoutInMilliseconds 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 true, as mensagens de exceção detalhadas são retornadas aos clientes quando uma exceção é lançada 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. Aumentar o valor pode aumentar o risco de ataques de DoS (negação de serviço).
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 hub são resolvidos de DI, se possível.

As opções podem ser configuradas para todos os hubs fornecendo um delegado de opções para a chamada em AddSignalR no 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 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 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 http avançadas do ASP.NET Core SignalR:

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 contrapressão. Aumentar esse valor permite ao servidor receber mensagens maiores de forma mais rápida sem aplicar controle de fluxo, mas pode aumentar o consumo de memória.
TransportMaxBufferSize	64 KB	O número máximo de bytes enviados pelo aplicativo que o servidor bufferiza antes de observar a contra-pressão. Aumentar esse valor permite que o servidor armazene em buffer mensagens maiores mais rapidamente sem aguardar a contrapressão, 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 uma enumeração de HttpTransportType valores que podem restringir os transportes que um cliente pode usar para se conectar.
LongPolling	Confira a seguir.	Opções adicionais específicas para o transporte Long Polling.
WebSockets	Confira a seguir.	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 os clientes a versões mais recentes.
CloseOnAuthenticationExpiration	falso	Defina essa opção para habilitar o controle de expiração de autenticação, que fechará as conexões quando um token expirar.

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

Opção	Valor Padrão	Descrição
PollTimeout	90 segundos	O tempo máximo que o servidor aguarda uma mensagem para enviar 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 WebSockets propriedade:

Opção	Valor Padrão	Descrição
CloseTimeout	5 segundos	Depois que o servidor for fechado, se o cliente não fechar dentro desse intervalo de tempo, a conexão será encerrada.
SubProtocolSelector	null	Um delegado que pode ser usado para definir o Sec-WebSocket-Protocol cabeçalho 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 HubConnectionBuilder tipo (disponível nos clientes .NET e JavaScript). Ele também está disponível no cliente Java, mas a HttpHubConnectionBuilder subclasse é a que contém as opções de configuração do construtor, assim como no próprio HubConnection.

Configurar o registro em log

A configuração do registro em log é feita no cliente .NET usando o método ConfigureLogging. Os provedores e filtros de log podem ser registrados da mesma forma que estão no servidor. Consulte a documentação do 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 integrados na documentação 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 método semelhante configureLogging . 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 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 log disponíveis. O valor que você fornece para configureLogging estabelece o nível mínimo de log que será registrado. As mensagens registradas nesse nível ou os níveis listados após ela na tabela serão registradas.

fio	LogLevel
trace	LogLevel.Trace
debug	LogLevel.Debug
info ouinformation	LogLevel.Information
warn ouwarning	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 de diagnóstico.

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

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

Se você não configurar o registro em suas dependências, o SLF4J carregará um logger 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 usados por SignalR podem ser configurados na WithUrl chamada (withUrl em JavaScript). Um OR bit a bit 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 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 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 por 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 oferece suporte à alternativa de transporte.

Configurar a autenticação do 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 de autenticação Bearer HTTP (usando o cabeçalho Authorization 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 Server-Sent solicitações de Eventos e WebSockets). Nesses casos, o token de acesso é fornecido como um valor de string de consulta access_token.

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 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 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 <. 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 de persistência:

.REDE

Opção	Valor padrão	Descrição
WithServerTimeout	30 segundos (30.000 milissegundos)	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 é pelo menos o dobro do intervalo de manutenção ativa (WithKeepAliveInterval) do servidor para permitir que os pings cheguem no tempo adequado.
HandshakeTimeout	15 s	Tempo de espera para o handshake inicial do servidor e está disponível no objeto HubConnection em si. 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 Especificação doSignalR 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 reinicia o temporizador para o começo do intervalo. Se o cliente não enviou uma mensagem no ClientTimeoutInterval definido 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)	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 onclose evento. 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 é pelo menos o dobro do intervalo de manutenção ativa (withKeepAliveInterval) do servidor para permitir que os pings cheguem no tempo adequado.
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 reinicia o temporizador para o começo do intervalo. Se o cliente não enviou uma mensagem no ClientTimeoutInterval definido 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 keep-alive deve ser menor ou igual a 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)	Tempo limite para atividade do servidor. Se o servidor não tiver enviado uma mensagem nesse intervalo, o cliente considerará o servidor desconectado e disparará o onClose evento. 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 KeepAliveInterval do servidor para permitir que os pings cheguem.
withHandshakeResponseTimeout	15 s	Tempo limite para a saudação inicial do servidor. Se o servidor não enviar uma resposta de handshake nesse intervalo, o cliente cancelará o handshake e disparará o onClose evento. 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 Handshake, consulte a SignalR.
getKeepAliveInterval / setKeepAliveInterval	15 segundos (15.000 milissegundos)	Determina o intervalo no qual o cliente envia mensagens de ping. Enviar qualquer mensagem do cliente reinicia o temporizador para o começo do intervalo. Se o cliente não enviou uma mensagem no ClientTimeoutInterval definido no servidor, o servidor considerará o cliente desconectado.

Configurar reconexão com estado

A reconexão SignalR 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 o recebimento de mensagens (ACK-ing) tanto pelo servidor quanto pelo cliente.
• Reconhecer quando uma conexão está ativa e reenviar mensagens que podem ter sido enviadas enquanto a conexão estava inativa.

A reconexão com estado está disponível na versão .NET 8 ou posteriores.

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 WithUrl método (withUrl em JavaScript) em HubConnectionBuilder ou nas várias APIs de configuração no HttpHubConnectionBuilder cliente Java:

.REDE

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 para enviar com cada solicitação HTTP.
CloseTimeout	5 segundos	Somente WebSockets. O tempo máximo 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-as 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 da autenticação do Windows.
WebSocketConfiguration	null	Um delegado que pode ser usado para configurar opções adicionais do WebSocket. Recebe uma instância de 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. Aumentar esse valor permite que o cliente receba mais rapidamente mensagens maiores, 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 pressão de retorno. Aumentar esse valor permite que o cliente armazene em buffer mensagens maiores mais rapidamente sem aguardar a contrapressão, mas pode aumentar o consumo de memória.

JavaScript

Opção 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 para a 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 para WebSockets ou para o ServerSentEvents stream.
logMessageContent	null	Defina para true registrar em log os bytes/caracteres de 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. O Serviço de Aplicativo do Azure usa cookies para sessões autoadesivas e precisa dessa opção habilitada para funcionar corretamente. Para obter mais informações sobre CORS com SignalR, consulte as considerações de segurança no ASP.NET Core SignalR.
timeout	100,000	Tempo limite em milissegundos para aplicar a solicitações HTTP. Isso não se aplica a solicitações de pesquisa 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 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 usando os métodos no HttpHubConnectionBuilder retornado 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 CoreSignalR
• Usar hubs no ASP.NET Core SignalR
• SignalR JavaScript
• ASP.NET Core SignalR Cliente .NET
• Usar o Protocolo do Hub MessagePack para SignalR ASP.NET Core
• Plataformas com suporte SignalR do ASP.NET Core