configuración de ASP.NET Core SignalR

Opciones de serialización JSON/MessagePack

ASP.NET Core SignalR admite dos protocolos para codificar mensajes: JSON y MessagePack. Cada protocolo tiene opciones de configuración de serialización.

La serialización JSON se puede configurar en el servidor utilizando el método de extensión AddJsonProtocol. AddJsonProtocol se puede agregar después de AddSignalR en Startup.ConfigureServices. El método AddJsonProtocol acepta un delegado que recibe un objeto options. La PayloadSerializerOptions propiedad de ese objeto es un System.Text.JsonJsonSerializerOptions objeto que se puede usar para configurar la serialización de argumentos y valores devueltos. Para obtener más información, consulte la documentación de System.Text.Json.

Por ejemplo, para configurar el serializador para que no cambie el uso de mayúsculas y minúsculas en los nombres de propiedad, en lugar de los nombres predeterminados en camel case, use el código siguiente en Program.cs.

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

En el cliente .NET, existe el mismo AddJsonProtocol método de extensión en HubConnectionBuilder. El Microsoft.Extensions.DependencyInjection espacio de nombres debe importarse para resolver el método de extensión:

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

Cambiar a Newtonsoft.Json

Si necesita características de Newtonsoft.Json que no se admiten en System.Text.Json, vea Cambiar a Newtonsoft.Json.

Opciones de serialización de MessagePack

La serialización de MessagePack se puede configurar proporcionando un delegado a la AddMessagePackProtocol llamada. Consulte MessagePack en SignalR para obtener más detalles.

Configurar las opciones del servidor

En la siguiente tabla se describen las opciones para configurar SignalR hubs:

Se pueden configurar opciones para todos los centros proporcionando un delegado de opciones a la llamada AddSignalR en Program.cs.

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

Las opciones de un único centro invalidan las opciones globales proporcionadas en AddSignalR y se pueden configurar mediante AddHubOptions:

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

Opciones avanzadas de configuración http

Use HttpConnectionDispatcherOptions para configurar opciones avanzadas relacionadas con los transportes y la administración del búfer de memoria. Estas opciones se configuran pasando un delegado a MapHub en 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();

En la tabla siguiente se describen las opciones para configurar las opciones HTTP avanzadas de ASP.NET Core SignalR:

El transporte de sondeo largo ofrece opciones adicionales que pueden configurarse a través de la propiedad LongPolling.

El transporte de WebSocket tiene opciones adicionales que se pueden configurar mediante la WebSockets propiedad :

Configuración de las opciones de cliente

Las opciones de cliente se pueden configurar en el HubConnectionBuilder tipo (disponible en los clientes de .NET y JavaScript). También está disponible en el cliente de Java, pero la subclase HttpHubConnectionBuilder es la que contiene las opciones de configuración del constructor, además de en el propio HubConnection.

Configurar el registro

El registro se configura en el cliente de .NET usando el método ConfigureLogging. Los proveedores y filtros de registro se pueden registrar de la misma manera que en el servidor. Consulte la documentación de Logging in ASP.NET Core (Registro en ASP.NET Core ) para obtener más información.

Por ejemplo, para habilitar el registro de consola, instale el Microsoft.Extensions.Logging.Console paquete NuGet. Llame al método de extensión AddConsole.

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

En el cliente de JavaScript, existe un método similar configureLogging . Proporcione un LogLevel valor que indique el nivel mínimo de mensajes de registro que se van a generar. Los registros se registran en la ventana de la consola del navegador.

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

En lugar de un LogLevel valor, también puede proporcionar un valor string que represente un nombre de nivel de log. Esto resulta útil al configurar el registro de SignalR en entornos en los que no tienes acceso a las constantes de LogLevel.

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

En la tabla siguiente se enumeran los niveles de registro disponibles. El valor que proporciones para configureLogging establece el nivel de log mínimo que se registrará. Los mensajes registrados en este nivel o los niveles enumerados después de él en la tabla se registrarán.

Para obtener más información sobre el registro, consulte la SignalR documentación de diagnóstico.

El SignalR cliente de Java usa la biblioteca SLF4J para el registro. Es una API de registro de alto nivel que permite a los usuarios de la biblioteca elegir su propia implementación de registro específica mediante la incorporación de una dependencia de registro específica. En el fragmento de código siguiente se muestra cómo usar java.util.logging con el SignalR cliente de Java.

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

En caso de no configurar el registro en tus dependencias, SLF4J carga un registrador predeterminado de no operación con el siguiente mensaje de advertencia:

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.

Esto se puede ignorar.

Configurar los transportes permitidos

Los transportes usados por SignalR se pueden configurar en la WithUrl llamada (withUrl en JavaScript). Se puede usar un OR bit a bit de los valores de HttpTransportType para restringir el cliente para que solo use los transportes especificados. Todos los transportes están habilitados de forma predeterminada.

Por ejemplo, para deshabilitar el transporte de eventos de Server-Sent, pero permitir conexiones WebSockets y Long Polling:

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

En el cliente de JavaScript, los transportes se configuran estableciendo el transport campo en el objeto options proporcionado a withUrl:

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

En esta versión del cliente de Java WebSockets es el único transporte disponible.

En el cliente de Java, el transporte se selecciona con el método withTransport en el HttpHubConnectionBuilder. El cliente java usa el transporte de WebSockets de forma predeterminada.

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

Configuración de la autenticación de portador

Para proporcionar datos de autenticación junto con SignalR las solicitudes, use la AccessTokenProvider opción (accessTokenFactory en JavaScript) para especificar una función que devuelva el token de acceso deseado. En el cliente .NET, este token de acceso se pasa como un token HTTP de "Autenticación de Portador" (mediante el encabezado Authorization con un tipo de Bearer). En el cliente de JavaScript, el token de acceso se usa como token de portador, excepto en algunos casos en los que las API del explorador restringen la capacidad de aplicar encabezados (en concreto, en Server-Sent eventos y solicitudes de WebSockets). En estos casos, el token de acceso se proporciona como un valor de cadena de consulta access_token.

En el cliente .NET, la AccessTokenProvider opción se puede especificar mediante el delegado de opciones en WithUrl:

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

En el cliente de JavaScript, el token de acceso se configura estableciendo el accessTokenFactory campo en el objeto options de 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();

En el SignalR cliente de Java, puede configurar un token de portador que se usará para la autenticación proporcionando una factoría de tokens de acceso a HttpHubConnectionBuilder. Use withAccessTokenFactory para proporcionar una cadena <. Con una llamada a Single.defer, puede escribir lógica para generar tokens de acceso para el cliente.

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

Configurar las opciones de tiempo de espera y conexión persistente

Opciones adicionales para configurar el tiempo de espera y el comportamiento de mantenimiento activo:

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 reconexión con estado

La reconexión con estado de SignalR reduce el tiempo de inactividad percibido de los clientes que tienen una desconexión temporal en su conexión de red, como al cambiar las conexiones de red o una breve pérdida temporal de acceso.

La reconexión con estado lo consigue gracias a:

• Almacenamiento temporal en búfer de los datos en el servidor y el cliente.
• Confirmación de los mensajes recibidos (ACK-ing) tanto por el servidor como por el cliente.
• Reconocer cuándo una conexión está activa y retransmitir los mensajes que podrían haberse enviado mientras la conexión estaba inactiva.

La reconexión con estado está disponible en .NET 8 o posterior.

Opte por la reconexión con estado tanto en el punto de conexión del centro de servidores como en el cliente:

• Actualice la configuración del punto de conexión del centro de servidores para habilitar la opción AllowStatefulReconnects:

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

  Opcionalmente, el tamaño máximo del búfer en bytes permitido por el servidor se puede establecer globalmente o para un centro específico con la opción StatefulReconnectBufferSize:

  La opción StatefulReconnectBufferSize establecida globalmente:

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

  La opción StatefulReconnectBufferSize establecida para un centro específico:

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

  La opción StatefulReconnectBufferSize es opcional con un valor predeterminado de 100 000 bytes.

• Actualice el código de cliente de JavaScript o TypeScript para habilitar la opción withStatefulReconnect:

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

  La opción bufferSize es opcional con un valor predeterminado de 100 000 bytes.

• Actualice el código de cliente de .NET para habilitar la opción WithStatefulReconnect:

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

  La opción StatefulReconnectBufferSize es opcional con un valor predeterminado de 100 000 bytes.

Configurar opciones adicionales

Se pueden configurar opciones adicionales en el WithUrl método (withUrl en JavaScript) en HubConnectionBuilder o en las distintas API de configuración de en el HttpHubConnectionBuilder cliente de Java:

En el cliente .NET, estas opciones se pueden modificar mediante el delegado de opciones proporcionado a 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();

En el cliente de JavaScript, estas opciones se pueden proporcionar en un objeto javaScript proporcionado 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();

En el cliente Java, estas opciones se pueden configurar con los métodos en el HttpHubConnectionBuilder que se devuelve desde el HubConnectionBuilder.create("HUB URL").

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

Recursos adicionales

• Introducción a ASP.NET Core SignalR
• Uso de concentradores en para ASP.NET CoreSignalR
• Cliente de JavaScript en ASP.NET Core SignalR
• Cliente .NET de ASP.NET Core SignalR
• Uso del MessagePack Hub Protocol en SignalR para ASP.NET Core
• Plataformas admitidas de SignalRASP.NET Core

Opciones de serialización JSON/MessagePack

ASP.NET Core SignalR admite dos protocolos para codificar mensajes: JSON y MessagePack. Cada protocolo tiene opciones de configuración de serialización.

La serialización JSON se puede configurar en el servidor mediante el método de extensión AddJsonProtocol, que se puede agregar después de AddSignalR en su método Startup.ConfigureServices. El método AddJsonProtocol acepta un delegado que recibe un objeto options. La PayloadSerializerSettings propiedad de ese objeto es un objeto Json.NET JsonSerializerSettings que se puede usar para configurar la serialización de argumentos y valores devueltos. Para obtener más información, consulte la documentación de Json.NET.

Por ejemplo, para configurar el serializador para que use nombres de propiedad en "PascalCase", en lugar de la notación camel predeterminada, use el siguiente código en :

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

En el cliente .NET, existe el mismo AddJsonProtocol método de extensión en HubConnectionBuilder. El Microsoft.Extensions.DependencyInjection espacio de nombres debe importarse para resolver el método de extensión:

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

Opciones de serialización de MessagePack

La serialización de MessagePack se puede configurar proporcionando un delegado a la AddMessagePackProtocol llamada. Consulte MessagePack en SignalR para obtener más detalles.

Configurar las opciones del servidor

En la siguiente tabla se describen las opciones para configurar SignalR hubs:

Se pueden configurar opciones para todos los centros proporcionando un delegado de opciones a la llamada AddSignalR en Startup.ConfigureServices.

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

Las opciones de un único centro invalidan las opciones globales proporcionadas en AddSignalR y se pueden configurar mediante AddHubOptions:

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

Opciones avanzadas de configuración http

Use HttpConnectionDispatcherOptions para configurar opciones avanzadas relacionadas con los transportes y la administración del búfer de memoria. Estas opciones se configuran pasando un delegado a MapHub en 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;
        });
    });
}

En la tabla siguiente se describen las opciones para configurar las opciones HTTP avanzadas de ASP.NET Core SignalR:

El transporte de sondeo largo ofrece opciones adicionales que pueden configurarse a través de la propiedad LongPolling.

El transporte de WebSocket tiene opciones adicionales que se pueden configurar mediante la WebSockets propiedad :

Configuración de las opciones de cliente

Las opciones de cliente se pueden configurar en el HubConnectionBuilder tipo (disponible en los clientes de .NET y JavaScript). También está disponible en el cliente de Java, pero la subclase HttpHubConnectionBuilder es la que contiene las opciones de configuración del constructor, además de en el propio HubConnection.

Configurar el registro

El registro se configura en el cliente de .NET usando el método ConfigureLogging. Los proveedores y filtros de registro se pueden registrar de la misma manera que en el servidor. Consulte la documentación de Logging in ASP.NET Core (Registro en ASP.NET Core ) para obtener más información.

Por ejemplo, para habilitar el registro de consola, instale el Microsoft.Extensions.Logging.Console paquete NuGet. Llame al método de extensión AddConsole.

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

En el cliente de JavaScript, existe un método similar configureLogging . Proporcione un LogLevel valor que indique el nivel mínimo de mensajes de registro que se van a generar. Los registros se registran en la ventana de la consola del navegador.

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

Para obtener más información sobre el registro, consulte la SignalR documentación de diagnóstico.

El SignalR cliente de Java usa la biblioteca SLF4J para el registro. Es una API de registro de alto nivel que permite a los usuarios de la biblioteca elegir su propia implementación de registro específica mediante la incorporación de una dependencia de registro específica. En el fragmento de código siguiente se muestra cómo usar java.util.logging con el SignalR cliente de Java.

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

En caso de no configurar el registro en tus dependencias, SLF4J carga un registrador predeterminado de no operación con el siguiente mensaje de advertencia:

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.

Esto se puede ignorar.

Configurar los transportes permitidos

Los transportes usados por SignalR se pueden configurar en la WithUrl llamada (withUrl en JavaScript). Se puede usar un OR bit a bit de los valores de HttpTransportType para restringir el cliente para que solo use los transportes especificados. Todos los transportes están habilitados de forma predeterminada.

Por ejemplo, para deshabilitar el transporte de eventos de Server-Sent, pero permitir conexiones WebSockets y Long Polling:

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

En el cliente de JavaScript, los transportes se configuran estableciendo el transport campo en el objeto options proporcionado a withUrl:

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

Configuración de la autenticación de portador

Para proporcionar datos de autenticación junto con SignalR las solicitudes, use la AccessTokenProvider opción (accessTokenFactory en JavaScript) para especificar una función que devuelva el token de acceso deseado. En el cliente .NET, este token de acceso se pasa como un token HTTP de "Autenticación de Portador" (mediante el encabezado Authorization con un tipo de Bearer). En el cliente de JavaScript, el token de acceso se usa como token de portador, excepto en algunos casos en los que las API del explorador restringen la capacidad de aplicar encabezados (en concreto, en Server-Sent eventos y solicitudes de WebSockets). En estos casos, el token de acceso se proporciona como un valor de cadena de consulta access_token.

En el cliente .NET, la AccessTokenProvider opción se puede especificar mediante el delegado de opciones en WithUrl:

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

En el cliente de JavaScript, el token de acceso se configura estableciendo el accessTokenFactory campo en el objeto options de 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();

En el SignalR cliente de Java, puede configurar un token de portador que se usará para la autenticación proporcionando una factoría de tokens de acceso a HttpHubConnectionBuilder. Use withAccessTokenFactory para proporcionar una cadena <. Con una llamada a Single.defer, puede escribir lógica para generar tokens de acceso para el cliente.

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

Configurar las opciones de tiempo de espera y conexión persistente

Hay disponibles opciones adicionales para configurar el tiempo de espera y el comportamiento de mantenimiento activo en el HubConnection propio objeto:

Configurar opciones adicionales

Se pueden configurar opciones adicionales en el WithUrl método (withUrl en JavaScript) en HubConnectionBuilder o en las distintas API de configuración de en el HttpHubConnectionBuilder cliente de Java:

En el cliente .NET, estas opciones se pueden modificar mediante el delegado de opciones proporcionado a WithUrl:

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

En el cliente de JavaScript, estas opciones se pueden proporcionar en un objeto javaScript proporcionado a withUrl:

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

En el cliente Java, estas opciones se pueden configurar con los métodos en el HttpHubConnectionBuilder que se devuelve desde el HubConnectionBuilder.create("HUB URL").

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

Recursos adicionales

• Introducción a ASP.NET Core SignalR
• Uso de concentradores en para ASP.NET CoreSignalR
• Cliente de JavaScript en ASP.NET Core SignalR
• Cliente .NET de ASP.NET Core SignalR
• Uso del MessagePack Hub Protocol en SignalR para ASP.NET Core
• Plataformas admitidas de SignalRASP.NET Core

Opciones de serialización JSON/MessagePack

ASP.NET Core SignalR admite dos protocolos para codificar mensajes: JSON y MessagePack. Cada protocolo tiene opciones de configuración de serialización.

La serialización JSON se puede configurar en el servidor mediante el método de extensión AddJsonProtocol, que se puede agregar después de AddSignalR en su método Startup.ConfigureServices. El método AddJsonProtocol acepta un delegado que recibe un objeto options. La PayloadSerializerSettings propiedad de ese objeto es un objeto Json.NET JsonSerializerSettings que se puede usar para configurar la serialización de argumentos y valores devueltos. Para obtener más información, consulte la documentación de Json.NET.

Por ejemplo, para configurar el serializador para que use nombres de propiedad en "PascalCase", en lugar de la notación camel predeterminada, use el siguiente código en :

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

En el cliente .NET, existe el mismo AddJsonProtocol método de extensión en HubConnectionBuilder. El Microsoft.Extensions.DependencyInjection espacio de nombres debe importarse para resolver el método de extensión:

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

Opciones de serialización de MessagePack

La serialización de MessagePack se puede configurar proporcionando un delegado a la AddMessagePackProtocol llamada. Consulte MessagePack en SignalR para obtener más detalles.

Configurar las opciones del servidor

En la siguiente tabla se describen las opciones para configurar SignalR hubs:

Se pueden configurar opciones para todos los centros proporcionando un delegado de opciones a la llamada AddSignalR en Startup.ConfigureServices.

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

Las opciones de un único centro invalidan las opciones globales proporcionadas en AddSignalR y se pueden configurar mediante AddHubOptions:

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

Opciones avanzadas de configuración http

Use HttpConnectionDispatcherOptions para configurar opciones avanzadas relacionadas con los transportes y la administración del búfer de memoria. Estas opciones se configuran pasando un delegado a MapHub en 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;
        });
    });
}

En la tabla siguiente se describen las opciones para configurar las opciones HTTP avanzadas de ASP.NET Core SignalR:

El transporte de sondeo largo ofrece opciones adicionales que pueden configurarse a través de la propiedad LongPolling.

El transporte de WebSocket tiene opciones adicionales que se pueden configurar mediante la WebSockets propiedad :

Configuración de las opciones de cliente

Las opciones de cliente se pueden configurar en el HubConnectionBuilder tipo (disponible en los clientes de .NET y JavaScript). También está disponible en el cliente de Java, pero la subclase HttpHubConnectionBuilder es la que contiene las opciones de configuración del constructor, además de en el propio HubConnection.

Configurar el registro

El registro se configura en el cliente de .NET usando el método ConfigureLogging. Los proveedores y filtros de registro se pueden registrar de la misma manera que en el servidor. Consulte la documentación de Logging in ASP.NET Core (Registro en ASP.NET Core ) para obtener más información.

Por ejemplo, para habilitar el registro de consola, instale el Microsoft.Extensions.Logging.Console paquete NuGet. Llame al método de extensión AddConsole.

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

En el cliente de JavaScript, existe un método similar configureLogging . Proporcione un LogLevel valor que indique el nivel mínimo de mensajes de registro que se van a generar. Los registros se registran en la ventana de la consola del navegador.

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

Para obtener más información sobre el registro, consulte la SignalR documentación de diagnóstico.

El SignalR cliente de Java usa la biblioteca SLF4J para el registro. Es una API de registro de alto nivel que permite a los usuarios de la biblioteca elegir su propia implementación de registro específica mediante la incorporación de una dependencia de registro específica. En el fragmento de código siguiente se muestra cómo usar java.util.logging con el SignalR cliente de Java.

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

En caso de no configurar el registro en tus dependencias, SLF4J carga un registrador predeterminado de no operación con el siguiente mensaje de advertencia:

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.

Esto se puede ignorar.

Configurar los transportes permitidos

Los transportes usados por SignalR se pueden configurar en la WithUrl llamada (withUrl en JavaScript). Se puede usar un OR bit a bit de los valores de HttpTransportType para restringir el cliente para que solo use los transportes especificados. Todos los transportes están habilitados de forma predeterminada.

Por ejemplo, para deshabilitar el transporte de eventos de Server-Sent, pero permitir conexiones WebSockets y Long Polling:

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

En el cliente de JavaScript, los transportes se configuran estableciendo el transport campo en el objeto options proporcionado a withUrl:

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

En esta versión del cliente de Java WebSockets es el único transporte disponible.

Configuración de la autenticación de portador

Para proporcionar datos de autenticación junto con SignalR las solicitudes, use la AccessTokenProvider opción (accessTokenFactory en JavaScript) para especificar una función que devuelva el token de acceso deseado. En el cliente .NET, este token de acceso se pasa como un token HTTP de "Autenticación de Portador" (mediante el encabezado Authorization con un tipo de Bearer). En el cliente de JavaScript, el token de acceso se usa como token de portador, excepto en algunos casos en los que las API del explorador restringen la capacidad de aplicar encabezados (en concreto, en Server-Sent eventos y solicitudes de WebSockets). En estos casos, el token de acceso se proporciona como un valor de cadena de consulta access_token.

En el cliente .NET, la AccessTokenProvider opción se puede especificar mediante el delegado de opciones en WithUrl:

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

En el cliente de JavaScript, el token de acceso se configura estableciendo el accessTokenFactory campo en el objeto options de 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();

En el SignalR cliente de Java, puede configurar un token de portador que se usará para la autenticación proporcionando una factoría de tokens de acceso a HttpHubConnectionBuilder. Use withAccessTokenFactory para proporcionar una cadena <. Con una llamada a Single.defer, puede escribir lógica para generar tokens de acceso para el cliente.

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

Configurar las opciones de tiempo de espera y conexión persistente

Hay disponibles opciones adicionales para configurar el tiempo de espera y el comportamiento de mantenimiento activo en el HubConnection propio objeto:

Configurar opciones adicionales

Se pueden configurar opciones adicionales en el WithUrl método (withUrl en JavaScript) en HubConnectionBuilder o en las distintas API de configuración de en el HttpHubConnectionBuilder cliente de Java:

En el cliente .NET, estas opciones se pueden modificar mediante el delegado de opciones proporcionado a WithUrl:

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

En el cliente de JavaScript, estas opciones se pueden proporcionar en un objeto javaScript proporcionado a withUrl:

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

En el cliente Java, estas opciones se pueden configurar con los métodos en el HttpHubConnectionBuilder que se devuelve desde el HubConnectionBuilder.create("HUB URL").

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

Recursos adicionales

• Introducción a ASP.NET Core SignalR
• Uso de concentradores en para ASP.NET CoreSignalR
• Cliente de JavaScript en ASP.NET Core SignalR
• Cliente .NET de ASP.NET Core SignalR
• Uso del MessagePack Hub Protocol en SignalR para ASP.NET Core
• Plataformas admitidas de SignalRASP.NET Core

Opciones de serialización JSON/MessagePack

ASP.NET Core SignalR admite dos protocolos para codificar mensajes: JSON y MessagePack. Cada protocolo tiene opciones de configuración de serialización.

La serialización JSON se puede configurar en el servidor utilizando el método de extensión AddJsonProtocol. AddJsonProtocol se puede agregar después de AddSignalR en Startup.ConfigureServices. El método AddJsonProtocol acepta un delegado que recibe un objeto options. La PayloadSerializerOptions propiedad de ese objeto es un System.Text.JsonJsonSerializerOptions objeto que se puede usar para configurar la serialización de argumentos y valores devueltos. Para obtener más información, consulte la documentación de System.Text.Json.

Por ejemplo, para configurar el serializador para que no cambie el uso de mayúsculas y minúsculas en los nombres de propiedad, en lugar de los nombres predeterminados en camel case, use el código siguiente en Startup.ConfigureServices.

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

En el cliente .NET, existe el mismo AddJsonProtocol método de extensión en HubConnectionBuilder. El Microsoft.Extensions.DependencyInjection espacio de nombres debe importarse para resolver el método de extensión:

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

Cambiar a Newtonsoft.Json

Si necesita características de Newtonsoft.Json que no se admiten en System.Text.Json, vea Cambiar a Newtonsoft.Json.

Opciones de serialización de MessagePack

La serialización de MessagePack se puede configurar proporcionando un delegado a la AddMessagePackProtocol llamada. Consulte MessagePack en SignalR para obtener más detalles.

Configurar las opciones del servidor

En la siguiente tabla se describen las opciones para configurar SignalR hubs:

Se pueden configurar opciones para todos los centros proporcionando un delegado de opciones a la llamada AddSignalR en Startup.ConfigureServices.

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

Las opciones de un único centro invalidan las opciones globales proporcionadas en AddSignalR y se pueden configurar mediante AddHubOptions:

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

Opciones avanzadas de configuración http

Use HttpConnectionDispatcherOptions para configurar opciones avanzadas relacionadas con los transportes y la administración del búfer de memoria. Estas opciones se configuran pasando un delegado a MapHub en 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;
        });
    });
}

En la tabla siguiente se describen las opciones para configurar las opciones HTTP avanzadas de ASP.NET Core SignalR:

El transporte de sondeo largo ofrece opciones adicionales que pueden configurarse a través de la propiedad LongPolling.

El transporte de WebSocket tiene opciones adicionales que se pueden configurar mediante la WebSockets propiedad :

Configuración de las opciones de cliente

Las opciones de cliente se pueden configurar en el HubConnectionBuilder tipo (disponible en los clientes de .NET y JavaScript). También está disponible en el cliente de Java, pero la subclase HttpHubConnectionBuilder es la que contiene las opciones de configuración del constructor, además de en el propio HubConnection.

Configurar el registro

El registro se configura en el cliente de .NET usando el método ConfigureLogging. Los proveedores y filtros de registro se pueden registrar de la misma manera que en el servidor. Consulte la documentación de Logging in ASP.NET Core (Registro en ASP.NET Core ) para obtener más información.

Por ejemplo, para habilitar el registro de consola, instale el Microsoft.Extensions.Logging.Console paquete NuGet. Llame al método de extensión AddConsole.

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

En el cliente de JavaScript, existe un método similar configureLogging . Proporcione un LogLevel valor que indique el nivel mínimo de mensajes de registro que se van a generar. Los registros se registran en la ventana de la consola del navegador.

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

En lugar de un LogLevel valor, también puede proporcionar un valor string que represente un nombre de nivel de log. Esto resulta útil al configurar el registro de SignalR en entornos en los que no tienes acceso a las constantes de LogLevel.

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

En la tabla siguiente se enumeran los niveles de registro disponibles. El valor que proporciones para configureLogging establece el nivel de log mínimo que se registrará. Los mensajes registrados en este nivel o los niveles enumerados después de él en la tabla se registrarán.

Para obtener más información sobre el registro, consulte la SignalR documentación de diagnóstico.

El SignalR cliente de Java usa la biblioteca SLF4J para el registro. Es una API de registro de alto nivel que permite a los usuarios de la biblioteca elegir su propia implementación de registro específica mediante la incorporación de una dependencia de registro específica. En el fragmento de código siguiente se muestra cómo usar java.util.logging con el SignalR cliente de Java.

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

En caso de no configurar el registro en tus dependencias, SLF4J carga un registrador predeterminado de no operación con el siguiente mensaje de advertencia:

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.

Esto se puede ignorar.

Configurar los transportes permitidos

Los transportes usados por SignalR se pueden configurar en la WithUrl llamada (withUrl en JavaScript). Se puede usar un OR bit a bit de los valores de HttpTransportType para restringir el cliente para que solo use los transportes especificados. Todos los transportes están habilitados de forma predeterminada.

Por ejemplo, para deshabilitar el transporte de eventos de Server-Sent, pero permitir conexiones WebSockets y Long Polling:

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

En el cliente de JavaScript, los transportes se configuran estableciendo el transport campo en el objeto options proporcionado a withUrl:

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

En esta versión del cliente de Java WebSockets es el único transporte disponible.

En el cliente de Java, el transporte se selecciona con el método withTransport en el HttpHubConnectionBuilder. El cliente java usa el transporte de WebSockets de forma predeterminada.

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

Configuración de la autenticación de portador

Para proporcionar datos de autenticación junto con SignalR las solicitudes, use la AccessTokenProvider opción (accessTokenFactory en JavaScript) para especificar una función que devuelva el token de acceso deseado. En el cliente .NET, este token de acceso se pasa como un token HTTP de "Autenticación de Portador" (mediante el encabezado Authorization con un tipo de Bearer). En el cliente de JavaScript, el token de acceso se usa como token de portador, excepto en algunos casos en los que las API del explorador restringen la capacidad de aplicar encabezados (en concreto, en Server-Sent eventos y solicitudes de WebSockets). En estos casos, el token de acceso se proporciona como un valor de cadena de consulta access_token.

En el cliente .NET, la AccessTokenProvider opción se puede especificar mediante el delegado de opciones en WithUrl:

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

En el cliente de JavaScript, el token de acceso se configura estableciendo el accessTokenFactory campo en el objeto options de 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();

En el SignalR cliente de Java, puede configurar un token de portador que se usará para la autenticación proporcionando una factoría de tokens de acceso a HttpHubConnectionBuilder. Use withAccessTokenFactory para proporcionar una cadena <. Con una llamada a Single.defer, puede escribir lógica para generar tokens de acceso para el cliente.

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

Configurar las opciones de tiempo de espera y conexión persistente

Hay disponibles opciones adicionales para configurar el tiempo de espera y el comportamiento de mantenimiento activo en el HubConnection propio objeto:

Configurar opciones adicionales

Se pueden configurar opciones adicionales en el WithUrl método (withUrl en JavaScript) en HubConnectionBuilder o en las distintas API de configuración de en el HttpHubConnectionBuilder cliente de Java:

En el cliente .NET, estas opciones se pueden modificar mediante el delegado de opciones proporcionado a WithUrl:

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

En el cliente de JavaScript, estas opciones se pueden proporcionar en un objeto javaScript proporcionado a withUrl:

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

En el cliente Java, estas opciones se pueden configurar con los métodos en el HttpHubConnectionBuilder que se devuelve desde el HubConnectionBuilder.create("HUB URL").

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

Recursos adicionales

• Introducción a ASP.NET Core SignalR
• Uso de concentradores en para ASP.NET CoreSignalR
• Cliente de JavaScript en ASP.NET Core SignalR
• Cliente .NET de ASP.NET Core SignalR
• Uso del MessagePack Hub Protocol en SignalR para ASP.NET Core
• Plataformas admitidas de SignalRASP.NET Core

Opciones de serialización JSON/MessagePack

ASP.NET Core SignalR admite dos protocolos para codificar mensajes: JSON y MessagePack. Cada protocolo tiene opciones de configuración de serialización.

La serialización JSON se puede configurar en el servidor utilizando el método de extensión AddJsonProtocol. AddJsonProtocol se puede agregar después de AddSignalR en Startup.ConfigureServices. El método AddJsonProtocol acepta un delegado que recibe un objeto options. La PayloadSerializerOptions propiedad de ese objeto es un System.Text.JsonJsonSerializerOptions objeto que se puede usar para configurar la serialización de argumentos y valores devueltos. Para obtener más información, consulte la documentación de System.Text.Json.

Por ejemplo, para configurar el serializador para que no cambie el uso de mayúsculas y minúsculas en los nombres de propiedad, en lugar de los nombres predeterminados en camel case, use el código siguiente en Startup.ConfigureServices.

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

En el cliente .NET, existe el mismo AddJsonProtocol método de extensión en HubConnectionBuilder. El Microsoft.Extensions.DependencyInjection espacio de nombres debe importarse para resolver el método de extensión:

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

Cambiar a Newtonsoft.Json

Si necesita características de Newtonsoft.Json que no se admiten en System.Text.Json, vea Cambiar a Newtonsoft.Json.

Opciones de serialización de MessagePack

La serialización de MessagePack se puede configurar proporcionando un delegado a la AddMessagePackProtocol llamada. Consulte MessagePack en SignalR para obtener más detalles.

Configurar las opciones del servidor

En la siguiente tabla se describen las opciones para configurar SignalR hubs:

Se pueden configurar opciones para todos los centros proporcionando un delegado de opciones a la llamada AddSignalR en Startup.ConfigureServices.

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

Las opciones de un único centro invalidan las opciones globales proporcionadas en AddSignalR y se pueden configurar mediante AddHubOptions:

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

Opciones avanzadas de configuración http

Use HttpConnectionDispatcherOptions para configurar opciones avanzadas relacionadas con los transportes y la administración del búfer de memoria. Estas opciones se configuran pasando un delegado a MapHub en 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;
        });
    });
}

En la tabla siguiente se describen las opciones para configurar las opciones HTTP avanzadas de ASP.NET Core SignalR:

El transporte de sondeo largo ofrece opciones adicionales que pueden configurarse a través de la propiedad LongPolling.

El transporte de WebSocket tiene opciones adicionales que se pueden configurar mediante la WebSockets propiedad :

Configuración de las opciones de cliente

Las opciones de cliente se pueden configurar en el HubConnectionBuilder tipo (disponible en los clientes de .NET y JavaScript). También está disponible en el cliente de Java, pero la subclase HttpHubConnectionBuilder es la que contiene las opciones de configuración del constructor, además de en el propio HubConnection.

Configurar el registro

El registro se configura en el cliente de .NET usando el método ConfigureLogging. Los proveedores y filtros de registro se pueden registrar de la misma manera que en el servidor. Consulte la documentación de Logging in ASP.NET Core (Registro en ASP.NET Core ) para obtener más información.

Por ejemplo, para habilitar el registro de consola, instale el Microsoft.Extensions.Logging.Console paquete NuGet. Llame al método de extensión AddConsole.

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

En el cliente de JavaScript, existe un método similar configureLogging . Proporcione un LogLevel valor que indique el nivel mínimo de mensajes de registro que se van a generar. Los registros se registran en la ventana de la consola del navegador.

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

En lugar de un LogLevel valor, también puede proporcionar un valor string que represente un nombre de nivel de log. Esto resulta útil al configurar el registro de SignalR en entornos en los que no tienes acceso a las constantes de LogLevel.

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

En la tabla siguiente se enumeran los niveles de registro disponibles. El valor que proporciones para configureLogging establece el nivel de log mínimo que se registrará. Los mensajes registrados en este nivel o los niveles enumerados después de él en la tabla se registrarán.

Para obtener más información sobre el registro, consulte la SignalR documentación de diagnóstico.

El SignalR cliente de Java usa la biblioteca SLF4J para el registro. Es una API de registro de alto nivel que permite a los usuarios de la biblioteca elegir su propia implementación de registro específica mediante la incorporación de una dependencia de registro específica. En el fragmento de código siguiente se muestra cómo usar java.util.logging con el SignalR cliente de Java.

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

En caso de no configurar el registro en tus dependencias, SLF4J carga un registrador predeterminado de no operación con el siguiente mensaje de advertencia:

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.

Esto se puede ignorar.

Configurar los transportes permitidos

Los transportes usados por SignalR se pueden configurar en la WithUrl llamada (withUrl en JavaScript). Se puede usar un OR bit a bit de los valores de HttpTransportType para restringir el cliente para que solo use los transportes especificados. Todos los transportes están habilitados de forma predeterminada.

Por ejemplo, para deshabilitar el transporte de eventos de Server-Sent, pero permitir conexiones WebSockets y Long Polling:

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

En el cliente de JavaScript, los transportes se configuran estableciendo el transport campo en el objeto options proporcionado a withUrl:

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

En esta versión del cliente de Java WebSockets es el único transporte disponible.

En el cliente de Java, el transporte se selecciona con el método withTransport en el HttpHubConnectionBuilder. El cliente java usa el transporte de WebSockets de forma predeterminada.

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

Configuración de la autenticación de portador

Para proporcionar datos de autenticación junto con SignalR las solicitudes, use la AccessTokenProvider opción (accessTokenFactory en JavaScript) para especificar una función que devuelva el token de acceso deseado. En el cliente .NET, este token de acceso se pasa como un token HTTP de "Autenticación de Portador" (mediante el encabezado Authorization con un tipo de Bearer). En el cliente de JavaScript, el token de acceso se usa como token de portador, excepto en algunos casos en los que las API del explorador restringen la capacidad de aplicar encabezados (en concreto, en Server-Sent eventos y solicitudes de WebSockets). En estos casos, el token de acceso se proporciona como un valor de cadena de consulta access_token.

En el cliente .NET, la AccessTokenProvider opción se puede especificar mediante el delegado de opciones en WithUrl:

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

En el cliente de JavaScript, el token de acceso se configura estableciendo el accessTokenFactory campo en el objeto options de 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();

En el SignalR cliente de Java, puede configurar un token de portador que se usará para la autenticación proporcionando una factoría de tokens de acceso a HttpHubConnectionBuilder. Use withAccessTokenFactory para proporcionar una cadena <. Con una llamada a Single.defer, puede escribir lógica para generar tokens de acceso para el cliente.

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

Configurar las opciones de tiempo de espera y conexión persistente

Hay disponibles opciones adicionales para configurar el tiempo de espera y el comportamiento de mantenimiento activo en el HubConnection propio objeto:

Configurar opciones adicionales

Se pueden configurar opciones adicionales en el WithUrl método (withUrl en JavaScript) en HubConnectionBuilder o en las distintas API de configuración de en el HttpHubConnectionBuilder cliente de Java:

En el cliente .NET, estas opciones se pueden modificar mediante el delegado de opciones proporcionado a WithUrl:

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

En el cliente de JavaScript, estas opciones se pueden proporcionar en un objeto javaScript proporcionado a withUrl:

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

En el cliente Java, estas opciones se pueden configurar con los métodos en el HttpHubConnectionBuilder que se devuelve desde el HubConnectionBuilder.create("HUB URL").

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

Recursos adicionales

• Introducción a ASP.NET Core SignalR
• Uso de concentradores en para ASP.NET CoreSignalR
• Cliente de JavaScript en ASP.NET Core SignalR
• Cliente .NET de ASP.NET Core SignalR
• Uso del MessagePack Hub Protocol en SignalR para ASP.NET Core
• Plataformas admitidas de SignalRASP.NET Core

Opciones de serialización JSON/MessagePack

ASP.NET Core SignalR admite dos protocolos para codificar mensajes: JSON y MessagePack. Cada protocolo tiene opciones de configuración de serialización.

La serialización JSON se puede configurar en el servidor utilizando el método de extensión AddJsonProtocol. AddJsonProtocol se puede agregar después de AddSignalR en Startup.ConfigureServices. El método AddJsonProtocol acepta un delegado que recibe un objeto options. La PayloadSerializerOptions propiedad de ese objeto es un System.Text.JsonJsonSerializerOptions objeto que se puede usar para configurar la serialización de argumentos y valores devueltos. Para obtener más información, consulte la documentación de System.Text.Json.

Por ejemplo, para configurar el serializador para que no cambie el uso de mayúsculas y minúsculas en los nombres de propiedad, en lugar de los nombres predeterminados en camel case, use el código siguiente en Startup.ConfigureServices.

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

En el cliente .NET, existe el mismo AddJsonProtocol método de extensión en HubConnectionBuilder. El Microsoft.Extensions.DependencyInjection espacio de nombres debe importarse para resolver el método de extensión:

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

Cambiar a Newtonsoft.Json

Si necesita características de Newtonsoft.Json que no se admiten en System.Text.Json, vea Cambiar a Newtonsoft.Json.

Opciones de serialización de MessagePack

La serialización de MessagePack se puede configurar proporcionando un delegado a la AddMessagePackProtocol llamada. Consulte MessagePack en SignalR para obtener más detalles.

Configurar las opciones del servidor

En la siguiente tabla se describen las opciones para configurar SignalR hubs:

Se pueden configurar opciones para todos los centros proporcionando un delegado de opciones a la llamada AddSignalR en Startup.ConfigureServices.

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

Las opciones de un único centro invalidan las opciones globales proporcionadas en AddSignalR y se pueden configurar mediante AddHubOptions:

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

Opciones avanzadas de configuración http

Use HttpConnectionDispatcherOptions para configurar opciones avanzadas relacionadas con los transportes y la administración del búfer de memoria. Estas opciones se configuran pasando un delegado a MapHub en 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;
        });
    });
}

En la tabla siguiente se describen las opciones para configurar las opciones HTTP avanzadas de ASP.NET Core SignalR:

El transporte de sondeo largo ofrece opciones adicionales que pueden configurarse a través de la propiedad LongPolling.

El transporte de WebSocket tiene opciones adicionales que se pueden configurar mediante la WebSockets propiedad :

Configuración de las opciones de cliente

Las opciones de cliente se pueden configurar en el HubConnectionBuilder tipo (disponible en los clientes de .NET y JavaScript). También está disponible en el cliente de Java, pero la subclase HttpHubConnectionBuilder es la que contiene las opciones de configuración del constructor, además de en el propio HubConnection.

Configurar el registro

El registro se configura en el cliente de .NET usando el método ConfigureLogging. Los proveedores y filtros de registro se pueden registrar de la misma manera que en el servidor. Consulte la documentación de Logging in ASP.NET Core (Registro en ASP.NET Core ) para obtener más información.

Por ejemplo, para habilitar el registro de consola, instale el Microsoft.Extensions.Logging.Console paquete NuGet. Llame al método de extensión AddConsole.

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

En el cliente de JavaScript, existe un método similar configureLogging . Proporcione un LogLevel valor que indique el nivel mínimo de mensajes de registro que se van a generar. Los registros se registran en la ventana de la consola del navegador.

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

En lugar de un LogLevel valor, también puede proporcionar un valor string que represente un nombre de nivel de log. Esto resulta útil al configurar el registro de SignalR en entornos en los que no tienes acceso a las constantes de LogLevel.

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

En la tabla siguiente se enumeran los niveles de registro disponibles. El valor que proporciones para configureLogging establece el nivel de log mínimo que se registrará. Los mensajes registrados en este nivel o los niveles enumerados después de él en la tabla se registrarán.

Para obtener más información sobre el registro, consulte la SignalR documentación de diagnóstico.

El SignalR cliente de Java usa la biblioteca SLF4J para el registro. Es una API de registro de alto nivel que permite a los usuarios de la biblioteca elegir su propia implementación de registro específica mediante la incorporación de una dependencia de registro específica. En el fragmento de código siguiente se muestra cómo usar java.util.logging con el SignalR cliente de Java.

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

En caso de no configurar el registro en tus dependencias, SLF4J carga un registrador predeterminado de no operación con el siguiente mensaje de advertencia:

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.

Esto se puede ignorar.

Configurar los transportes permitidos

Los transportes usados por SignalR se pueden configurar en la WithUrl llamada (withUrl en JavaScript). Se puede usar un OR bit a bit de los valores de HttpTransportType para restringir el cliente para que solo use los transportes especificados. Todos los transportes están habilitados de forma predeterminada.

Por ejemplo, para deshabilitar el transporte de eventos de Server-Sent, pero permitir conexiones WebSockets y Long Polling:

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

En el cliente de JavaScript, los transportes se configuran estableciendo el transport campo en el objeto options proporcionado a withUrl:

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

En esta versión del cliente de Java WebSockets es el único transporte disponible.

En el cliente de Java, el transporte se selecciona con el método withTransport en el HttpHubConnectionBuilder. El cliente java usa el transporte de WebSockets de forma predeterminada.

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

Configuración de la autenticación de portador

Para proporcionar datos de autenticación junto con SignalR las solicitudes, use la AccessTokenProvider opción (accessTokenFactory en JavaScript) para especificar una función que devuelva el token de acceso deseado. En el cliente .NET, este token de acceso se pasa como un token HTTP de "Autenticación de Portador" (mediante el encabezado Authorization con un tipo de Bearer). En el cliente de JavaScript, el token de acceso se usa como token de portador, excepto en algunos casos en los que las API del explorador restringen la capacidad de aplicar encabezados (en concreto, en Server-Sent eventos y solicitudes de WebSockets). En estos casos, el token de acceso se proporciona como un valor de cadena de consulta access_token.

En el cliente .NET, la AccessTokenProvider opción se puede especificar mediante el delegado de opciones en WithUrl:

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

En el cliente de JavaScript, el token de acceso se configura estableciendo el accessTokenFactory campo en el objeto options de 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();

En el SignalR cliente de Java, puede configurar un token de portador que se usará para la autenticación proporcionando una factoría de tokens de acceso a HttpHubConnectionBuilder. Use withAccessTokenFactory para proporcionar una cadena <. Con una llamada a Single.defer, puede escribir lógica para generar tokens de acceso para el cliente.

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

Configurar las opciones de tiempo de espera y conexión persistente

Hay disponibles opciones adicionales para configurar el tiempo de espera y el comportamiento de mantenimiento activo en el HubConnection propio objeto:

Configurar opciones adicionales

Se pueden configurar opciones adicionales en el WithUrl método (withUrl en JavaScript) en HubConnectionBuilder o en las distintas API de configuración de en el HttpHubConnectionBuilder cliente de Java:

En el cliente .NET, estas opciones se pueden modificar mediante el delegado de opciones proporcionado a 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();

En el cliente de JavaScript, estas opciones se pueden proporcionar en un objeto javaScript proporcionado 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();

En el cliente Java, estas opciones se pueden configurar con los métodos en el HttpHubConnectionBuilder que se devuelve desde el HubConnectionBuilder.create("HUB URL").

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

Recursos adicionales

• Introducción a ASP.NET Core SignalR
• Uso de concentradores en para ASP.NET CoreSignalR
• Cliente de JavaScript en ASP.NET Core SignalR
• Cliente .NET de ASP.NET Core SignalR
• Uso del MessagePack Hub Protocol en SignalR para ASP.NET Core
• Plataformas admitidas de SignalRASP.NET Core

Opciones de serialización JSON/MessagePack

ASP.NET Core SignalR admite dos protocolos para codificar mensajes: JSON y MessagePack. Cada protocolo tiene opciones de configuración de serialización.

La serialización JSON se puede configurar en el servidor utilizando el método de extensión AddJsonProtocol. AddJsonProtocol se puede agregar después de AddSignalR en Program.cs. El método AddJsonProtocol acepta un delegado que recibe un objeto options. La PayloadSerializerOptions propiedad de ese objeto es un System.Text.JsonJsonSerializerOptions objeto que se puede usar para configurar la serialización de argumentos y valores devueltos. Para obtener más información, consulte la documentación de System.Text.Json.

Por ejemplo, para configurar el serializador para que no cambie el uso de mayúsculas y minúsculas en los nombres de propiedad, en lugar de los nombres predeterminados en camel case, use el código siguiente en Program.cs.

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

En el cliente .NET, existe el mismo AddJsonProtocol método de extensión en HubConnectionBuilder. El Microsoft.Extensions.DependencyInjection espacio de nombres debe importarse para resolver el método de extensión:

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

Cambiar a Newtonsoft.Json

Si necesita características de Newtonsoft.Json que no se admiten en System.Text.Json, vea Cambiar a Newtonsoft.Json.

Opciones de serialización de MessagePack

La serialización de MessagePack se puede configurar proporcionando un delegado a la AddMessagePackProtocol llamada. Consulte MessagePack en SignalR para obtener más detalles.

Configurar las opciones del servidor

En la siguiente tabla se describen las opciones para configurar SignalR hubs:

Se pueden configurar opciones para todos los centros proporcionando un delegado de opciones a la llamada AddSignalR en Program.cs.

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

Las opciones de un único centro invalidan las opciones globales proporcionadas en AddSignalR y se pueden configurar mediante AddHubOptions:

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

Opciones avanzadas de configuración http

Use HttpConnectionDispatcherOptions para configurar opciones avanzadas relacionadas con los transportes y la administración del búfer de memoria. Estas opciones se configuran pasando un delegado a MapHub en 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();

En la tabla siguiente se describen las opciones para configurar las opciones HTTP avanzadas de ASP.NET Core SignalR:

El transporte de sondeo largo ofrece opciones adicionales que pueden configurarse a través de la propiedad LongPolling.

El transporte de WebSocket tiene opciones adicionales que se pueden configurar mediante la WebSockets propiedad :

Configuración de las opciones de cliente

Las opciones de cliente se pueden configurar en el HubConnectionBuilder tipo (disponible en los clientes de .NET y JavaScript). También está disponible en el cliente de Java, pero la subclase HttpHubConnectionBuilder es la que contiene las opciones de configuración del constructor, además de en el propio HubConnection.

Configurar el registro

El registro se configura en el cliente de .NET usando el método ConfigureLogging. Los proveedores y filtros de registro se pueden registrar de la misma manera que en el servidor. Consulte la documentación de Logging in ASP.NET Core (Registro en ASP.NET Core ) para obtener más información.

Por ejemplo, para habilitar el registro de consola, instale el Microsoft.Extensions.Logging.Console paquete NuGet. Llame al método de extensión AddConsole.

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

En el cliente de JavaScript, existe un método similar configureLogging . Proporcione un LogLevel valor que indique el nivel mínimo de mensajes de registro que se van a generar. Los registros se registran en la ventana de la consola del navegador.

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

En lugar de un LogLevel valor, también puede proporcionar un valor string que represente un nombre de nivel de log. Esto resulta útil al configurar el registro de SignalR en entornos en los que no tienes acceso a las constantes de LogLevel.

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

En la tabla siguiente se enumeran los niveles de registro disponibles. El valor que proporciones para configureLogging establece el nivel de log mínimo que se registrará. Los mensajes registrados en este nivel o los niveles enumerados después de él en la tabla se registrarán.

Para obtener más información sobre el registro, consulte la SignalR documentación de diagnóstico.

El SignalR cliente de Java usa la biblioteca SLF4J para el registro. Es una API de registro de alto nivel que permite a los usuarios de la biblioteca elegir su propia implementación de registro específica mediante la incorporación de una dependencia de registro específica. En el fragmento de código siguiente se muestra cómo usar java.util.logging con el SignalR cliente de Java.

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

En caso de no configurar el registro en tus dependencias, SLF4J carga un registrador predeterminado de no operación con el siguiente mensaje de advertencia:

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.

Esto se puede ignorar.

Configurar los transportes permitidos

Los transportes usados por SignalR se pueden configurar en la WithUrl llamada (withUrl en JavaScript). Se puede usar un OR bit a bit de los valores de HttpTransportType para restringir el cliente para que solo use los transportes especificados. Todos los transportes están habilitados de forma predeterminada.

Por ejemplo, para deshabilitar el transporte de eventos de Server-Sent, pero permitir conexiones WebSockets y Long Polling:

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

En el cliente de JavaScript, los transportes se configuran estableciendo el transport campo en el objeto options proporcionado a withUrl:

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

En esta versión del cliente de Java WebSockets es el único transporte disponible.

En el cliente de Java, el transporte se selecciona con el método withTransport en el HttpHubConnectionBuilder. El cliente java usa el transporte de WebSockets de forma predeterminada.

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

Configuración de la autenticación de portador

Para proporcionar datos de autenticación junto con SignalR las solicitudes, use la AccessTokenProvider opción (accessTokenFactory en JavaScript) para especificar una función que devuelva el token de acceso deseado. En el cliente .NET, este token de acceso se pasa como un token HTTP de "Autenticación de Portador" (mediante el encabezado Authorization con un tipo de Bearer). En el cliente de JavaScript, el token de acceso se usa como token de portador, excepto en algunos casos en los que las API del explorador restringen la capacidad de aplicar encabezados (en concreto, en Server-Sent eventos y solicitudes de WebSockets). En estos casos, el token de acceso se proporciona como un valor de cadena de consulta access_token.

En el cliente .NET, la AccessTokenProvider opción se puede especificar mediante el delegado de opciones en WithUrl:

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

En el cliente de JavaScript, el token de acceso se configura estableciendo el accessTokenFactory campo en el objeto options de 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();

En el SignalR cliente de Java, puede configurar un token de portador que se usará para la autenticación proporcionando una factoría de tokens de acceso a HttpHubConnectionBuilder. Use withAccessTokenFactory para proporcionar una cadena <. Con una llamada a Single.defer, puede escribir lógica para generar tokens de acceso para el cliente.

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

Configurar las opciones de tiempo de espera y conexión persistente

Hay disponibles opciones adicionales para configurar el tiempo de espera y el comportamiento de mantenimiento activo en el HubConnection propio objeto:

Configurar opciones adicionales

Se pueden configurar opciones adicionales en el WithUrl método (withUrl en JavaScript) en HubConnectionBuilder o en las distintas API de configuración de en el HttpHubConnectionBuilder cliente de Java:

En el cliente .NET, estas opciones se pueden modificar mediante el delegado de opciones proporcionado a 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();

En el cliente de JavaScript, estas opciones se pueden proporcionar en un objeto javaScript proporcionado 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();

En el cliente Java, estas opciones se pueden configurar con los métodos en el HttpHubConnectionBuilder que se devuelve desde el HubConnectionBuilder.create("HUB URL").

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

Recursos adicionales

• Introducción a ASP.NET Core SignalR
• Uso de concentradores en para ASP.NET CoreSignalR
• Cliente de JavaScript en ASP.NET Core SignalR
• Cliente .NET de ASP.NET Core SignalR
• Uso del MessagePack Hub Protocol en SignalR para ASP.NET Core
• Plataformas admitidas de SignalRASP.NET Core

Opciones de serialización JSON/MessagePack

ASP.NET Core SignalR admite dos protocolos para codificar mensajes: JSON y MessagePack. Cada protocolo tiene opciones de configuración de serialización.

La serialización JSON se puede configurar en el servidor utilizando el método de extensión AddJsonProtocol. AddJsonProtocol se puede agregar después de AddSignalR en Startup.ConfigureServices. El método AddJsonProtocol acepta un delegado que recibe un objeto options. La PayloadSerializerOptions propiedad de ese objeto es un System.Text.JsonJsonSerializerOptions objeto que se puede usar para configurar la serialización de argumentos y valores devueltos. Para obtener más información, consulte la documentación de System.Text.Json.

Por ejemplo, para configurar el serializador para que no cambie el uso de mayúsculas y minúsculas en los nombres de propiedad, en lugar de los nombres predeterminados en camel case, use el código siguiente en Program.cs.

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

En el cliente .NET, existe el mismo AddJsonProtocol método de extensión en HubConnectionBuilder. El Microsoft.Extensions.DependencyInjection espacio de nombres debe importarse para resolver el método de extensión:

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

Cambiar a Newtonsoft.Json

Si necesita características de Newtonsoft.Json que no se admiten en System.Text.Json, vea Cambiar a Newtonsoft.Json.

Opciones de serialización de MessagePack

La serialización de MessagePack se puede configurar proporcionando un delegado a la AddMessagePackProtocol llamada. Consulte MessagePack en SignalR para obtener más detalles.

Configurar las opciones del servidor

En la siguiente tabla se describen las opciones para configurar SignalR hubs:

Se pueden configurar opciones para todos los centros proporcionando un delegado de opciones a la llamada AddSignalR en Program.cs.

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

Las opciones de un único centro invalidan las opciones globales proporcionadas en AddSignalR y se pueden configurar mediante AddHubOptions:

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

Opciones avanzadas de configuración http

Use HttpConnectionDispatcherOptions para configurar opciones avanzadas relacionadas con los transportes y la administración del búfer de memoria. Estas opciones se configuran pasando un delegado a MapHub en 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();

En la tabla siguiente se describen las opciones para configurar las opciones HTTP avanzadas de ASP.NET Core SignalR:

El transporte de sondeo largo ofrece opciones adicionales que pueden configurarse a través de la propiedad LongPolling.

El transporte de WebSocket tiene opciones adicionales que se pueden configurar mediante la WebSockets propiedad :

Configuración de las opciones de cliente

Las opciones de cliente se pueden configurar en el HubConnectionBuilder tipo (disponible en los clientes de .NET y JavaScript). También está disponible en el cliente de Java, pero la subclase HttpHubConnectionBuilder es la que contiene las opciones de configuración del constructor, además de en el propio HubConnection.

Configurar el registro

El registro se configura en el cliente de .NET usando el método ConfigureLogging. Los proveedores y filtros de registro se pueden registrar de la misma manera que en el servidor. Consulte la documentación de Logging in ASP.NET Core (Registro en ASP.NET Core ) para obtener más información.

Por ejemplo, para habilitar el registro de consola, instale el Microsoft.Extensions.Logging.Console paquete NuGet. Llame al método de extensión AddConsole.

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

En el cliente de JavaScript, existe un método similar configureLogging . Proporcione un LogLevel valor que indique el nivel mínimo de mensajes de registro que se van a generar. Los registros se registran en la ventana de la consola del navegador.

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

En lugar de un LogLevel valor, también puede proporcionar un valor string que represente un nombre de nivel de log. Esto resulta útil al configurar el registro de SignalR en entornos en los que no tienes acceso a las constantes de LogLevel.

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

En la tabla siguiente se enumeran los niveles de registro disponibles. El valor que proporciones para configureLogging establece el nivel de log mínimo que se registrará. Los mensajes registrados en este nivel o los niveles enumerados después de él en la tabla se registrarán.

Para obtener más información sobre el registro, consulte la SignalR documentación de diagnóstico.

El SignalR cliente de Java usa la biblioteca SLF4J para el registro. Es una API de registro de alto nivel que permite a los usuarios de la biblioteca elegir su propia implementación de registro específica mediante la incorporación de una dependencia de registro específica. En el fragmento de código siguiente se muestra cómo usar java.util.logging con el SignalR cliente de Java.

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

En caso de no configurar el registro en tus dependencias, SLF4J carga un registrador predeterminado de no operación con el siguiente mensaje de advertencia:

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.

Esto se puede ignorar.

Configurar los transportes permitidos

Los transportes usados por SignalR se pueden configurar en la WithUrl llamada (withUrl en JavaScript). Se puede usar un OR bit a bit de los valores de HttpTransportType para restringir el cliente para que solo use los transportes especificados. Todos los transportes están habilitados de forma predeterminada.

Por ejemplo, para deshabilitar el transporte de eventos de Server-Sent, pero permitir conexiones WebSockets y Long Polling:

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

En el cliente de JavaScript, los transportes se configuran estableciendo el transport campo en el objeto options proporcionado a withUrl:

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

En esta versión del cliente de Java WebSockets es el único transporte disponible.

En el cliente de Java, el transporte se selecciona con el método withTransport en el HttpHubConnectionBuilder. El cliente java usa el transporte de WebSockets de forma predeterminada.

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

Configuración de la autenticación de portador

Para proporcionar datos de autenticación junto con SignalR las solicitudes, use la AccessTokenProvider opción (accessTokenFactory en JavaScript) para especificar una función que devuelva el token de acceso deseado. En el cliente .NET, este token de acceso se pasa como un token HTTP de "Autenticación de Portador" (mediante el encabezado Authorization con un tipo de Bearer). En el cliente de JavaScript, el token de acceso se usa como token de portador, excepto en algunos casos en los que las API del explorador restringen la capacidad de aplicar encabezados (en concreto, en Server-Sent eventos y solicitudes de WebSockets). En estos casos, el token de acceso se proporciona como un valor de cadena de consulta access_token.

En el cliente .NET, la AccessTokenProvider opción se puede especificar mediante el delegado de opciones en WithUrl:

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

En el cliente de JavaScript, el token de acceso se configura estableciendo el accessTokenFactory campo en el objeto options de 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();

En el SignalR cliente de Java, puede configurar un token de portador que se usará para la autenticación proporcionando una factoría de tokens de acceso a HttpHubConnectionBuilder. Use withAccessTokenFactory para proporcionar una cadena <. Con una llamada a Single.defer, puede escribir lógica para generar tokens de acceso para el cliente.

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

Configurar las opciones de tiempo de espera y conexión persistente

Hay disponibles opciones adicionales para configurar el tiempo de espera y el comportamiento de mantenimiento activo en el HubConnection propio objeto:

Configurar opciones adicionales

Se pueden configurar opciones adicionales en el WithUrl método (withUrl en JavaScript) en HubConnectionBuilder o en las distintas API de configuración de en el HttpHubConnectionBuilder cliente de Java:

En el cliente .NET, estas opciones se pueden modificar mediante el delegado de opciones proporcionado a 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();

En el cliente de JavaScript, estas opciones se pueden proporcionar en un objeto javaScript proporcionado 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();

En el cliente Java, estas opciones se pueden configurar con los métodos en el HttpHubConnectionBuilder que se devuelve desde el HubConnectionBuilder.create("HUB URL").

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

Recursos adicionales

• Introducción a ASP.NET Core SignalR
• Uso de concentradores en para ASP.NET CoreSignalR
• Cliente de JavaScript en ASP.NET Core SignalR
• Cliente .NET de ASP.NET Core SignalR
• Uso del MessagePack Hub Protocol en SignalR para ASP.NET Core
• Plataformas admitidas de SignalRASP.NET Core