Plataformas com suporte do SignalR do ASP.

NET Core

• 05/04/2019
• 2 minutos para ler

Requisitos de sistema do servidor

SignalR para [Link] Core dá suporte a qualquer plataforma de servidor que dá suporte ao [Link]
Core.

Cliente JavaScript
O cliente JavaScript é executado no NodeJS 8 e versões posteriores e os seguintes navegadores:
Navegador Versão
Microsoft Edge atual
Mozilla Firefox atual
Google Chrome; inclui o Android atual
Safari; inclui o iOS atual
Microsoft Internet Explorer 11

Cliente .NET
O cliente .NET é executado em qualquer plataforma com suporte pelo [Link] Core. Por
exemplo, desenvolvedores Xamarin podem usar o SignalR para a criação de aplicativos Android
usando o xamarin. Android [Link] e posterior e aplicativos iOS usando xamarin. IOS [Link] e
versões posteriores.
Se o servidor executa o IIS, o transporte de WebSockets requer o IIS 8.0 ou posterior no Windows
Server 2012 ou posterior. Outros transportes têm suporte em todas as plataformas.

Cliente Java
O cliente Java dá suporte a Java 8 e versões posteriores.

Não há suporte para clientes

Os clientes a seguir estão disponíveis, mas são experimentais ou não oficial. Eles não têm suporte no
momento e nunca podem ser.
• Cliente C++
• Cliente SWIFT

De <[Link]

Página 1 de SignalR para [Link] Core

 Tutorial: Introdução ao SignalR para [Link] Core

• 07/07/2019
• 12 minutos para ler

Este tutorial ensina as noções básicas da criação de um aplicativo em tempo real usando o
SignalR. Você aprenderá como:
• Crie um projeto Web.
• Adicionar uma biblioteca de clientes do SignalR.
• Criar um hub do SignalR.
• Configurar o projeto para usar o SignalR.
• Adicione o código que envia mensagens de qualquer cliente para todos os clientes conectados.
No final, você terá um aplicativo de chat funcionando:

Pré-requisitos
• Visual Studio
• Visual Studio Code
• Visual Studio para Mac
• Visual Studio 2017 versão 15.9 ou posterior com a carga de trabalho [Link] e
desenvolvimento para a Web. É possível usar o Visual Studio 2019, mas algumas etapas da
criação de projetos são diferentes do mostrado no tutorial.
• SDK 2.2 ou posterior do .NET Core
Aviso
Se você usar o Visual Studio 2017, confira problema de dotnet/sdk nº 3124 para obter informações
sobre as versões do SDK do .NET Core que não funcionam com o Visual Studio.

Criar um projeto Web

• Visual Studio
• Visual Studio Code
• Visual Studio para Mac
• No menu, selecione Arquivo > Novo Projeto.
• Na caixa de diálogo Novo Projeto, selecione Instalado > Visual C# > Web > Aplicativo Web
[Link] Core. Dê ao projeto o nome de SignalRChat.

Página 2 de SignalR para [Link] Core

 • Selecione Aplicativo Web para criar um projeto que usa Razor Pages.
• Selecione uma estrutura de destino do .NET Core, selecione [Link] Core 2.2 e clique em OK.

Adicionar a biblioteca de clientes do SignalR

A biblioteca do servidor SignalR está incluída no metapacote [Link]. A biblioteca
de clientes do JavaScript não é incluída automaticamente no projeto. Neste tutorial, você usará o
LibMan (Library Manager) para obter a biblioteca de clientes de unpkg. unpkg é uma CDN (rede de
distribuição de conteúdo) que pode distribuir qualquer conteúdo do npm, o gerenciador de pacotes
do [Link].
• Visual Studio
• Visual Studio Code
• Visual Studio para Mac
• No Gerenciador de Soluções, clique com o botão direito do mouse no projeto e
selecione Adicionar > Biblioteca do Lado do Cliente.
• Na caixa de diálogo Adicionar Biblioteca do Lado do Cliente, para Provedor, selecione unpkg.
• Para Biblioteca, insira @aspnet/signalr@1 e selecione a versão mais recente que não seja uma
versão prévia.

Página 3 de SignalR para [Link] Core

 • Selecione Escolher arquivos específicos, expanda a pasta distribuidor/navegador e
selecione [Link] e [Link].
• Defina Localização de Destino como wwwroot/lib/signalr/ e selecione Instalar.

O LibMan cria uma pasta wwwroot/lib/signalr e copia os arquivos selecionados para ela.

Criar um hub do SignalR

Um hub é uma classe que funciona como um pipeline de alto nível que lida com a comunicação
entre cliente e servidor.
• Na pasta do projeto SignalRChat, crie uma pasta Hubs.
• Na pasta Hubs, crie um arquivo [Link] com o código a seguir:
C#Copiar
using [Link];
using [Link];

namespace [Link]
{
public class ChatHub : Hub
{

Página 4 de SignalR para [Link] Core

 {
public async Task SendMessage(string user, string message)
{
await [Link]("ReceiveMessage", user, message);
}
}
}

A classe ChatHub é herda da classe Hub do SignalR. A classe Hub gerencia conexões, grupos e
sistemas de mensagens.
O método SendMessage pode ser chamado por um cliente conectado para enviar uma
mensagem a todos os clientes. O código cliente do JavaScript que chama o método é mostrado
posteriormente no tutorial. O código do SignalR é assíncrono para fornecer o máximo de
escalabilidade.

Configurar o SignalR
O servidor do SignalR precisa ser configurado para passar solicitações do SignalR ao SignalR.
• Adicione o seguinte código realçado ao arquivo [Link].
C#Copiar

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

namespace SignalRChat
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}

public IConfiguration Configuration { get; }

// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
[Link]<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a
given request.
[Link] = context => true;
[Link] = [Link];
});

[Link]().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);

[Link]();
}

// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if ([Link]())
{

Página 5 de SignalR para [Link] Core

 {
[Link]();
}
else
{
[Link]("/Error");
[Link]();
}

[Link]();
[Link]();
[Link]();
[Link](routes =>
{
[Link]<ChatHub>("/chatHub");
});
[Link]();
}
}
}

Essas alterações adicionam o SignalR ao sistema de injeção de dependência e ao pipeline do

middleware do [Link] Core.

Adicionar o código de cliente do SignalR

• Substitua o conteúdo Pages\[Link] pelo código a seguir:
CSHTMLCopiar
@page
<div class="container">
<div class="row">&nbsp;</div>
<div class="row">
<div class="col-6">&nbsp;</div>
<div class="col-6">
User..........<input type="text" id="userInput" />
<br />
Message...<input type="text" id="messageInput" />
<input type="button" id="sendButton" value="Send Message" />
</div>
</div>
<div class="row">
<div class="col-12">
<hr />
</div>
</div>
<div class="row">
<div class="col-6">&nbsp;</div>
<div class="col-6">
<ul id="messagesList"></ul>
</div>
</div>
</div>
<script src="~/lib/signalr/dist/browser/[Link]"></script>
<script src="~/js/[Link]"></script>

O código anterior:
• Cria as caixas de texto para o nome e a mensagem de texto e um botão Enviar.
• Cria uma lista com id="messagesList" para exibir as mensagens recebidas do hub do SignalR.
• Inclui referências de script ao SignalR e ao código do aplicativo [Link] que você criará na
próxima etapa.
• Na pasta wwwroot/js, crie um arquivo [Link] com o código a seguir:

Página 6 de SignalR para [Link] Core

 • Na pasta wwwroot/js, crie um arquivo [Link] com o código a seguir:
JavaScriptCopiar
"use strict";

var connection = new [Link]().withUrl("/chatHub").build();

//Disable send button until connection is established

[Link]("sendButton").disabled = true;

[Link]("ReceiveMessage", function (user, message) {

var msg = [Link](/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
var encodedMsg = user + " says " + msg;
var li = [Link]("li");
[Link] = encodedMsg;
[Link]("messagesList").appendChild(li);
});

[Link]().then(function(){
[Link]("sendButton").disabled = false;
}).catch(function (err) {
return [Link]([Link]());
});

[Link]("sendButton").addEventListener("click", function (event) {

var user = [Link]("userInput").value;
var message = [Link]("messageInput").value;
[Link]("SendMessage", user, message).catch(function (err) {
return [Link]([Link]());
});
[Link]();
});

O código anterior:
• Cria e inicia uma conexão.
• Adiciona no botão Enviar um manipulador que envia mensagens ao hub.
• Adiciona no objeto de conexão um manipulador que recebe mensagens do hub e as adiciona à
lista.

Executar o aplicativo
• Visual Studio
• Visual Studio Code
• Visual Studio para Mac
• Pressione CTRL + F5 para executar o aplicativo sem depuração.
• Copie a URL da barra de endereços, abra outra instância ou guia do navegador e cole a URL na
barra de endereços.
• Escolha qualquer navegador, insira um nome e uma mensagem e selecione o botão Enviar
Mensagem.
O nome e a mensagem são exibidos em ambas as páginas instantaneamente.

Página 7 de SignalR para [Link] Core

 Dica
Se o aplicativo não funcionar, abra as ferramentas para desenvolvedores do navegador (F12) e
acesse o console. Você pode encontrar erros relacionados ao código HTML e JavaScript. Por
exemplo, suponha que você coloque [Link] em uma pasta diferente daquela direcionada. Nesse
caso, a referência a esse arquivo não funcionará e ocorrerá um erro 404 no console.

Próximas etapas
Neste tutorial, você aprendeu como:
• Criar um projeto de aplicativo Web.
• Adicionar uma biblioteca de clientes do SignalR.
• Criar um hub do SignalR.
• Configurar o projeto para usar o SignalR.
• Adicionar o código que usa o hub para enviar mensagens de qualquer cliente para todos os
clientes conectados.
Para saber mais sobre o SignalR, confira a introdução:
Introdução ao [Link] Core SignalR

De <[Link]

Página 8 de SignalR para [Link] Core

 Usar o SignalR do [Link] Core com TypeScript e
Webpack

• 22/04/2019
• 9 minutos para ler

Por Sébastien Sougnez e Scott Addie

O Webpack habilita os desenvolvedores a agrupar e criar recursos de um aplicativo Web do lado do
cliente. Este tutorial demonstra como usar o Webpack em um aplicativo Web SignalR do [Link]
Core cujo cliente é escrito em TypeScript.
Neste tutorial, você aprenderá como:
• Gerar um aplicativo inicial SignalR do [Link] Core por scaffold
• Configurar o cliente TypeScript do SignalR
• Configurar um pipeline de build usando o Webpack
• Configurar o servidor SignalR
• Habilitar a comunicação entre o cliente e o servidor
Exibir ou baixar código de exemplo (como baixar)

Pré-requisitos
• Visual Studio
• Visual Studio Code
• Visual Studio 2019 com carga de trabalho [Link] e desenvolvimento Web
• SDK 2.2 ou posterior do .NET Core
• [Link] com npm

Criar o aplicativo Web do [Link] Core

• Visual Studio
• Visual Studio Code
Configure o Visual Studio para pesquisar o npm na variável de ambiente PATH. Por padrão, o Visual
Studio usa a versão do npm encontrada no diretório de instalação. Siga estas instruções no Visual
Studio:
1. Navegue para Ferramentas > Opções > Projetos e Soluções > Gerenciamento de Pacotes da
Web > Ferramentas da Web Externas.
2. Selecione a entrada $(PATH) na lista. Clique na seta para cima para mover a entrada para a
segunda posição da lista.

Página 9 de SignalR para [Link] Core

A configuração do Visual Studio foi concluída. É hora de criar o projeto.
1. Use a opção do menu Arquivo > Novo > Projeto e escolha o modelo Aplicativo Web do
[Link] Core.
2. Dê ao projeto o nome SignalRWebPack e selecione OK.
3. Selecione .NET Core no menu suspenso da estrutura de destino e selecione [Link] Core
2.2 no menu suspenso do seletor de estrutura. Selecione o modelo Vazio e selecione OK.

Configurar Webpack e TypeScript

As etapas a seguir configuram a conversão do TypeScript para JavaScript e o agrupamento de
recursos no lado do cliente.
1. Execute o seguinte comando na raiz do projeto para criar um arquivo [Link]:
consoleCopiar
npm init -y
2. Adicione a propriedade destacada ao arquivo [Link]:
JSONCopiar

{
"name": "SignalRWebPack",
"version": "1.0.0",
"private": true,
"description": "",
"main": "[Link]",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC"
}

Definir a propriedade private como true evita avisos de instalação de pacote na próxima etapa.
3. Instalar os pacotes de npm exigidos. Execute o seguinte comando na raiz do projeto:
consoleCopiar
npm install -D -E clean-webpack-plugin@1.0.1 css-loader@2.1.0 html-webpack-plugin@4.0.0-beta.5
mini-css-extract-plugin@0.5.0 ts-loader@5.3.3 typescript@3.3.3 webpack@4.29.3 webpack-cli@3.2.3

Alguns detalhes de comando a se observar:

○ Um número de versão segue o sinal @ para cada nome de pacote. O npm instala essas
versões específicas do pacote.
○ A opção -E desabilita o comportamento padrão do npm de escrever os operadores de
intervalo de versão semântica para [Link]. Por exemplo, "webpack": "4.29.3" é

Página 10 de SignalR para [Link] Core

 intervalo de versão semântica para [Link]. Por exemplo, "webpack": "4.29.3" é
usado em vez de "webpack": "^4.29.3". Essa opção evita atualizações não intencionais
para versões de pacote mais recentes.
Veja os documentos oficiais de instalação de npm para saber mais detalhes.
4. Substitua a propriedade scripts do arquivo [Link] com o seguinte snippet:
JSONCopiar
"scripts": {
"build": "webpack --mode=development --watch",
"release": "webpack --mode=production",
"publish": "npm run release && dotnet publish -c Release"
},

Uma explicação sobre os scripts:

○ build: agrupa os recursos do lado do cliente no modo de desenvolvimento e busca
alterações no arquivo. O observador de arquivos faz com que o lote se regenere toda
vez que um arquivo de projeto é alterado. A opção mode desabilita otimizações de
produção, como tree shaking e minificação. Use somente build no desenvolvimento.
○ release: agrupa recursos do lado do cliente no modo de produção.
○ publish: executa o script release para agrupar recursos do lado do cliente no modo de
produção. Chama o comando publicar da CLI do .NET Core para publicar o aplicativo.
5. Crie um arquivo chamado [Link] na raiz do projeto, com o seguinte conteúdo:
JavaScriptCopiar
const path = require("path");
const HtmlWebpackPlugin = require("html-webpack-plugin");
const CleanWebpackPlugin = require("clean-webpack-plugin");
const MiniCssExtractPlugin = require("mini-css-extract-plugin");

[Link] = {
entry: "./src/[Link]",
output: {
path: [Link](__dirname, "wwwroot"),
filename: "[name].[chunkhash].js",
publicPath: "/"
},
resolve: {
extensions: [".js", ".ts"]
},
module: {
rules: [
{
test: /\.ts$/,
use: "ts-loader"
},
{
test: /\.css$/,
use: [[Link], "css-loader"]
}
]
},
plugins: [
new CleanWebpackPlugin(["wwwroot/*"]),
new HtmlWebpackPlugin({
template: "./src/[Link]"
}),
new MiniCssExtractPlugin({
filename: "css/[name].[chunkhash].css"
})
]
};

O arquivo precedente configura a compilação Webpack. Detalhes de configuração a serem

notados:

Página 11 de SignalR para [Link] Core

 notados:
○ A propriedade output substitui o valor padrão do dist. Em vez disso, o lote é emitido no
diretório wwwroot.
○ A matriz [Link] inclui .js para importar o JavaScript do cliente SignalR.
6. Crie um novo diretório src na raiz do projeto. O propósito é armazenar os ativos do lado do
cliente do projeto.
7. Crie src/[Link] com o seguinte conteúdo.
HTMLCopiar
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>[Link] Core SignalR</title>
</head>
<body>
<div id="divMessages" class="messages">
</div>
<div class="input-zone">
<label id="lblMessage" for="tbMessage">Message:</label>
<input id="tbMessage" class="input-zone-input" type="text" />
<button id="btnSend">Send</button>
</div>
</body>
</html>

A HTML precedente define a marcação clichê da página inicial.

8. Crie um novo diretório src/css. Seu propósito é armazenar os arquivos do projeto .css.
9. Crie src/css/[Link] com o seguinte conteúdo:
cssCopiar
*, *::before, *::after {
box-sizing: border-box;
}

html, body {
margin: 0;
padding: 0;
}

.input-zone {
align-items: center;
display: flex;
flex-direction: row;
margin: 10px;
}

.input-zone-input {
flex: 1;
margin-right: 10px;
}

.message-author {
font-weight: bold;
}

.messages {
border: 1px solid #000;
margin: 10px;
max-height: 300px;
min-height: 300px;
overflow-y: auto;
padding: 5px;
}

Página 12 de SignalR para [Link] Core

 }

O arquivo precedente [Link] define o estilo do aplicativo.

10. Crie src/[Link] com o seguinte conteúdo:
JSONCopiar
{
"compilerOptions": {
"target": "es5"
}
}

O código precedente configura o compilador TypeScript para produzir um JavaScript

compatível com ECMAScript 5.
11. Crie src/[Link] com o seguinte conteúdo:
TypeScriptCopiar
import "./css/[Link]";

const divMessages: HTMLDivElement = [Link]("#divMessages");

const tbMessage: HTMLInputElement = [Link]("#tbMessage");
const btnSend: HTMLButtonElement = [Link]("#btnSend");
const username = new Date().getTime();

[Link]("keyup", (e: KeyboardEvent) => {

if ([Link] === 13) {
send();
}
});

[Link]("click", send);

function send() {
}

O TypeScript precedente recupera referências a elementos DOM e anexa dois manipuladores

de eventos:
○ keyup: esse evento é acionado quando o usuário digita algo na caixa de texto
identificada como tbMessage. A função send é chamada quando o usuário pressionar a
tecla Enter.
○ click: esse evento é acionado quando o usuário clica no botão Enviar. A função send é
chamada.

Configurar o aplicativo do [Link] Core

1. O código fornecido no método [Link] exibe Olá, Mundo. Substitua a chamada para o
método [Link] com chamadas para UseDefaultFiles e UseStaticFiles.
C#Copiar
[Link]();
[Link]();

O código precedente permite que o servidor localize e forneça o arquivo [Link], se o

usuário inserir a URL completa ou a URL raiz do aplicativo Web.
2. Chame AddSignalR no método [Link]. Adiciona serviços SignalR ao seu
projeto.
C#Copiar
[Link]();
3. Mapeie uma rota /hub para o hub ChatHub. Adicione as linhas a seguir ao final do
método [Link]:
C#Copiar
[Link](options =>
{

Página 13 de SignalR para [Link] Core

 {
[Link]<ChatHub>("/hub");
});
4. Crie um novo diretório, chamado Hubs, na raiz do projeto. A finalidade é armazenar o hub
SignalR, que é criado na próxima etapa.
5. Crie o hub Hubs/[Link] com o código a seguir:
C#Copiar
using [Link];
using [Link];

namespace [Link]
{
public class ChatHub : Hub
{
}
}
6. Adicione o código a seguir ao topo do arquivo [Link] para resolver a referência ChatHub:
C#Copiar
using [Link];

Habilitar a comunicação entre o cliente e o servidor

Atualmente, o aplicativo exibe um formulário simples para enviar mensagens. Nada acontece
quando você tenta fazer alguma coisa.O servidor está escutando uma rota específica, mas não faz
nada com as mensagens enviadas.
1. Execute o comando a seguir na raiz do projeto:
consoleCopiar
npm install @aspnet/signalr

O comando precedente instala o cliente TypeScript do SignalR, que permite ao cliente enviar
mensagens para o servidor.
2. Adicione o código destacado ao arquivo src/[Link]:
TypeScriptCopiar

import "./css/[Link]";
import * as signalR from "@aspnet/signalr";

const divMessages: HTMLDivElement = [Link]("#divMessages");

const tbMessage: HTMLInputElement = [Link]("#tbMessage");
const btnSend: HTMLButtonElement = [Link]("#btnSend");
const username = new Date().getTime();

const connection = new [Link]()

.withUrl("/hub")
.build();

[Link]().catch(err => [Link](err));

[Link]("messageReceived", (username: string, message: string) => {

let m = [Link]("div");

[Link] =
`<div class="message-author">${username}</div><div>${message}</div>`;

[Link](m);
[Link] = [Link];
});

[Link]("keyup", (e: KeyboardEvent) => {

if ([Link] === 13) {
send();

Página 14 de SignalR para [Link] Core

 send();
}
});

[Link]("click", send);

function send() {
}

O código precedente é compatível com o recebimento de mensagens do servidor. A

classe HubConnectionBuilder cria um novo construtor para configurar a conexão do servidor. A
função withUrl configura a URL do hub.
O SignalR habilita a troca de mensagens entre um cliente e um servidor. Cada mensagem tem
um nome específico. Por exemplo, você pode ter mensagens com o
nome messageReceived que executam a lógica responsável por exibir a nova mensagem na
zona de mensagens. É possível escutar uma mensagem específica por meio da função on. Você
pode escutar qualquer número de nomes de mensagem. Também é possível passar
parâmetros para a mensagem, como o nome do autor e o conteúdo da mensagem
recebida. Quando o cliente recebe a mensagem, um novo elemento div é criado com o nome
do autor e o conteúdo da mensagem em seu atributo innerHTML. Ele é adicionado ao
elemento principal div que exibe as mensagens.
3. Agora que o cliente pode receber mensagens, configure-o para enviá-las. Adicione o código
destacado ao arquivo src/[Link]:
TypeScriptCopiar

import "./css/[Link]";
import * as signalR from "@aspnet/signalr";

const divMessages: HTMLDivElement = [Link]("#divMessages");

const tbMessage: HTMLInputElement = [Link]("#tbMessage");
const btnSend: HTMLButtonElement = [Link]("#btnSend");
const username = new Date().getTime();

const connection = new [Link]()

.withUrl("/hub")
.build();

[Link]().catch(err => [Link](err));

[Link]("messageReceived", (username: string, message: string) => {

let messageContainer = [Link]("div");

[Link] =
`<div class="message-author">${username}</div><div>${message}</div>`;

[Link](messageContainer);
[Link] = [Link];
});

[Link]("keyup", (e: KeyboardEvent) => {

if ([Link] === 13) {
send();
}
});

[Link]("click", send);

function send() {
[Link]("newMessage", username, [Link])
.then(() => [Link] = "");
}

Página 15 de SignalR para [Link] Core

 Enviar uma mensagem por meio da conexão WebSockets exige uma chamada para o
método send. O primeiro parâmetro do método é o nome da mensagem. Os dados da
mensagem residem nos outros parâmetros. Neste exemplo, uma mensagem identificada
como newMessage é enviada ao servidor. A mensagem é composta do nome de usuário e da
entrada em uma caixa de texto. Se o envio for bem-sucedido, o valor da caixa de texto será
limpo.
4. Adicione o método em destaque à classe ChatHub:
C#Copiar

using [Link];
using [Link];

namespace [Link]
{
public class ChatHub : Hub
{
public async Task NewMessage(long username, string message)
{
await [Link]("messageReceived", username, message);
}
}
}

O código precedente transmite as mensagens recebidas para todos os usuários conectados

quando o servidor as recebe. Não é necessário ter um método genérico on para receber todas
as mensagens. Um método nomeado com o nome da mensagem é suficiente.
Neste exemplo, o cliente TypeScript envia uma mensagem identificada como newMessage. O
método NewMessage de C# espera os dados enviados pelo cliente. Uma chamada é feita para o
método SendAsync em [Link]. As mensagens recebidas são enviadas a todos os clientes
conectados ao hub.

Testar o aplicativo
Confirme que o aplicativo funciona com as seguintes etapas.
• Visual Studio
• Visual Studio Code
1. Execute o Webpack no modo de versão. Usando a janela Console do Gerenciador de Pacotes,
execute o comando a seguir na raiz do projeto. Se você não estiver na raiz do projeto, insira cd
SignalRWebPack antes de inserir o comando.
consoleCopiar
npm run release

Este comando suspende o fornecimento dos ativos do lado do cliente ao executar o

aplicativo. Os ativos são colocados na pasta wwwroot.
O Webpack concluiu as seguintes tarefas:
○ Limpou os conteúdos do diretório wwwroot.
○ Converteu o TypeScript para JavaScript, um processo conhecido como transpilação.
○ Reduziu o tamanho do arquivo JavaScript gerado, um processo conhecido
como minificação.
○ Copiou os arquivos JavaScript, CSS e HTML processados do src para o diretório wwwroot.
○ Injetou os seguintes elementos no arquivo wwwroot/[Link]:
○ Uma marca <link>, que referencia o arquivo wwwroot/main.<hash>.css. Essa marca é
colocada imediatamente antes do fim da marca </head>.
○ Uma marca <script>, que referencia o arquivo minificado wwwroot/main.<hash>.js. Essa
marca é colocada imediatamente antes do fim da marca </body>.
2. Selecione Debug > Iniciar sem depuração para iniciar o aplicativo em um navegador sem
anexar o depurador. O arquivo wwwroot/[Link] é fornecido

Página 16 de SignalR para [Link] Core

 anexar o depurador. O arquivo wwwroot/[Link] é fornecido
em [Link]
3. Abra outra instância do navegador (qualquer navegador). Cole a URL na barra de endereços.
4. Escolha qualquer navegador, digite algo na caixa de texto Mensagem e clique no
botão Enviar. O nome de usuário exclusivo e a mensagem são exibidas em ambas as páginas
instantaneamente.

Recursos adicionais
• Cliente JavaScript do Signalr [Link] Core
• Usando os hubs de SignalR do [Link] Core

De <[Link]
&tabs=visual-studio>

Página 17 de SignalR para [Link] Core

 Usar os hubs no SignalR do [Link] Core

• 19/11/2018
• 6 minutos para ler

Por Rachel Appel e Kevin Griffin

Exibir ou baixar o código de exemplo (como fazer o download)

O que é um hub SignalR

A API de Hubs de SignalR permite chamar métodos em clientes conectados do servidor. No código
do servidor, você define métodos que são chamados pelo cliente. O código do cliente, você define
métodos que são chamados do servidor. SignalR cuida de tudo o que nos bastidores que possibilita a
comunicação de servidor para cliente e servidor-cliente em tempo real.

Configurar os hubs de SignalR

O middleware SignalR requer alguns serviços, que são configurados por meio da
chamada [Link].

C#Copiar
[Link]();
Ao adicionar a funcionalidade do SignalR para um aplicativo [Link] Core, configurar as rotas do
SignalR chamando [Link] [Link] método.

C#Copiar
[Link](route =>
{
[Link]<ChatHub>("/chathub");
});

Criar e usar os hubs

Criar um hub, declarando uma classe que herda de Hube adicione os métodos públicos a ele. Os
clientes poderão chamar métodos que são definidos como public.

C#Copiar
public class ChatHub : Hub
{
public Task SendMessage(string user, string message)
{
return [Link]("ReceiveMessage", user, message);
}
}
Você pode especificar um tipo de retorno e parâmetros, incluindo tipos complexos e matrizes, como
você faria em qualquer método em c#. O SignalR lida com a serialização e desserialização de objetos
complexos e matrizes em seus valores de retorno e parâmetros.
Observação

Página 18 de SignalR para [Link] Core

Observação
Os hubs são transitórios:
• Não armazene o estado em uma propriedade na classe hub. Cada chamada de método de hub
é executada em uma nova instância de hub.
• Use await ao chamar métodos assíncronos que dependem do hub de permanecer ativo. Por
exemplo, um método, como [Link](...) pode falhar se ele for chamado
sem await e o método de hub seja concluída antes de SendAsync for concluída.

O objeto de contexto
O Hub classe tem um Context propriedade que contém as propriedades a seguir com informações
sobre a conexão:
Proprieda Descrição
de
ConnectionId Obtém a ID exclusiva para a conexão, atribuído pelo SignalR. Há uma ID de conexão
UserIdentifie para
Obtém cada conexão. de usuário. Por padrão, o SignalR usa
o identificador
r
o [Link] do ClaimsPrincipal associado com a conexão como o identificador
User de usuário.
Obtém o ClaimsPrincipal associado ao usuário atual.
Items Obtém uma coleção de chave/valor que pode ser usada para compartilhar dados
dentro do escopo dessa conexão. Dados podem ser armazenados nessa coleção e ela
será mantida para a conexão entre as invocações de método de hub diferentes.
Features Obtém a coleção de recursos disponíveis sobre a conexão. Por enquanto, essa coleção
não é necessária na maioria dos cenários, portanto, ele ainda não está documentado
ConnectionA em detalhes.
Obtém um CancellationToken que notifica quando a conexão será anulada.
borted
[Link] também contém os seguintes métodos:
Método Descrição
GetHttpCon Retorna o HttpContext para a conexão, ou null se a conexão não está associado uma
text
solicitação HTTP. Para conexões HTTP, você pode usar esse método para obter
informações como cadeias de caracteres de consulta e cabeçalhos HTTP.
Abort Anula a conexão.

O objeto de clientes
O Hub classe tem um Clients propriedade que contém as seguintes propriedades para a comunicação
entre cliente e servidor:
Propriedad Descrição
e
All Chama um método em todos os clientes conectados
Caller Chama um método no cliente que invocou o método de hub
Others Chama um método em todos os clientes conectados, exceto o cliente que invocou o
método
[Link] também contém os seguintes métodos:
Método Descrição
AllExcept Chama um método em todos os clientes conectados, exceto para as conexões
Client especificadas
Chama um método em um cliente conectado específico
Clients Chama um método em clientes conectados específicos
Group Chama um método em todas as conexões no grupo especificado
GroupExcept Chama um método em todas as conexões do grupo especificado, exceto as conexões
Groups especificadas
Chama um método em vários grupos de conexões

Página 19 de SignalR para [Link] Core

Groups Chama um método em vários grupos de conexões
OthersInGrou Chama um método em um grupo de conexões, excluindo o cliente que invocou o
p
User método de método
Chama um hub em todas as conexões associadas a um usuário específico
Users Chama um método em todas as conexões associadas com os usuários especificados
Cada propriedade ou método nas tabelas anteriores retorna um objeto com
um SendAsync método. O SendAsync método permite que você forneça o nome e parâmetros do
método de cliente para chamar.

Enviar mensagens para os clientes

Para fazer chamadas para clientes específicos, use as propriedades do Clients objeto. No exemplo a
seguir, há três métodos de Hub:
• SendMessage envia uma mensagem para todos os clientes conectados usando [Link].
• SendMessageToCaller envia uma mensagem de volta para o chamador usando [Link].
• SendMessageToGroups envia uma mensagem a todos os clientes a SignalR Users grupo.

C#Copiar
public Task SendMessage(string user, string message)
{
return [Link]("ReceiveMessage", user, message);
}
public Task SendMessageToCaller(string message)
{
return [Link]("ReceiveMessage", message);
}
public Task SendMessageToGroup(string message)
{
return [Link]("SignalR Users").SendAsync("ReceiveMessage", message);
}

Hubs com rigidez de tipos

Uma desvantagem de usar SendAsync é que ele se baseia em uma cadeia de caracteres mágica para
especificar o método de cliente a ser chamado. Isso deixa o código aberto para erros de tempo de
execução se o nome do método está incorreto ou ausente do cliente.
Uma alternativa ao uso SendAsync é tipar fortemente os Hub com Hub<T>. No exemplo a seguir,
o ChatHub métodos de cliente foram extraídos por em uma interface chamada IChatClient.

C#Copiar
public interface IChatClient
{
Task ReceiveMessage(string user, string message);
Task ReceiveMessage(string message);
}
Essa interface pode ser usada para refatorar anterior ChatHub exemplo.

C#Copiar
public class StronglyTypedChatHub : Hub<IChatClient>
{
public async Task SendMessage(string user, string message)
{
await [Link](user, message);
}
public Task SendMessageToCaller(string message)
{
return [Link](message);
}

Página 20 de SignalR para [Link] Core

 }
}
Usando Hub<IChatClient> habilita a verificação de tempo de compilação dos métodos do cliente. Isso
evita problemas causados pelo uso de cadeias de caracteres mágicas desde Hub<T> só pode fornecer
acesso aos métodos definidos na interface.
Usando fortemente tipado Hub<T> desabilita a capacidade de usar SendAsync. Todos os métodos
definidos na interface ainda podem ser definidos como assíncronos. Na verdade, cada um desses
métodos deve retornar um Task. Uma vez que ele é uma interface, não use o async palavra-
chave. Por exemplo:

C#Copiar
public interface IClient
{
Task ClientMethod();
}
Observação
O Async sufixo não é removido do nome do método. A menos que o método de cliente é definido
com .on('MyMethodAsync'), você não deve usar MyMethodAsync como um nome.

Alterar o nome de um método de hub

Por padrão, um nome de método de hub do servidor é o nome do método do .NET. No entanto,
você pode usar o HubMethodNameatributo para alterar esse padrão e especificar manualmente um
nome para o método. O cliente deve usar esse nome, em vez do nome de método do .NET, ao
chamar o método.

C#Copiar

[HubMethodName("SendMessageToUser")]
public Task DirectMessage(string user, string message)
{
return [Link](user).SendAsync("ReceiveMessage", message);
}

Manipular eventos para uma conexão

A API de Hubs de SignalR fornece o OnConnectedAsync e OnDisconnectedAsync métodos virtuais para
gerenciar e controlar conexõ[Link] o OnConnectedAsync método virtual para executar ações
quando um cliente se conecta ao Hub, como adicioná-lo a um grupo.

C#Copiar
public override async Task OnConnectedAsync()
{
await [Link]([Link], "SignalR Users");
await [Link]();
}
Substituir o OnDisconnectedAsync método virtual para executar ações quando um cliente se
desconecta. Se o cliente se desconecta intencionalmente (chamando [Link](), por exemplo),
o exception parâmetro será null. No entanto, se o cliente for desconectado devido a um erro (como
uma falha de rede), o exception parâmetro conterá uma exceção que descreve a falha.

C#Copiar
public override async Task OnDisconnectedAsync(Exception exception)
{
await [Link]([Link], "SignalR Users");
await [Link](exception);
}

Página 21 de SignalR para [Link] Core

Tratar erros
As exceções geradas em seus métodos de hub são enviadas ao cliente que invocou o método. No
cliente JavaScript, o invokemétodo retorna um promessa JavaScript. Quando o cliente recebe um
erro com um manipulador anexado à promessa usando catch, ele tem chamado e passado como um
JavaScript Error objeto.

JavaScriptCopiar
[Link]("SendMessage", user, message).catch(err => [Link](err));
Se o seu Hub de lançar uma exceção, as conexões não estão fechadas. Por padrão, o SignalR retorna
uma mensagem de erro genérica para o cliente. Por exemplo:

Copiar
[Link]: An unexpected error occurred invoking 'MethodName' on the
server.
Exceções inesperadas geralmente contêm informações confidenciais, como o nome de um servidor
de banco de dados em uma exceção acionada quando a conexão de banco de dados falha. O SignalR
não expõe estas mensagens de erro detalhadas por padrão como medida de segurança. Consulte
a artigo de considerações de segurança para obter mais informações sobre por que os detalhes da
exceção são suprimidos.
Se você tiver um excepcional de condição você fazer deseja propagar para o cliente, você pode usar
o HubException classe. Se você lançar uma HubException de seu método de hub do SignalR será enviar
a mensagem inteira para o cliente, sem modificações.

C#Copiar

public Task ThrowException()

{
throw new HubException("This error will be sent to the client!");
}
Observação
O SignalR envia apenas o Message propriedade da exceção para o cliente. O rastreamento de pilha e
outras propriedades na exceção não estão disponíveis para o cliente.

Recursos relacionados
• Introdução ao SignalR do [Link] Core
• Cliente JavaScript
• Publicar no Azure

De <[Link]

Página 22 de SignalR para [Link] Core

 Enviar mensagens de fora de um hub

• 31/10/2018
• 2 minutos para ler

Por Mikael Mengistu

O hub do SignalR é a abstração central para enviar mensagens para os clientes conectados ao
servidor SignalR. Também é possível enviar mensagens de outros lugares no seu aplicativo usando
o IHubContext service. Este artigo explica como acessar um SignalR IHubContext para enviar
notificações para clientes externos um hub.
Exibir ou baixar o código de exemplo (como fazer o download)

Obtenha uma instância de IHubContext

No SignalR do [Link] Core, você pode acessar uma instância de IHubContext por meio da injeção de
dependência. Você pode injetar uma instância do IHubContext em um controlador, middleware ou
outro serviço de injeção de dependência. Use a instância para enviar mensagens para os clientes.
Observação
Isso é diferente do [Link] 4.x SignalR que usado GlobalHost para fornecer acesso ao IHubContext. O
[Link] Core tem uma estrutura de injeção de dependência que remove a necessidade de neste
singleton global.

Injetar uma instância do IHubContext em um controlador

Você pode injetar uma instância do IHubContext em um controlador, adicionando-o para seu
construtor:

C#Copiar
public class HomeController : Controller
{
private readonly IHubContext<NotificationHub> _hubContext;
public HomeController(IHubContext<NotificationHub> hubContext)
{
_hubContext = hubContext;
}
}
Agora, com acesso a uma instância de IHubContext, você pode chamar métodos de hub, como se
estivessem no próprio hub.

C#Copiar
public async Task<IActionResult> Index()
{
await _hubContext.[Link]("Notify", $"Home page loaded at: {[Link]}");
return View();
}

Obtenha uma instância de IHubContext no middleware

Acesso a IHubContext dentro do pipeline de middleware da seguinte forma:

Página 23 de SignalR para [Link] Core

C#Copiar
[Link](async (context, next) =>
{
var hubContext = [Link]
.GetRequiredService<IHubContext<MyHub>>();
//...
});
Observação
Quando os métodos de hub são chamados de fora do Hub de classe, não há nenhum chamador
associado com a invocaçã[Link], não há nenhum acesso para o ConnectionId, Caller,
e Others propriedades.

Injetar um HubContext fortemente tipados

Para injetar um HubContext fortemente tipadas, certifique-se de seu Hub herda de Hub<T>. Injetá-lo
usando o IHubContext<THub, T>interface em vez de IHubContext<THub>.

C#Copiar
public class ChatController : Controller
{
public IHubContext<ChatHub, IChatClient> _strongChatHubContext { get; }
public ChatController(IHubContext<ChatHub, IChatClient> chatHubContext)
{
_strongChatHubContext = chatHubContext;
}
public async Task SendMessage(string message)
{
await _strongChatHubContext.[Link](message);
}
}

Recursos relacionados
• Introdução
• Hubs
• Publicar no Azure

De <[Link]

Página 24 de SignalR para [Link] Core

 Gerenciar usuários e grupos no SignalR

• 03/06/2018
• 2 minutos para ler

Por Brennan Conroy

O SignalR permite que mensagens sejam enviadas para todas as conexões associadas a um usuário
específico, bem como grupos de conexões nomeados.
Exibir ou baixar o código de exemplo (como fazer o download)

Usuários no SignalR
O SignalR permite enviar mensagens para todas as conexões associadas a um usuário específico. Por
padrão, o SignalR usa o [Link] do ClaimsPrincipal associado com a conexão como o
identificador de usuário. Um único usuário pode ter várias conexões a um aplicativo do SignalR. Por
exemplo, um usuário pode ser conectado em sua área de trabalho, bem como seu telefone. Cada
dispositivo tem uma conexão SignalR separado, mas eles são todos associados ao mesmo usuário. Se
uma mensagem é enviada para o usuário, todas as conexões associadas ao usuário recebem a
mensagem. O identificador de usuário para uma conexão pode ser acessado
pelo [Link] propriedade em seu hub.
Enviar uma mensagem para um usuário específico, passando o identificador de usuário para
o User funcionar no seu método de hub, conforme mostrado no exemplo a seguir:
Observação
O identificador de usuário diferencia maiusculas de minúsculas.

C#Copiar
public Task SendPrivateMessage(string user, string message)
{
return [Link](user).SendAsync("ReceiveMessage", message);
}

Grupos no SignalR
Um grupo é uma coleção de conexões associado com um nome. As mensagens podem ser enviadas
para todas as conexões em um grupo. Grupos são a maneira recomendada para enviar para uma
conexão ou várias conexões, porque os grupos são gerenciados pelo aplicativo. Uma conexão pode
ser um membro de vários grupos. Isso torna grupos ideal para algo como um aplicativo de bate-
papo, onde cada sala pode ser representada como um grupo. Conexões podem ser adicionadas ou
removidas de grupos por meio de AddToGroupAsync e RemoveFromGroupAsync métodos.

C#Copiar
public async Task AddToGroup(string groupName)
{
await [Link]([Link], groupName);
await [Link](groupName).SendAsync("Send", $"{[Link]} has joined the group
{groupName}.");
}
public async Task RemoveFromGroup(string groupName)
{
await [Link]([Link], groupName);
await [Link](groupName).SendAsync("Send", $"{[Link]} has left the group

Página 25 de SignalR para [Link] Core

await [Link](groupName).SendAsync("Send", $"{[Link]} has left the group
{groupName}.");
}
Associação de grupo não é preservada quando uma conexão se reconecta. A conexão precisa
ingressar novamente o grupo quando é restabelecida. Não é possível contar os membros de um
grupo, uma vez que essas informações não estarão disponíveis se o aplicativo é dimensionado para
vários servidores.
Para proteger o acesso a recursos durante o uso de grupos, use autenticação e
autorização funcionalidade no [Link] Core. Se você adicionar apenas os usuários a um grupo
quando as credenciais são válidas para esse grupo, as mensagens enviadas a esse grupo só irá para
os usuários autorizados. No entanto, os grupos não são um recurso de segurança. Declarações de
autenticação têm recursos que grupos não fizer isso, como a expiração e a revogação. Se a
permissão do usuário para acessar o grupo for revogada, você precisa detectar que e removê-las
manualmente.
Observação
Nomes de grupo diferenciam maiusculas de minúsculas.

Recursos relacionados
• Introdução
• Hubs
• Publicar no Azure

De <[Link]

Página 26 de SignalR para [Link] Core

 Considerações de design de API do SignalR

• 05/11/2018
• 2 minutos para ler

Por Andrew Stanton-Nurse

Este artigo fornece diretrizes para a criação de APIs baseadas no SignalR.

Usar parâmetros de objeto personalizado para garantir a

compatibilidade com versões anteriores
Adicionar parâmetros a um método de hub do SignalR (no cliente ou servidor) é um alteração
significativa. Isso significa que os clientes/servidores mais antigos receberá erros ao tentar invocar o
método sem o número apropriado de parâmetros. No entanto, é a adição de propriedades para um
parâmetro de objeto personalizado não uma alteração significativa. Isso pode ser usado para
projetar APIs compatíveis que são resistentes a alterações no cliente ou servidor.
Por exemplo, considere uma API de servidor semelhante ao seguinte:

C#Copiar
public async Task<string> GetTotalLength(string param1)
{
return [Link];
}
O cliente JavaScript chama esse método usando invoke da seguinte maneira:

TypeScriptCopiar
[Link]("GetTotalLength", "value1");
Se você adicionar posteriormente um segundo parâmetro para o método de servidor, os clientes
mais antigos não fornecerá esse valor de parâmetro. Por exemplo:

C#Copiar
public async Task<string> GetTotalLength(string param1, string param2)
{
return [Link] + [Link];
}
Quando o cliente antigo tenta invocar esse método, ele receberá um erro como este:

Copiar
[Link]: Failed to invoke 'GetTotalLength' due to an error on the server.
No servidor, você verá uma mensagem de log como esta:

Copiar
[Link]: Invocation provides 1 argument(s) but target expects 2.
O cliente antigo enviados apenas um parâmetro, mas a API mais recente do servidor necessários
dois parâmetros. O uso de objetos personalizados como parâmetros oferece mais
flexibilidade. Vamos recriar a API original para usar um objeto personalizado:

C#Copiar
public class TotalLengthRequest
{
public string Param1 { get; set; }
}
public async Task GetTotalLength(TotalLengthRequest req)

Página 27 de SignalR para [Link] Core

public async Task GetTotalLength(TotalLengthRequest req)
{
return [Link];
}
Agora, o cliente usa um objeto para chamar o método:

TypeScriptCopiar
[Link]("GetTotalLength", { param1: "value1" });
Em vez de adicionar um parâmetro, adicione uma propriedade para o TotalLengthRequest objeto:

C#Copiar

public class TotalLengthRequest

{
public string Param1 { get; set; }
public string Param2 { get; set; }
}
public async Task GetTotalLength(TotalLengthRequest req)
{
var length = [Link];
if (req.Param2 != null)
{
length += [Link];
}
return length;
}
Quando o cliente antigo envia um único parâmetro, o extra Param2 propriedade será
deixada null. Você pode detectar uma mensagem enviada por um cliente mais antigo, verificando
o Param2 para null e aplicar um valor padrão. Um novo cliente pode enviar os dois parâmetros.

TypeScriptCopiar
[Link]("GetTotalLength", { param1: "value1", param2: "value2" });
A mesma técnica funciona para métodos definidos no cliente. Você pode enviar um objeto
personalizado do lado do servidor:

C#Copiar
public async Task Broadcast(string message)
{
await [Link]("ReceiveMessage", new
{
Message = message
});
}
No lado do cliente, você acessa o Message propriedade em vez de usar um parâmetro:

TypeScriptCopiar
[Link]("ReceiveMessage", (req) => {
appendMessageToChatWindow([Link]);
});
Se você decidir posteriormente adicionar o remetente da mensagem à carga, adicione uma
propriedade no objeto:

C#Copiar

public async Task Broadcast(string message)

{
await [Link]("ReceiveMessage", new
{
Sender = [Link],
Message = message
});
}

Página 28 de SignalR para [Link] Core

}
Os clientes mais antigos não esperando o Sender de valor, portanto eles vai ignorá-lo. Um novo
cliente pode aceitá-lo com a atualização para a nova propriedade de leitura:

TypeScriptCopiar

[Link]("ReceiveMessage", (req) => {

let message = [Link];
if ([Link]) {
message = [Link] + ": " + message;
}
appendMessageToChatWindow(message);
});
Nesse caso, o novo cliente também é tolerante a falhas de um servidor antigo que não fornece
o Sender valor. Uma vez que o servidor antigo não fornecerá a Sender valor, o cliente verifica para ver
se ele existe antes de acessá-lo.

De <[Link]

Página 29 de SignalR para [Link] Core

 Cliente de .NET do SignalR do [Link] Core

• 16/04/2019
• 6 minutos para ler

A biblioteca de cliente .NET de SignalR do [Link] Core permite que você se comunicar com os hubs
de SignalR em aplicativos .NET.
Exibir ou baixar código de exemplo (como baixar)
O exemplo de código neste artigo é um aplicativo do WPF que usa o cliente .NET de SignalR do
[Link] Core.

Instalar o pacote de cliente .NET do SignalR

O [Link] pacote é necessário para clientes .NET conectar-se aos hubs de
SignalR. Para instalar a biblioteca de cliente, execute o seguinte comando na Package Manager
Console janela:

PowerShellCopiar
Install-Package [Link]

Conectar a um hub
Para estabelecer uma conexão, cria uma HubConnectionBuilder e chamar Build. A URL do hub,
protocolo, o tipo de transporte, nível de log, cabeçalhos e outras opções podem ser configuradas
durante a criação de uma conexão. Configurar as opções necessárias, inserindo qualquer um
dos HubConnectionBuilder métodos em Build. Iniciar a conexão com StartAsync.

C#Copiar

using System;
using [Link];
using [Link];
using [Link];
namespace SignalRChatClient
{
public partial class MainWindow : Window
{
HubConnection connection;
public MainWindow()
{
InitializeComponent();
connection = new HubConnectionBuilder()
.WithUrl("[Link]
.Build();
[Link] += async (error) =>
{
await [Link](new Random().Next(0,5) * 1000);
await [Link]();
};
}
private async void connectButton_Click(object sender, RoutedEventArgs e)
{

Página 30 de SignalR para [Link] Core

 {
[Link]<string, string>("ReceiveMessage", (user, message) =>
{
[Link](() =>
{
var newMessage = $"{user}: {message}";
[Link](newMessage);
});
});
try
{
await [Link]();
[Link]("Connection started");
[Link] = false;
[Link] = true;
}
catch (Exception ex)
{
[Link]([Link]);
}
}
private async void sendButton_Click(object sender, RoutedEventArgs e)
{
try
{
await [Link]("SendMessage",
[Link], [Link]);
}
catch (Exception ex)
{
[Link]([Link]);
}
}
}
}

Lidar com a conexão perdida

Reconectar manualmente
Aviso
Antes do 3.0, o cliente .NET para o SignalR não reconectados automaticamente. Você deve escrever
código que será reconectada seu cliente manualmente.
Use o Closed eventos para responder a uma conexão perdida. Por exemplo, você talvez queira
automatizar a reconexão.
O Closed evento requer um delegado que retorna um Task, que permite que o código assíncrono
executar sem usar async [Link] satisfazer a assinatura do delegado em um Closed manipulador de
eventos que é executado de forma síncrona, retorna [Link]:

C#Copiar
[Link] += (error) => {
// Do your close logic.
return [Link];
};
O principal motivo para o suporte assíncrono é portanto, você pode reiniciar a conexão. Iniciar uma
conexão é uma ação assíncrona.
Em um Closed manipulador que reinicia a conexão, considere aguardar algum atraso aleatório evitar
sobrecarregar o servidor, conforme mostrado no exemplo a seguir:

Página 31 de SignalR para [Link] Core

C#Copiar
[Link] += async (error) =>
{
await [Link](new Random().Next(0,5) * 1000);
await [Link]();
};

Chamar métodos de hub do cliente

InvokeAsync chama métodos no hub. Passe o nome do método de hub e quaisquer argumentos
definidos no método de hub para InvokeAsync. O SignalR é assíncrono, portanto, use async e await ao
fazer as chamadas.

C#Copiar
await [Link]("SendMessage",
[Link], [Link]);
O InvokeAsync método retorna um Task que conclui quando o método de servidor é retornado. O
valor de retorno, se houver, é fornecido como o resultado do Task. Todas as exceções geradas pelo
método no servidor de produzem uma falha Task. Use awaitsintaxe de espera para o método de
servidor concluir e try...catch sintaxe para lidar com erros.
O SendAsync método retorna um Task que conclui quando a mensagem foi enviada ao
servidor. Nenhum valor de retorno é fornecido uma vez que isso Task não espera até que o método
de servidor seja concluída. Todas as exceções geradas no cliente ao enviar a mensagem de
produzem uma falha Task. Use await e try...catch enviar de sintaxe para lidar com erros.
Observação
Se você estiver usando o serviço do Azure SignalR no modo sem servidor, você não pode chamar
métodos de hub de um [Link] obter mais informações, consulte o documentação do SignalR
Service.

Chamar métodos de cliente do hub

Definir métodos de hub de chamadas usando [Link] depois de criar, mas antes de iniciar a
conexão.

C#Copiar
[Link]<string, string>("ReceiveMessage", (user, message) =>
{
[Link](() =>
{
var newMessage = $"{user}: {message}";
[Link](newMessage);
});
});
O código anterior no [Link] é executado quando o código do lado do servidor chama-o
usando o SendAsync método.

C#Copiar
public async Task SendMessage(string user, string message)
{
await [Link]("ReceiveMessage", user,message);
}

Registro em log e tratamento de erros

Tratar erros com uma instrução try-catch. Inspecione o Exception objeto para determinar a ação
apropriada a tomar depois de ocorrer um erro.

Página 32 de SignalR para [Link] Core

apropriada a tomar depois de ocorrer um erro.

C#Copiar
try
{
await [Link]("SendMessage",
[Link], [Link]);
}
catch (Exception ex)
{
[Link]([Link]);
}

Recursos adicionais
• Hubs
• Cliente JavaScript
• Publicar no Azure
• Documentação de sem servidor SignalR Service do Azure

De <[Link]

Página 33 de SignalR para [Link] Core

[Link] Namespace

Classes
HttpConnectionFactory A factory for creating HttpConnection instances.
HubConnection A connection used to invoke hub methods on a SignalR
HubConnectionBuilder Server.
A builder for configuring HubConnection instances.
HubConnectionBuilderExtensions Extension methods for IHubConnectionBuilder.
HubConnectionBuilderHttpExtension Extension methods for IHubConnectionBuilder.
sHubConnectionExtensions Extension methods for HubConnectionExtensions.

Interfaces
IConnectionFactory A factory abstraction for creating connections to a SignalR server.
IHubConnectionBuilder A builder abstraction for configuring HubConnection instances.

Enums
HubConnectionState Describes the current state of the HubConnection to the server.

De <[Link]

Página 34 de SignalR para [Link] Core

 Cliente de Java do SignalR Core [Link]

• 26/06/2019
• 2 minutos para ler

Por Mikael Mengistu

O cliente de Java permite se conectar a um servidor do SignalR do [Link] Core do código Java,
incluindo aplicativos [Link] o cliente JavaScript e o cliente .NET, o cliente de Java permite
que você receber e enviar mensagens a um hub em tempo real.O cliente de Java está disponível no
[Link] Core 2.2 e posterior.
O aplicativo de console do Java de exemplo referenciado neste artigo usa o cliente de Java do
SignalR.
Exibir ou baixar código de exemplo (como baixar)

Instalar o pacote de cliente Java do SignalR

O 1.0.0 signalr arquivo JAR permite que os clientes se conectem aos hubs de SignalR. Para localizar o
número de versão de arquivo JAR mais recente, consulte o resultados da pesquisa Maven.
Se usando o Gradle, adicione a seguinte linha para o dependencies seção do seu Build.
gradle arquivo:

gradleCopiar
implementation '[Link]:signalr:1.0.0'
Se usando o Maven, adicione as seguintes linhas dentro de <dependencies> elemento da sua POM.
XML arquivo:

XMLCopiar
<dependency>
<groupId>[Link]</groupId>
<artifactId>signalr</artifactId>
<version>1.0.0</version>
</dependency>

Conectar a um hub
Para estabelecer uma HubConnection, o HubConnectionBuilder deve ser usado. O nível de log e a URL
do hub pode ser configurado durante a criação de uma conexão. Configurar as opções necessárias
chamando o HubConnectionBuilder métodos antes [Link] a conexão com start.

JavaCopiar
HubConnection hubConnection = [Link](input)
.build();

Chamar métodos de hub do cliente

Uma chamada para send invoca um método de hub. Passe o nome do método de hub e quaisquer
argumentos definidos no método de hub para send.

JavaCopiar
[Link]("Send", input);

Página 35 de SignalR para [Link] Core

[Link]("Send", input);
Observação
Se você estiver usando o serviço do Azure SignalR no modo sem servidor, você não pode chamar
métodos de hub de um [Link] obter mais informações, consulte o documentação do SignalR
Service.

Chamar métodos de cliente do hub

Use [Link] para definir métodos no cliente que o hub pode chamar. Defina os métodos
depois de criar, mas antes de iniciar a conexão.

JavaCopiar
[Link]("Send", (message) -> {
[Link]("New Message: " + message);
}, [Link]);

Adicionar registro em log

O cliente SignalR Java usa a SLF4J biblioteca para registro em log. É uma API de alto nível de log que
permite aos usuários da biblioteca de escolher sua própria implementação de log específico,
colocando em uma dependência de log específico. O trecho de código a seguir mostra como
usar [Link] com o cliente de Java do SignalR.

gradleCopiar
implementation 'org.slf4j:slf4j-jdk14:1.7.25'
Se você não configurar o registro em log em suas dependências, SLF4J carrega um agente de
operação não padrão com a seguinte mensagem de aviso:

Copiar
SLF4J: Failed to load class "[Link]".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See [Link] for further details.
Isso pode ser ignorado.

Notas de desenvolvimento do Android

Com relação à compatibilidade do SDK do Android para os recursos de cliente do SignalR, considere
os seguintes itens ao especificar sua versão do SDK do Android de destino:
• O cliente de Java do SignalR será executado no nível da API Android 16 e versões posteriores.
• Conectar-se por meio do serviço Azure SignalR exigirá o nível da API Android 20 e posterior
porque a serviço do Azure SignalRrequer o TLS 1.2 e não dá suporte a conjuntos de codificação
baseado em SHA-1. Android adicionou suporte para SHA-256 (e superior) conjuntos de
codificação no nível da API 20.

Configurar a autenticação de token de portador

No cliente de Java do SignalR, você pode configurar um token de portador para usar para
autenticação, fornecendo uma "access token fábrica" para
o HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer uma RxJava único<cadeia
de caracteres >. Com uma chamada para [Link], você pode escrever a lógica para gerar tokens
de acesso do cliente.

JavaCopiar
HubConnection hubConnection = [Link]("YOUR HUB URL HERE")
.withAccessTokenProvider([Link](() -> {

Página 36 de SignalR para [Link] Core

 .withAccessTokenProvider([Link](() -> {
// Your logic here.
return [Link]("An Access Token");
})).build();

Limitações conhecidas
• Há suporte para apenas o protocolo JSON.
• Há suporte para apenas o transporte de WebSockets.
• Streaming ainda não tem suporte.

Recursos adicionais
• Referência de API Java
• Usando os hubs de SignalR do [Link] Core
• Cliente JavaScript do Signalr [Link] Core
• Publicar um [Link] Core SignalR aplicativo no serviço de aplicativo do Azure
• Documentação de sem servidor SignalR Service do Azure

Comentários
De <[Link]

Página 37 de SignalR para [Link] Core

[Link]

Edit
This package contains the classes for SignalR Java client.

Classes
HttpHubConnectionBuilder A builder for configuring HubConnection instances.
HubConnection
HubConnectionBuilder A builder for configuring HubConnection instances.
HubException An exception thrown when the server fails to invoke a Hub method.
Subscription Represents the registration of a handler for a client method.

Interfaces
Action A callback that takes no parameters.
Action1<T1> A callback that takes one parameter.
Action2<T1,T2> A callback that takes two parameters.
Action3<T1,T2,T3> A callback that takes three parameters.
Action4<T1,T2,T3,T4> A callback that takes four parameters.
Action5<T1,T2,T3,T4,T5> A callback that takes five parameter.
Action6<T1,T2,T3,T4,T5,T6> A callback that takes six parameters.
Action7<T1,T2,T3,T4,T5,T6,T7> A callback that takes seven parameters.
Action8<T1,T2,T3,T4,T5,T6,T7,T8> A callback that takes eight parameters.

Enums
HubConnectionState Indicates the state of the HubConnection.

De <[Link]
java&viewFallbackFrom=aspnetcore-2.2>

Página 38 de SignalR para [Link] Core

 Cliente JavaScript do Signalr [Link] Core

• 27/06/2019
• 8 minutos para ler

Por Rachel Appel

A biblioteca de cliente JavaScript do [Link] Core Signalr permite que os desenvolvedores chamem
o código do Hub do lado do servidor.
Exibir ou baixar código de exemplo (como baixar)

Instalar o pacote de cliente do Signalr

A biblioteca de cliente JavaScript do Signalr é entregue como um pacote NPM . Se você estiver
usando o Visual Studio, npm installexecute no console do Gerenciador de pacotes enquanto estiver
na pasta raiz. Para Visual Studio Code, execute o comando do terminal integrado.

consoleCopiar
npm init -y
npm install @aspnet/signalr
NPM instala o conteúdo do pacote na node_modules\@aspnet\signalr\dist\browser pasta. Crie uma
nova pasta chamada signalr na pasta wwwroot\lib . Copie o arquivo signalr. js para a pasta wwwroot
\lib\signalr .

Usar o cliente do Signalr JavaScript

Referencie o cliente de JavaScript do signalr <script> no elemento.

HTMLCopiar
<script src="~/lib/signalr/[Link]"></script>

Conectar-se a um hub
O código a seguir cria e inicia uma conexão. O nome do Hub não diferencia maiúsculas de
minúsculas.

JavaScriptCopiar
const connection = new [Link]()
.withUrl("/chatHub")
.configureLogging([Link])
.build();
[Link]().then(function () {
[Link]("connected");
});

Conexões entre origens

Normalmente, os navegadores carregam conexões do mesmo domínio que a página solicitada. No
entanto, há ocasiões em que uma conexão com outro domínio é necessária.
Para impedir que um site mal-intencionado leia dados confidenciais de outro site, as conexões entre

Página 39 de SignalR para [Link] Core

Para impedir que um site mal-intencionado leia dados confidenciais de outro site, as conexões entre
origens são desabilitadas por padrão. Para permitir uma solicitação entre origens, habilite-
a Startup na classe.

C#Copiar

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
namespace SignalRChat
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public void ConfigureServices(IServiceCollection services)
{
[Link]<CookiePolicyOptions>(options =>
{
[Link] = context => true;
[Link] = [Link];
});
[Link]();
[Link](options => [Link]("CorsPolicy",
builder =>
{
[Link]().AllowAnyHeader()
.WithOrigins("[Link]
.AllowCredentials();
}));
[Link]();
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if ([Link]())
{
[Link]();
[Link]();
}
else
{
[Link]("/Error");
[Link]();
}
[Link]();
[Link]();
[Link]();
[Link]("CorsPolicy");
[Link](routes =>
{
[Link]<ChatHub>("/chathub");
});
[Link]();
}
}
}

Página 40 de SignalR para [Link] Core

Métodos do hub de chamadas do cliente
Os clientes JavaScript chamam métodos públicos em hubs por meio do
método Invoke de HubConnection. O invoke método aceita dois argumentos:
• O nome do método de Hub. No exemplo a seguir, o nome do método no Hub é SendMessage.
• Quaisquer argumentos definidos no método Hub. No exemplo a seguir, o nome do
argumento messageé. O código de exemplo usa a sintaxe de função de seta que tem suporte
nas versões atuais de todos os principais navegadores, exceto o Internet Explorer.
JavaScriptCopiar
[Link]("SendMessage", user, message).catch(err => [Link]([Link]()));
Observação
Se você estiver usando o serviço de sinalizador do Azure no modo sem servidor, não será possível
chamar os métodos de Hub de um cliente. Para obter mais informações, consulte a documentação
do serviço signalr.
O invoke método retorna uma promessade JavaScript. O Promise é resolvido com o valor de retorno
(se houver) quando o método no servidor retorna. Se o método no servidor gerar um erro,
o Promise será rejeitado com a mensagem de erro. Use os thenmétodos catch e na Promise própria
para lidar com esses casos (ou await sintaxe).
O send método retorna um JavaScript Promise. O Promise é resolvido quando a mensagem é enviada
ao servidor. Se houver um erro ao enviar a mensagem, o Promise será rejeitado com a mensagem de
erro. Use os then métodos catch e na Promise própria para lidar com esses casos (ou await sintaxe).
Observação
O send uso de não aguarda até que o servidor tenha recebido a mensagem. Consequentemente, não
é possível retornar dados ou erros do servidor.

Chamar métodos de cliente do Hub

Para receber mensagens do Hub, defina um método usando o método on do HubConnection.
• O nome do método de cliente JavaScript. No exemplo a seguir, o nome do
método ReceiveMessageé.
• Argumentos que o Hub passa para o método. No exemplo a seguir, o valor do
argumento messageé.

JavaScriptCopiar
[Link]("ReceiveMessage", (user, message) => {
const encodedMsg = user + " says " + message;
const li = [Link]("li");
[Link] = encodedMsg;
[Link]("messagesList").appendChild(li);
});
O código anterior em [Link] é executado quando o código do lado do servidor o chama
usando o método SendAsync .

C#Copiar
public async Task SendMessage(string user, string message)
{
await [Link]("ReceiveMessage", user, message);
}
O signalr determina qual método de cliente deve ser chamado, correspondendo ao nome
do SendAsync método [Link] aos argumentos definidos em e.
Observação
Como prática recomendada, chame o método Start no HubConnection After on. Isso garante que seus
manipuladores sejam registrados antes que todas as mensagens sejam recebidas.

Tratamento de erros e registro em log

Página 41 de SignalR para [Link] Core
Tratamento de erros e registro em log
Encadear catch um método ao final start do método para manipular erros do lado do
cliente. Use [Link] para gerar erros de saída para o console do navegador.

JavaScriptCopiar
[Link]().catch(function (err) {
return [Link]([Link]());
});
Configure o rastreamento de log no lado do cliente passando um agente e um tipo de evento para
registrar quando a conexão é feita. As mensagens são registradas com o nível de log especificado e
superior. Os níveis de log disponíveis são os seguintes:
• [Link]– Mensagens de erro. Registra Error somente mensagens.
• [Link]– Mensagens de aviso sobre possíveis
erros. Logs Warning eError mensagens.
• [Link]– Mensagens de status sem
erros. Logs Information, Warning eError mensagens.
• [Link]– Mensagens de rastreamento. Registra tudo, incluindo dados
transportados entre o Hub e o cliente.
Use o método configureLogging no HubConnectionBuilder para configurar o nível de log. As
mensagens são registradas no console do navegador.

JavaScriptCopiar
const connection = new [Link]()
.withUrl("/chatHub")
.configureLogging([Link])
.build();

Reconectar clientes

Reconectar manualmente
Aviso
Antes de 3,0, o cliente JavaScript para Signalr não se reconecta automaticamente. Você deve
escrever um código que reconectará o cliente manualmente.
O código a seguir demonstra uma abordagem de reconexão manual típica:
1. Uma função (nesse caso, a start função) é criada para iniciar a conexão.
2. Chame a start função no manipulador de eventos onclose da conexão.

JavaScriptCopiar
async function start() {
try {
await [Link]();
[Link]("connected");
} catch (err) {
[Link](err);
setTimeout(() => start(), 5000);
}
};
[Link](async () => {
await start();
});
Uma implementação do mundo real usaria um retirada exponencial ou tentaria um número
especificado de vezes antes de desistir.

Recursos adicionais
Página 42 de SignalR para [Link] Core
Recursos adicionais
• Referência de API JavaScript
• Tutorial do JavaScript
• Tutorial do webpack e TypeScript
• Hubs
• Cliente .NET
• Publicar no Azure
• Solicitações entre origens (CORS)
• Documentação sem servidor do serviço de sinalizador do Azure

Comentários
De <[Link]

Página 43 de SignalR para [Link] Core

Navegador da API JavaScript

Bem-vindo ao Navegador da API JavaScript – uma opção completa com todas as

APIs baseadas em JavaScript da Microsoft. Comece a pesquisar por APIs JavaScript
na caixa abaixo. Se tiver algum comentário, use nosso repositório do GitHub.

De <[Link]

Página 44 de SignalR para [Link] Core

 Hospedagem do [Link] SignalR Core e
dimensionamento

• 27/11/2018
• 4 minutos para ler

Por Andrew Stanton-Nurse, Brady Gaster, e Tom Dykstra,

Este artigo explica as considerações para aplicativos de alto tráfego que usam o SignalR do [Link]
Core de dimensionamento e hospedagem.

Recursos de conexão TCP

O número de conexões TCP simultâneas que pode dar suporte a um servidor web é limitado. Os
clientes HTTP padrão usam efêmeroconexões. Essas conexões podem ser fechadas quando o cliente
fica ocioso e reabrir posteriormente. Por outro lado, uma conexão SignalR é persistente. Conexões
do SignalR permanecem aberta até mesmo quando o cliente vai ocioso. Em um aplicativo de alto
tráfego que atende a muitos clientes, essas conexões persistentes podem causar servidores atingido
o número máximo de conexões.
Conexões persistentes também consomem memória extra, para acompanhar cada conexão.
O uso intenso de recursos relacionados à conexão pelo SignalR pode afetar outros aplicativos web
hospedados no mesmo [Link] o SignalR é aberto e mantém as último conexões TCP
disponíveis, outros aplicativos web no mesmo servidor também não tem mais conexões disponíveis
para eles.
Se um servidor ficar sem conexões, você verá erros de soquete aleatória e erros de redefinição de
conexão. Por exemplo:

Copiar
An attempt was made to access a socket in a way forbidden by its access permissions...
Para evitar o uso de recursos do SignalR causando erros em outros aplicativos da web, execute o
SignalR em servidores diferentes do que seus outros aplicativos da web.
Para evitar o uso de recursos do SignalR causando erros em um aplicativo do SignalR, escala
horizontalmente para limitar o número de conexões que um servidor deve manipular.

Expansão do
Um aplicativo que usa o SignalR precisa manter o controle de todas as suas conexões, que cria
problemas para um farm de servidores. Adicionar um servidor, e ele obtém novas conexões de
outros servidores não conhecer. Por exemplo, o SignalR em cada servidor no diagrama a seguir
desconhece as conexões nos outros servidores. Quando quiser SignalR em um dos servidores enviar
uma mensagem a todos os clientes, a mensagem é apenas vai para os clientes conectados a esse
servidor.

Página 45 de SignalR para [Link] Core

As opções para resolver esse problema são as serviço do Azure SignalR e Redis backplane.

Serviço Azure SignalR

O serviço do Azure SignalR é um proxy em vez de um backplane. Cada vez que um cliente inicia uma
conexão ao servidor, o cliente é redirecionado para se conectar ao serviço. Esse processo é ilustrado
no diagrama a seguir:

O resultado é que o serviço gerencia todas as conexões de cliente, enquanto cada servidor precisa
de apenas um pequeno número constante de conexões para o serviço, conforme mostrado no
diagrama a seguir:

Essa abordagem de expansão tem várias vantagens em relação a alternativa de backplane do Redis:
• Sessões adesivas, também conhecidas como afinidade do cliente, não é necessário, pois os
clientes imediatamente são redirecionados para o serviço do Azure SignalR quando eles se
conectam.
• Um aplicativo pode escalar horizontalmente de SignalR com base no número de mensagens

Página 46 de SignalR para [Link] Core

 • Um aplicativo pode escalar horizontalmente de SignalR com base no número de mensagens
enviadas, enquanto o serviço do Azure SignalR é dimensionado automaticamente para lidar
com qualquer número de conexões. Por exemplo, pode haver milhares de clientes, mas se
apenas algumas mensagens por segundo são enviadas, o aplicativo SignalR não será
necessário escalar horizontalmente em vários servidores apenas para lidar com as conexões
em si.
• Um aplicativo de SignalR não usar significativamente mais recursos de conexão que um
aplicativo web sem SignalR.
Por esses motivos, recomendamos que o serviço do Azure SignalR para todos os aplicativos do
SignalR do [Link] Core hospedados no Azure, incluindo o serviço de aplicativo, as VMs e
contêineres.
Para obter mais informações, consulte o documentação do serviço do Azure SignalR.

Backplane de Redis
Redis é um repositório de chave-valor na memória que dá suporte a um sistema de mensagens com
um modelo de publicação/assinatura. O backplane SignalR Redis usa o recurso de
publicação/assinatura para encaminhar mensagens para outros servidores. Quando um cliente faz
uma conexão, as informações de conexão são passadas ao backplane. Quando um servidor deseja
enviar uma mensagem a todos os clientes, ele envia ao backplane. Backplane sabe clientes tudo
conectados e quais servidores que eles estão. Ele envia a mensagem a todos os clientes por meio de
seus respectivos servidores. Esse processo é ilustrado no diagrama a seguir:

O backplane do Redis é a abordagem recomendada de escalabilidade horizontal para aplicativos

hospedados em sua própria infraestrutura. Azure SignalR Service não é uma opção prática para uso
em produção com aplicativos no local devido à latência de conexão entre seu data center e um data
center do Azure.
As vantagens de serviço do Azure SignalR observadas anteriormente são as desvantagens para o
backplane do Redis:
• Sessões adesivas, também conhecidas como afinidade do cliente, é necessário. Depois que
uma conexão é iniciada em um servidor, a conexão deve permanecer nesse servidor.
• Um aplicativo de SignalR deve escalar horizontalmente com base no número de clientes,
mesmo se algumas mensagens estão sendo enviadas.
• Um aplicativo de SignalR usa significativamente mais recursos de conexão que um aplicativo
web sem SignalR.

Próximas etapas
Para obter mais informações, consulte os seguintes recursos:
• Documentação do SignalR Service do Azure
• Configurar um backplane de Redis

Página 47 de SignalR para [Link] Core

Comentários
De <[Link]

Página 48 de SignalR para [Link] Core

 Publicar um [Link] Core SignalR aplicativo no serviço de
aplicativo do Azure

• 25/06/2019
• 2 minutos para ler

Por Brady Gaster

O serviço de aplicativo do Azure é um a computação em nuvem do Microsoft plataforma de serviço
para hospedar aplicativos web, incluindo o [Link] Core.
Observação
Este artigo refere-se a publicação de um aplicativo de SignalR do [Link] Core no Visual Studio. Para
obter mais informações, consulte serviço SignalR para o Azure.

Publique o aplicativo
Este artigo aborda a publicação usando as ferramentas do Visual Studio. Os usuários do Visual Studio
Code podem usar CLI do Azurecomandos para publicar aplicativos no Azure. Para obter mais
informações, consulte publicar um aplicativo [Link] Core no Azure com ferramentas de linha de
comando.
1. Clique com o botão direito do mouse no projeto, no Gerenciador de Soluções, e
selecione Publicar.
2. Confirme serviço de aplicativo e criar novo selecionados no escolher um destino de
publicação caixa de diálogo.
3. Selecione criar perfil da publicar botão soltar para baixo.
Insira as informações descritas na tabela a seguir na criar serviço de aplicativo caixa de
diálogo e selecione criar.
Item Descrição
Nome Nome exclusivo do aplicativo.
Assinatura Assinatura do Azure que o aplicativo usa.
Grupo de recursos Grupo de recursos relacionados ao qual pertence o aplicativo.
Plano de hospedagem Plano de preços para o aplicativo web.
4. Selecione o serviço do Azure SignalR na dependências > Add lista suspensa:

5. No serviço do Azure SignalR caixa de diálogo, selecione criar uma nova instância de serviço
do Azure SignalR.
6. Fornecer um nome, grupo de recursos, e local. Volte para o serviço do Azure SignalR caixa de
diálogo e selecione Add.
Visual Studio conclui as seguintes tarefas:
• Cria um perfil de publicação que contém as configurações de publicação.
• Cria uma aplicativo Web do Azure com os detalhes fornecidos.
• Publica o aplicativo.
• Inicia um navegador, que carrega o aplicativo web.
O formato da URL do aplicativo é {APP SERVICE NAME}.[Link]. Por exemplo, um aplicativo
chamado SignalRChatApp tem uma URL de [Link]
Se um HTTP 502.2 - Gateway incorreto erro ocorre ao implantar um aplicativo que tem como alvo

Página 49 de SignalR para [Link] Core

Se um HTTP 502.2 - Gateway incorreto erro ocorre ao implantar um aplicativo que tem como alvo
uma versão do .NET Core da visualização, consulte versão de visualização de implantar o [Link]
Core no serviço de aplicativo do Azure resolvê-lo.

Configurar o aplicativo no serviço de aplicativo do Azure

Observação
Esta seção aplica-se somente para aplicativos que não usam o serviço do Azure SignalR.
Se o aplicativo usa o serviço do Azure SignalR, o serviço de aplicativo não exige a configuração de
afinidade do roteamento ARR (Application Request) e Web Sockets descritos nesta seção. Os clientes
se conectam seus soquetes da Web ao serviço Azure SignalR, não diretamente para o aplicativo.
Para aplicativos hospedados sem o serviço do Azure SignalR, habilite:
• Afinidade ARR para rotear solicitações de um usuário de volta para a mesma instância do
serviço de aplicativo. A configuração padrão é em.
• Web Sockets para permitir que o transporte de soquetes da Web para a função. A
configuração padrão é desativar.
1. No portal do Azure, navegue até o aplicativo web no serviços de aplicativos.
2. Abra Configuration > configurações gerais.
3. Definir Web sockets à em.
4. Verifique afinidade ARR é definido como em.

Limita o plano do serviço de aplicativo

Soquetes da Web e outros transportes são limitados com base no plano de serviço de aplicativo
selecionado. Para obter mais informações, consulte o serviços de nuvem do Azure limita e limites do
serviço de aplicativo seções o assinatura do Azure e limites de serviço, cotas e restrições artigo.

Recursos adicionais
• O que é o serviço do Azure SignalR?
• Introdução ao SignalR do [Link] Core
• Hospedar e implantar o [Link] Core
• Publicar um aplicativo [Link] Core no Azure com o Visual Studio
• Publicar um aplicativo [Link] Core no Azure com ferramentas de linha de comando
• Hospedar e implantar aplicativos de visualização do [Link] Core no Azure

Comentários
De <[Link]

Página 50 de SignalR para [Link] Core

 Configurar um backplane de Redis para expansão do
SignalR do [Link] Core

• 27/11/2018
• 3 minutos para ler

Por Andrew Stanton-Nurse, Brady Gaster, e Tom Dykstra,

Este artigo explica os aspectos de SignalR específicas de configuração de um Redis servidor a ser
usado para dimensionar um aplicativo do SignalR do [Link] Core.

Configurar um backplane de Redis

• Implante um servidor do Redis.
Importante
Para uso em produção, um backplane de Redis é recomendável somente quando ele é
executado no mesmo data center que o aplicativo do SignalR. Caso contrário, latência de rede
degrada o desempenho. Se seu aplicativo SignalR está em execução na nuvem do Azure, é
recomendável o serviço do Azure SignalR em vez de um backplane de Redis. Você pode usar o
serviço de Cache Redis do Azure para desenvolvimento e ambientes de teste.
Para obter mais informações, consulte os seguintes recursos:
• Hospedagem de produção do [Link] SignalR Core e dimensionamento
• Documentação do redis
• Documentação do Cache Redis do Azure
• No aplicativo do SignalR, instale um dos seguintes pacotes NuGet:
• [Link] -Depende do stackexchange. Redis 2.X.X. Este
é o pacote recomendado para o [Link] Core 2.2 e posterior.
• [Link] -Depende do 1.X.X stackexchange. Redis. Este pacote não
enviará no [Link] Core 3.0.
• No [Link] método, chame AddStackExchangeRedis depois AddSignalR:
C#Copiar
[Link]().AddStackExchangeRedis("<your_Redis_connection_string>");
• Defina as opções conforme necessário:
A maioria das opções pode ser definido na cadeia de conexão ou
nos ConfigurationOptions objeto. As opções especificadas em ConfigurationOptions substituirão
as definido na cadeia de conexão.
O exemplo a seguir mostra como definir opções no ConfigurationOptions objeto. Este exemplo
adiciona um prefixo de canal para que vários aplicativos podem compartilhar a mesma
instância do Redis, conforme explicado na etapa a seguir.
C#Copiar
[Link]()
.AddStackExchangeRedis(connectionString, options => {
[Link] = "MyApp";
});

No código anterior, [Link] é inicializada com tudo o que foi especificado na

cadeia de conexão.
Para obter informações sobre as opções do Redis, consulte o StackExchange Redis
documentação.
• Se você estiver usando um servidor de Redis para vários aplicativos do SignalR, use um prefixo
de canal diferente para cada aplicativo do SignalR.
Configurar um prefixo de canal isola a um aplicativo do SignalR de outras pessoas que usam os

Página 51 de SignalR para [Link] Core

 Configurar um prefixo de canal isola a um aplicativo do SignalR de outras pessoas que usam os
prefixos de canal diferente. Se você não atribuir prefixos diferentes, uma mensagem enviada
de um aplicativo para todos os seus próprios clientes irão para todos os clientes de todos os
aplicativos que usam o servidor Redis como um backplane.
• Configure seu servidor farm balanceamento de carga para sessões adesivas. Aqui estão alguns
exemplos de documentação sobre como fazer isso:
• IIS
• HAProxy
• Nginx
• pfSense

Erros do servidor de redis

Quando um servidor Redis fica inativo, o SignalR gera exceções que indicam as mensagens não
entregues. Algumas mensagens de exceção típico:
• Mensagem de gravação com falha
• Falha ao invocar o método de hub 'MethodName'
• Falha na Conexão ao Redis
O SignalR não armazena em buffer as mensagens para enviá-las quando o servidor de volta a
funcionar. Todas as mensagens enviadas enquanto o servidor Redis estiver inativo serão perdidas.
O SignalR se reconecta automaticamente quando o servidor Redis estiver disponível novamente.

Comportamento personalizado para falhas de conexão

Aqui está um exemplo que mostra como manipular eventos de falha de conexão do Redis.

C#Copiar
[Link]()
.AddMessagePackProtocol()
.AddStackExchangeRedis(o =>
{
[Link] = async writer =>
{
var config = new ConfigurationOptions
{
AbortOnConnectFail = false
};
[Link]([Link], 0);
[Link]();
var connection = await [Link](config, writer);
[Link] += (_, e) =>
{
[Link]("Connection to Redis failed.");
};
if (![Link])
{
[Link]("Did not connect to Redis.");
}
return connection;
};
});

Clustering do redis
Clustering de redis é um método para alcançar alta disponibilidade por meio de vários servidores do
Redis. Clustering não é oficialmente suportado, mas pode funcionar.

Página 52 de SignalR para [Link] Core

Próximas etapas
Para obter mais informações, consulte os seguintes recursos:
• Hospedagem de produção do [Link] SignalR Core e dimensionamento
• Documentação do redis
• Documentação do StackExchange Redis
• Documentação do Cache Redis do Azure

Comentários
De <[Link]

Página 53 de SignalR para [Link] Core

 Host SignalR do [Link] Core em serviços em segundo
plano

• 03/02/2019
• 2 minutos para ler

Por Brady Gaster

Este artigo fornece orientações para:
• Hospedagem de Hubs de SignalR usando um processo de trabalho em segundo plano
hospedado com o [Link] Core.
• Enviando mensagens para clientes de dentro de um núcleo do .NET de
conectados BackgroundService.
Exibir ou baixar o código de exemplo (como fazer o download)

Conectar o SignalR durante a inicialização

Os Hubs de SignalR do [Link] Core no contexto de um processo de trabalho em segundo plano de
hospedagem é idêntico à hospedagem de um Hub em um aplicativo web [Link]
Core. No [Link] chamar um método, [Link] adiciona os serviços
necessários para a camada de injeção de dependência de núcleo do [Link] (DI) para dar suporte
ao SignalR. Na [Link], o UseSignalR método é chamado para ligar os pontos de
extremidade de Hub no pipeline de solicitação do [Link] Core.

C#Copiar
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
[Link]();
[Link]<Worker>();
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if ([Link]())
{
[Link]();
}
[Link]((routes) =>
{
[Link]<ClockHub>("/hubs/clock");
});
}
}
No exemplo anterior, o ClockHub classe implementa o Hub<T> classe para criar um Hub com rigidez
de tipos. O ClockHub tiver sido configurado na Startup classe responder às solicitações no ponto de
extremidade /hubs/clock.
Para obter mais informações sobre os Hubs com rigidez de tipos, consulte usando os hubs de SignalR
do [Link] Core.
Observação
Essa funcionalidade não está limitada para o Hub<T > classe. Qualquer classe que herda de Hub,
como DynamicHub, também funcionará.

Página 54 de SignalR para [Link] Core

C#Copiar
public class ClockHub : Hub<IClock>
{
public async Task SendTimeToClients(DateTime dateTime)
{
await [Link](dateTime);
}
}
A interface usada pelo fortemente tipados ClockHub é o IClock interface.

C#Copiar
public interface IClock
{
Task ShowTime(DateTime currentTime);
}

Chamar um SignalR Hub de um serviço em segundo plano

Durante a inicialização, o Worker classe, uma BackgroundService, está conectada
usando AddHostedService.

C#Copiar
[Link]<Worker>();
Uma vez que o SignalR também está conectado durante o Startup fase, em que cada Hub está
anexado a um ponto de extremidade individual no pipeline de solicitação HTTP do [Link] Core,
cada Hub é representado por um IHubContext<T> no servidor. Usando o [Link] Core injeção de
dependência recursos, outras classes instanciadas por meio da camada de hospedagem,
como BackgroundService classes, classes de controlador MVC ou modelos de página do Razor, podem
obter referências para os Hubs do lado do servidor, aceitando as instâncias de IHubContext<ClockHub,
IClock> durante a construção.

C#Copiar
public class Worker : BackgroundService
{
private readonly ILogger<Worker> _logger;
private readonly IHubContext<ClockHub, IClock> _clockHub;
public Worker(ILogger<Worker> logger, IHubContext<ClockHub, IClock> clockHub)
{
_logger = logger;
_clockHub = clockHub;
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (![Link])
{
_logger.LogInformation($"Worker running at: {[Link]}");
await _clockHub.[Link]([Link]);
await [Link](1000);
}
}
}
Como o ExecuteAsync método é chamado de forma iterativa no serviço do plano de fundo, o servidor
data e hora atuais são enviadas para os clientes conectados usando o ClockHub.

Reagir a eventos do SignalR com serviços em segundo plano

Como um aplicativo de página única usando o cliente JavaScript para um aplicativo de área de
trabalho do .NET ou SignalR pode fazer usando o usando o Cliente de .NET do SignalR do [Link]

Página 55 de SignalR para [Link] Core

trabalho do .NET ou SignalR pode fazer usando o usando o Cliente de .NET do SignalR do [Link]
Core, um BackgroundService ou IHostedService implementação também pode ser usada para conectar-
se aos Hubs de SignalR e responder a eventos.
O ClockHubClient classe implementa ambos o IClock interface e o IHostedService interface. Dessa
forma, ele pode ser conectado durante Startup para executar continuamente e responder a eventos
do Hub do servidor.

C#Copiar
public partial class ClockHubClient : IClock, IHostedService
{
}
Durante a inicialização, o ClockHubClient cria uma instância de um HubConnection e conecta
os [Link] método como o manipulador para o Hub ShowTime eventos.

C#Copiar
private readonly ILogger<ClockHubClient> _logger;
private HubConnection _connection;
public ClockHubClient(ILogger<ClockHubClient> logger)
{
_logger = logger;

_connection = new HubConnectionBuilder()

.WithUrl([Link])
.Build();
_connection.On<DateTime>([Link],
dateTime => _ = ShowTime(dateTime));
}
public Task ShowTime(DateTime currentTime)
{
_logger.LogInformation($"{[Link]()}");
return [Link];
}
No [Link] implementação, o HubConnection é iniciado de forma assíncrona.

C#Copiar
public async Task StartAsync(CancellationToken cancellationToken)
{
// Loop is here to wait until the server is running
while (true)
{
try
{
await _connection.StartAsync(cancellationToken);
break;
}
catch
{
await [Link](1000);
}
}
}
Durante o [Link] método, o HubConnection é descartado de forma assíncrona.

C#Copiar
public Task StopAsync(CancellationToken cancellationToken)
{
return _connection.DisposeAsync();
}
}

Recursos adicionais
Página 56 de SignalR para [Link] Core
Recursos adicionais
• Introdução
• Hubs
• Publicar no Azure
• Hubs com rigidez de tipos

Comentários
De <[Link]

Página 57 de SignalR para [Link] Core

 Configuração do Signalr [Link] Core

• 04/08/2019
• 18 minutos para ler

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

[Link] Core Signalr dá suporte a dois protocolos para codificar
mensagens: JSON e MessagePack. Cada protocolo tem opções de configuração de serialização.
A serialização JSON pode ser configurada no servidor usando o método de
extensão AddJsonProtocol, que pode ser adicionado após addsignalr em seu
método [Link]. O AddJsonProtocol método usa um delegado que recebe
um optionsobjeto. A propriedade PayloadSerializerSettings nesse objeto é um objeto
[Link] JsonSerializerSettings que pode ser usado para configurar a serialização de argumentos e
valores de retorno. Consulte a documentação do [Link] para obter mais detalhes.
Por exemplo, para configurar o serializador para usar nomes de propriedade "PascalCase", em vez
dos nomes padrão "camelCase", use o seguinte código:

C#Copiar
[Link]()
.AddJsonProtocol(options => {
[Link] =
new DefaultContractResolver();
});
No cliente .net, o mesmo AddJsonProtocol método de extensão existe
em HubConnectionBuilder. O [Link] namespace deve ser
importado para resolver o método de extensão:

C#Copiar
// At the top of the file:
using [Link];
// When constructing your connection:
var connection = new HubConnectionBuilder()
.AddJsonProtocol(options => {
[Link] =
new DefaultContractResolver();
})
.Build();
Observação
Não é possível configurar a serialização JSON no cliente JavaScript neste momento.

Opções de serialização MessagePack

A serialização MessagePack pode ser configurada fornecendo um delegado para a
chamada AddMessagePackProtocol . Consulte MessagePack no signalr para obter mais detalhes.
Observação
Não é possível configurar a serialização MessagePack no cliente JavaScript neste momento.

Configurar opções de servidor

Página 58 de SignalR para [Link] Core
Configurar opções de servidor
A tabela a seguir descreve as opções para configurar os hubs de sinalização:
Opção Valor Descrição
padrão
ClientTimeo 30 O servidor considerará o cliente desconectado se ele não tiver recebido
utInterval
segundos uma mensagem (incluindo Keep-Alive) nesse intervalo. Pode levar mais
tempo do que esse intervalo de tempo limite para que o cliente seja
realmente marcado como desconectado, devido a como isso é
Handshake 15 implementado.
Se o cliente nãoOenviar
valoruma
recomendado
mensagemé de
o dobro KeepAliveInterval do valor.
handshake inicial dentro desse
Timeout
segundos intervalo de tempo, a conexão será fechada. Essa é uma configuração
avançada que só deve ser modificada se os erros de tempo limite de
handshake estiverem ocorrendo devido a uma latência de rede grave. Para
obter mais detalhes sobre o processo de handshake, consulte
KeepAliveIn 15 aSeespecificação dotiver
o servidor não protocolo deuma
enviado Hubdo signalr. dentro desse intervalo,
mensagem
terval
segundos uma mensagem de ping será enviada automaticamente para manter a
conexão aberta. Ao alterar KeepAliveInterval, altere
a ServerTimeout /configuraçãonocliente serverTimeoutInMilliseconds . O
SupportedP Todos os valor ServerTimeoutrecomendado / KeepAliveInterval é
Protocolos com suporte neste Hub. Por padrão, todos os protocolos
rotocols
protocolos registrados no servidor são permitidos, mas os protocolos podem ser
instalados removidos dessa lista para desabilitar protocolos específicos para hubs
EnableDetai false individuais.
Se true, as mensagens de exceção detalhadas serão retornadas aos clientes
ledErrors
quando uma exceção for lançada em um método de Hub. O padrão é false,
pois essas mensagens de exceção podem conter informações
confidenciais.
As opções podem ser configuradas para todos os hubs, fornecendo um AddSignalR delegado
de [Link]ções para a chamada em.

C#Copiar
public void ConfigureServices(IServiceCollection services)
{
[Link](hubOptions =>
{
[Link] = true;
[Link] = [Link](1);
});
}
As opções para um único Hub substituem as opções globais AddSignalR fornecidas no e podem
ser AddHubOptionsconfiguradas usando:

C#Copiar
[Link]().AddHubOptions<MyHub>(options =>
{
[Link] = true;
});

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

Use HttpConnectionDispatcherOptions para definir configurações avançadas relacionadas a
transportes e gerenciamento de buffer de memória. Essas opções são configuradas passando um
delegado para<MapHub T > no. [Link]

C#Copiar
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
[Link]((configure) =>
{

Página 59 de SignalR para [Link] Core

 {
var desiredTransports =
[Link] |
[Link];
[Link]<MyHub>("/myhub", (options) =>
{
[Link] = desiredTransports;
});
});
}
A tabela a seguir descreve as opções para configurar as opções HTTP avançadas do Signalr [Link]
Core:
Opção Valor padrão Descrição
ApplicationM 32 KB O número máximo de bytes recebidos do cliente que o
axBufferSize
servidor armazena em buffer. Aumentar esse valor permite
que o servidor receba mensagens maiores, mas pode afetar
negativamente o consumo de memória.
Authorization Dados coletados Uma lista de objetos IAuthorizeData usados para
Data
automaticamente determinar se um cliente está autorizado a se conectar ao
dos Authorize atributos Hub.
aplicados à classe Hub.
TransportMa 32 KB O número máximo de bytes enviados pelo aplicativo que o
xBufferSize
servidor armazena em buffer. Aumentar esse valor permite
que o servidor envie mensagens maiores, mas pode afetar
negativamente o consumo de memória.
Transports Todos os transportes Uma enumeração de sinalizadores de HttpTransportType bits
estão habilitados. de valores que pode restringir os transportes que um
LongPolling Veja abaixo. cliente
Opçõespode usar para
adicionais se conectar.
específicas para o transporte de
WebSockets Veja abaixo. sondagem longa. específicas ao transporte do
Opções adicionais
WebSockets.
O transporte de sondagem longa tem opções adicionais que podem ser configuradas usando
a LongPolling Propriedade:
Opção Valor Descrição
padrão
PollTimeo90 A quantidade máxima de tempo que o servidor aguarda uma mensagem para
ut
segundos enviar ao cliente antes de encerrar uma única solicitação de sondagem. A
redução desse valor faz com que o cliente emita novas solicitações de
sondagem
O transporte WebSocket com mais
tem opções frequência.
adicionais que podem ser configuradas WebSockets usando a
propriedade:
Opção Valor Descrição
padrão
CloseTimeou 5 Depois que o servidor for fechado, se o cliente falhar ao fechar dentro desse
t
segundos intervalo de tempo, a conexão será encerrada.
SubProtocolS null Um delegado que pode ser usado para definir o Sec-WebSocket-
elector
Protocol cabeçalho para um valor personalizado. O delegado recebe os
valores solicitados pelo cliente como entrada e é esperado para retornar o
valor desejado.

Configurar opções do cliente

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

Página 60 de SignalR para [Link] Core

como HubConnection por si só.

Configurar registro em log

O registro em log é configurado no cliente .NET ConfigureLogging usando o método. Os provedores e
filtros de log podem ser registrados da mesma maneira como estão no servidor. Consulte a
documentação de [Link] Core de logon para obter mais informações.
Observação
Para registrar provedores de log, você deve instalar os pacotes necessários. Consulte a
seção provedores de log internos do docs para obter uma lista completa.
Por exemplo, para habilitar o log do console, [Link] instale o pacote
NuGet. Chame o AddConsolemétodo de extensão:

C#Copiar
var connection = new HubConnectionBuilder()
.WithUrl("[Link]
.ConfigureLogging(logging => {
[Link]([Link]);
[Link]();
})
.Build();
No cliente JavaScript, existe um método configureLogging semelhante. Forneça um LogLevel valor que
indique o nível mínimo de mensagens de log a serem produzidas. Os logs são gravados na janela do
console do navegador.

JavaScriptCopiar
let connection = new [Link]()
.withUrl("/myhub")
.configureLogging([Link])
.build();
Observação
Para desabilitar completamente o registro [Link] configureLogging em log, especifique
no método.
Para obter mais informações sobre registro em log, consulte a documentação de diagnósticodo
signalr.
O cliente Java Signalr usa a biblioteca SLF4J para registro em log. É uma API de log de alto nível que
permite que os usuários da biblioteca escolham sua própria implementação de log específica,
trazendo uma dependência de registro em log específica. O trecho de código a seguir mostra
como [Link] usar o com o cliente Java do signalr.

gradleCopiar
implementation 'org.slf4j:slf4j-jdk14:1.7.25'
Se você não configurar o registro em log em suas dependências, o SLF4J carregará um agente sem
operação padrão com a seguinte mensagem de aviso:

Copiar
SLF4J: Failed to load class "[Link]".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See [Link] for further details.
Isso pode ser ignorado com segurança.

Configurar transportes permitidos

Os transportes usados pelo signalr podem ser configurados na WithUrl chamada (withUrl em
JavaScript). Um bit-a-ou dos valores HttpTransportType de pode ser usado para restringir o cliente a
usar apenas os transportes especificados. Todos os transportes são habilitados por padrão.
Por exemplo, para desabilitar o transporte de eventos enviados pelo servidor, mas permitir
WebSockets e conexões de sondagem longas:

Página 61 de SignalR para [Link] Core

WebSockets e conexões de sondagem longas:

C#Copiar
var connection = new HubConnectionBuilder()
.WithUrl("[Link] [Link] | [Link])
.Build();
No cliente JavaScript, os transportes são configurados definindo o transport campo no objeto de
opções fornecido para: withUrl

JavaScriptCopiar
let connection = new [Link]()
.withUrl("/myhub", { transport: [Link] |
[Link] })
.build();
Nesta versão do WebSocket do cliente Java é o único transporte disponível.

Configurar a autenticação do portador

Para fornecer dados de autenticação juntamente com solicitações do
signalr, AccessTokenProvider use aaccessTokenFactory opção (em JavaScript) para especificar uma
função que retorna o token de acesso desejado. No cliente .net, esse token de acesso é passado
como um token http "autenticação de portador" (usando o Authorization cabeçalho com um tipo
de Bearer). No cliente JavaScript, o token de acesso é usado como um token de portador, exceto em
alguns casos em que as APIs de navegador restringem a capacidade de aplicar cabeçalhos
(especificamente, em eventos enviados pelo servidor e solicitações de WebSocket). Nesses casos, o
token de acesso é fornecido como um valor access_tokende cadeia de caracteres de consulta.
No cliente .net, a AccessTokenProvider opção pode ser especificada usando o delegado de opções
em: WithUrl

C#Copiar
var connection = new HubConnectionBuilder()
.WithUrl("[Link] options => {
[Link] = async () => {
// Get and return the access token.
};
})
.Build();
No cliente JavaScript, o token de acesso é configurado definindo o accessTokenFactory campo no
objeto Options em: withUrl

JavaScriptCopiar
let connection = new [Link]()
.withUrl("/myhub", {
accessTokenFactory: () => {
// Get and return the access token.
// This function can return a JavaScript Promise if asynchronous
// logic is required to retrieve the access token.
}
})
.build();
No cliente Java do Signalr, você pode configurar um token de portador a ser usado para
autenticação, fornecendo um alocador de token de acesso para
o HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer uma única<cadeia de
caracteres>de RxJava. Com uma chamada para Single. Defer, você pode escrever lógica para
produzir tokens de acesso para seu cliente.

JavaCopiar
HubConnection hubConnection = [Link]("[Link]
.withAccessTokenProvider([Link](() -> {
// Your logic here.

Página 62 de SignalR para [Link] Core

 // Your logic here.
return [Link]("An Access Token");
})).build();

Configurar opções de tempo limite e Keep-Alive

Opções adicionais para configurar o tempo limite e o HubConnection comportamento Keep-Alive
estão disponíveis no próprio objeto:
• .NET
• JavaScript
• Java
Opção Valor Descrição
padrão
ServerTim 30 Tempo limite para a atividade do servidor. Se o servidor não tiver enviado
eout
segundos uma mensagem nesse intervalo, o cliente considerará o servidor
(30.000 desconectado e Closed disparará o evento (oncloseem JavaScript). Esse valor
milissegund deve ser grande o suficiente para que uma mensagem de ping seja enviada
os) do servidor e recebida pelo cliente dentro do intervalo de tempo limite. O
valor recomendado é um número, pelo menos, o dobro KeepAliveInterval do
Handshake 15 valor
Tempo dolimite
servidor
parapara dar tempoinicial
o handshake para do
queservidor.
os pingsSe
cheguem.
o servidor não enviar
Timeout
segundos uma resposta de handshake nesse intervalo, o cliente cancelará o
handshake e disparará o Closed evento (oncloseem JavaScript). Essa é uma
configuração avançada que só deve ser modificada se os erros de tempo
limite de handshake estiverem ocorrendo devido a uma latência de rede
grave. Para obter mais detalhes sobre o processo de handshake, consulte
KeepAliveI 15 aDetermina
especificação do protocolo
o intervalo no qualdeo Hubdo
cliente signalr.
envia mensagens de ping. O envio
nterval
segundos de qualquer mensagem do cliente redefine o temporizador para o início do
intervalo. Se o cliente não tiver enviado uma mensagem
no ClientTimeoutInterval conjunto no servidor, o servidor considerará o cliente
desconectado.
No cliente .net, os valores de tempo limite são TimeSpan especificados como valores.

Configurar opções adicionais

Opções adicionais podem ser configuradas WithUrl nowithUrl método (em
JavaScript) HubConnectionBuilder em HttpHubConnectionBuilder ou em várias APIs de configuração no
cliente Java:
• .NET
• JavaScript
• Java
Opção .N Valor Descrição
ET padrão
AccessToke null Uma função que retorna uma cadeia de caracteres que é fornecida como um
nProvider
token de autenticação de portador em solicitações HTTP.
SkipNegotia false Defina como true para ignorar a etapa de negociação. Com suporte apenas
tion
quando o transporte WebSockets é o único transporte habilitado. Essa
configuração não pode ser habilitada ao usar o serviço de Signaler do Azure.
ClientCertifi Vazio Uma coleção de certificados TLS a serem enviados para autenticar
cates
solicitações.
Cookies Vazio Uma coleção de cookies HTTP a serem enviados com cada solicitação HTTP.
Credentials Vazio Credenciais a serem enviadas com cada solicitação HTTP.
CloseTimeo 5 Somente WebSockets. A quantidade máxima de tempo que o cliente aguarda

Página 63 de SignalR para [Link] Core

CloseTimeo 5 Somente WebSockets. A quantidade máxima de tempo que o cliente aguarda
ut
segundo depois de fechar para que o servidor reconheça a solicitação de
s fechamento. Se o servidor não reconhecer o fechamento dentro desse tempo,
Headers Vazio o
Umcliente
mapasededesconectará.
cabeçalhos HTTP adicionais para enviar com cada solicitação
HttpMessag null HTTP.
Um delegado que pode ser usado para configurar ou substituir
eHandlerFa
o HttpMessageHandler usado para enviar solicitações HTTP. Não é usado para
ctory
conexões WebSocket. Esse delegado deve retornar um valor não nulo e
recebe o valor padrão como um parâmetro. Modifique as configurações desse
valor padrão e retorne-o ou retorne uma HttpMessageHandler nova instância. Ao
substituir o manipulador, certifique-se de copiar as configurações que deseja
manter do manipulador fornecido, caso contrário, as opções configuradas
Proxy null (como cookies
Um proxy HTTPeacabeçalhos)
ser usado aonão se aplicarão
enviar ao HTTP.
solicitações novo manipulador.
UseDefault false Defina esse booliano para enviar as credenciais padrão para solicitações de
Credentials
HTTP e WebSockets. Isso permite o uso da autenticação do Windows.
WebSocket null Um delegado que pode ser usado para configurar opções adicionais do
Configurati
WebSocket. Recebe uma instância de ClientWebSocketOptions que pode ser
on
No cliente .NET, essasusada para
opções configurar
podem as opçõ[Link] delegado de opções fornecido
ser modificadas
para WithUrl:

C#Copiar
var connection = new HubConnectionBuilder()
.WithUrl("[Link] options => {
[Link]["Foo"] = "Bar";
[Link](new Cookie(/* ... */);
[Link](/* ... */);
})
.Build();
No cliente JavaScript, essas opções podem ser fornecidas em um objeto JavaScript fornecido
para withUrl:

JavaScriptCopiar
let connection = new [Link]()
.withUrl("/myhub", {
skipNegotiation: true,
transport: [Link]
})
.build();
No cliente Java, essas opções podem ser configuradas com os métodos
no HttpHubConnectionBuilder retornado [Link]("HUB URL")

JavaCopiar
HubConnection hubConnection = [Link]("[Link]
.withHeader("Foo", "Bar")
.shouldSkipNegotiate(true)
.withHandshakeResponseTimeout(30*1000)
.build();

Recursos adicionais
• Introdução ao SignalR para [Link] Core
• Usando os hubs de SignalR do [Link] Core
• Cliente JavaScript do Signalr [Link] Core
• Cliente de .NET do SignalR do [Link] Core
• Usar o protocolo de MessagePack Hub no SignalR do [Link] Core
• Plataformas com suporte do SignalR do [Link] Core

Página 64 de SignalR para [Link] Core

Comentários
De <[Link]

Página 65 de SignalR para [Link] Core

 Autenticação e autorização no Signalr [Link] Core

• 14/07/2019
• 7 minutos para ler

Por Andrew Stanton-enfermaria

Exibir ou baixar código de exemplo (como baixar)

Autenticar usuários que se conectam a um Hub do Signalr

O signalr pode ser usado com [Link] Core autenticação para associar um usuário a cada
conexão. Em um Hub, os dados de autenticação podem ser acessados
da [Link] propriedade. A autenticação permite que o Hub Chame métodos em
todas as conexões associadas a um usuário (consulte gerenciar usuários e grupos no signalr para
obter mais informações). Várias conexões podem ser associadas a um único usuário.
Veja a seguir um exemplo de [Link] que usa a autenticação de sinalização e [Link] Core:

C#Copiar
public void Configure(IApplicationBuilder app)
{
...
[Link]();

[Link]();
[Link](hubs =>
{
[Link]<ChatHub>("/chat");
});
[Link](routes =>
{
[Link]("default", "{controller=Home}/{action=Index}/{id?}");
});
}
Observação
A ordem na qual você registra o Signalr e o middleware de autenticação [Link] Core é
importante. Sempre chame UseAuthentication antes UseSignalR para que o HttpContextsignalr tenha
um usuário no.

Autenticação de cookie
Em um aplicativo baseado em navegador, a autenticação de cookie permite que suas credenciais de
usuário existentes fluam automaticamente para conexões de Signalr. Ao usar o cliente de
navegador, nenhuma configuração adicional é necessária. Se o usuário estiver conectado ao seu
aplicativo, a conexão do Signalr herdará automaticamente essa autenticação.
Cookies são uma maneira específica do navegador de enviar tokens de acesso, mas os clientes sem
navegador podem enviá-los. Ao usar o cliente .net, a Cookies propriedade pode .WithUrl ser
configurada na chamada a fim de fornecer um cookie. No entanto, usar a autenticação de cookie do
cliente .NET requer que o aplicativo forneça uma API para trocar dados de autenticação para um
cookie.

Autenticação de token de portador

Página 66 de SignalR para [Link] Core
Autenticação de token de portador
O cliente pode fornecer um token de acesso em vez de usar um cookie. O servidor valida o token e o
usa para identificar o usuá[Link] validação é feita somente quando a conexão é
estabelecida. Durante a vida útil da conexão, o servidor não é revalidado automaticamente para
verificar a revogação de tokens.
No servidor, a autenticação de token de portador é configurada usando o middleware portador JWT.
No cliente JavaScript, o token pode ser fornecido usando a opção accessTokenFactory .

TypeScriptCopiar
[Link] = new [Link]()
.withUrl("/hubs/chat", { accessTokenFactory: () => [Link] })
.build();
No cliente .NET, há uma propriedade AccessTokenProvider semelhante que pode ser usada para
configurar o token:

C#Copiar
var connection = new HubConnectionBuilder()
.WithUrl("[Link] options =>
{
[Link] = () => [Link](_myAccessToken);
})
.Build();
Observação
A função de token de acesso que você fornece é chamada antes de cada solicitação HTTP feita pelo
signalr. Se você precisar renovar o token para manter a conexão ativa (porque ela pode expirar
durante a conexão), faça isso de dentro dessa função e retorne o token atualizado.
Nas APIs Web padrão, os tokens de portador são enviados em um cabeçalho HTTP. No entanto, o
Signalr não pode definir esses cabeçalhos em navegadores ao usar alguns transportes. Ao usar
Websockets e eventos enviados pelo servidor, o token é transmitido como um parâmetro de cadeia
de caracteres de consulta. Para dar suporte a isso no servidor, é necessária uma configuração
adicional:

C#Copiar
public void ConfigureServices(IServiceCollection services)
{
[Link]<ApplicationDbContext>(options =>
[Link]([Link]("DefaultConnection")));
[Link]<ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();
[Link](options =>
{
// Identity made Cookie authentication the default.
// However, we want JWT Bearer Auth to be the default.
[Link] = [Link];
[Link] = [Link];
})
.AddJwtBearer(options =>
{
// Configure JWT Bearer Auth to expect our security key
[Link] =
new TokenValidationParameters
{
LifetimeValidator = (before, expires, token, param) =>
{
return expires > [Link];
},
ValidateAudience = false,
ValidateIssuer = false,
ValidateActor = false,

Página 67 de SignalR para [Link] Core

 ValidateActor = false,
ValidateLifetime = true,
IssuerSigningKey = SecurityKey
};
// We have to hook the OnMessageReceived event in order to
// allow the JWT authentication handler to read the access
// token from the query string when a WebSocket or
// Server-Sent Events request comes in.
[Link] = new JwtBearerEvents
{
OnMessageReceived = context =>
{
var accessToken = [Link]["access_token"];
// If the request is for our hub...
var path = [Link];
if ( &&
([Link]("/hubs/chat")))
{
// Read the token out of the query string
[Link] = accessToken;
}
return [Link];
}
};
});
[Link]().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
[Link]();
// Change to use Name as the user identifier for SignalR
// WARNING: This requires that the source of your JWT token
// ensures that the Name claim is unique!
// If the Name claim isn't unique, users could receive messages
// intended for a different user!
[Link]<IUserIdProvider, NameUserIdProvider>();
// Change to use email as the user identifier for SignalR
// [Link]<IUserIdProvider, EmailBasedUserIdProvider>();
// WARNING: use *either* the NameUserIdProvider *or* the
// EmailBasedUserIdProvider, but do not use both.
}

Cookies versus tokens de portador

Como os cookies são específicos para os navegadores, enviá-los de outros tipos de clientes adiciona
complexidade em comparação ao envio de tokens de portador. Por esse motivo, a autenticação de
cookie não é recomendada, a menos que o aplicativo precise apenas autenticar usuários do cliente
de navegador. A autenticação de token de portador é a abordagem recomendada ao usar clientes
diferentes do cliente de navegador.

Autenticação do Windows
Se a autenticação do Windows estiver configurada em seu aplicativo, o signalr poderá usar essa
identidade para proteger os [Link] entanto, para enviar mensagens a usuários individuais, você
precisa adicionar um provedor de ID de usuário personalizado. Isso ocorre porque o sistema de
autenticação do Windows não fornece a declaração de "identificador de nome" que o Signalr usa
para determinar o nome de usuário.
Adicione uma nova classe que implementa IUserIdProvider e recupere uma das declarações do
usuário para usar como o identificador. Por exemplo, para usar a declaração "Name" (que é o nome
de usuário do Windows [Domain]\[Username]no formulário), crie a seguinte classe:

C#Copiar

Página 68 de SignalR para [Link] Core

C#Copiar
public class NameUserIdProvider : IUserIdProvider
{
public string GetUserId(HubConnectionContext connection)
{
return [Link]?.Identity?.Name;
}
}
Em vez [Link], você pode usar qualquer valor User do (como o identificador de SID do
Windows, etc.).
Observação
O valor escolhido deve ser exclusivo entre todos os usuários em seu sistema. Caso contrário, uma
mensagem destinada a um usuário poderia acabar indo para um usuário diferente.
Registre esse componente em seu [Link] método.

C#Copiar
public void ConfigureServices(IServiceCollection services)
{
// ... other services ...
[Link]();
[Link]<IUserIdProvider, NameUserIdProvider>();
}
No cliente .NET, a autenticação do Windows deve ser habilitada definindo a
propriedade UseDefaultCredentials :

C#Copiar
var connection = new HubConnectionBuilder()
.WithUrl("[Link] options =>
{
[Link] = true;
})
.Build();
A autenticação do Windows só tem suporte pelo cliente de navegador ao usar o Microsoft Internet
Explorer ou o Microsoft Edge.

Usar declarações para personalizar o tratamento de identidades

Um aplicativo que autentica os usuários pode derivar IDs de usuário do Signalr de declarações do
usuário. Para especificar como o signalr cria IDs de usuário IUserIdProvider , implemente e registre a
implementação.
O código de exemplo demonstra como você usaria declarações para selecionar o endereço de email
do usuário como a propriedade de identificação.
Observação
O valor escolhido deve ser exclusivo entre todos os usuários em seu sistema. Caso contrário, uma
mensagem destinada a um usuário poderia acabar indo para um usuário diferente.

C#Copiar
public class EmailBasedUserIdProvider : IUserIdProvider
{
public virtual string GetUserId(HubConnectionContext connection)
{
return [Link]?.FindFirst([Link])?.Value;
}
}
O registro de conta adiciona uma declaração com [Link] o tipo ao banco de dados de
identidade [Link].

C#Copiar
// create a new user
var user = new ApplicationUser { UserName = [Link], Email = [Link] };

Página 69 de SignalR para [Link] Core

var user = new ApplicationUser { UserName = [Link], Email = [Link] };
var result = await _userManager.CreateAsync(user, [Link]);
// add the email claim and value for this user
await _userManager.AddClaimAsync(user, new Claim([Link], [Link]));
Registre esse componente no seu [Link].

C#Copiar
[Link]<IUserIdProvider, EmailBasedUserIdProvider>();

Autorizar usuários a acessar hubs e métodos de Hub

Por padrão, todos os métodos em um Hub podem ser chamados por um usuário não
autenticado. Para exigir autenticação, aplique o atributo autorizar ao Hub:

C#Copiar
[Authorize]
public class ChatHub: Hub
{
}
Você pode usar os argumentos do construtor e as propriedades [Authorize] do atributo para
restringir o acesso a apenas os usuários que correspondem a políticas de autorizaçãoespecíficas. Por
exemplo, se você tiver uma política de autorização personalizada MyAuthorizationPolicy chamada,
poderá garantir que somente os usuários que correspondem a essa política possam acessar o Hub
usando o seguinte código:

C#Copiar
[Authorize("MyAuthorizationPolicy")]
public class ChatHub : Hub
{
}
Os métodos de Hub individuais também [Authorize] podem ter o atributo aplicado. Se o usuário atual
não corresponder à política aplicada ao método, um erro será retornado ao chamador:

C#Copiar
[Authorize]
public class ChatHub : Hub
{
public async Task Send(string message)
{
// ... send a message to all users ...
}
[Authorize("Administrators")]
public void BanUser(string userName)
{
// ... ban a user from the chat room (something only Administrators can do) ...
}
}

Recursos adicionais
• Autenticação de token de portador no [Link] Core
• Autorização baseada em recursos

Comentários
De <[Link]

Página 70 de SignalR para [Link] Core

 Considerações de segurança no SignalR do [Link] Core

• 05/11/2018
• 4 minutos para ler

Por Andrew Stanton-Nurse

Este artigo fornece informações sobre como proteger o SignalR.

Compartilhamento de recursos entre origens

Recursos entre origens (CORS) compartilhamento pode ser usado para permitir conexões do SignalR
entre origens no navegador. Se o código JavaScript é hospedado em um domínio diferente do
aplicativo do SignalR, middleware CORS deve estar habilitado para permitir que o JavaScript para se
conectar ao aplicativo SignalR. Permitir solicitações entre origens de domínios que confiáveis ou
controle. Por exemplo:
• O site é hospedado em [Link]
• Seu aplicativo SignalR é hospedado em [Link]
CORS devem ser configurado no aplicativo do SignalR para permitir somente a
origem [Link].
Para obter mais informações sobre como configurar o CORS, consulte habilitar solicitações de entre
origens (CORS). O SignalR requer as seguintes políticas CORS:
• Permitir que as origens esperadas específicas. Permitir qualquer origem é possível, mas
está não segura ou recomendada.
• Métodos HTTP GET e POST devem ser permitidos.
• Credenciais devem ser habilitadas, mesmo quando a autenticação não é usada.
Por exemplo, a seguinte política CORS permite que um cliente de navegador do SignalR hospedado
no [Link] para acessar o aplicativo de SignalR hospedado
em [Link]

C#Copiar
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
// ... other middleware ...
// Make sure the CORS middleware is ahead of SignalR.
[Link](builder =>
{
[Link]("[Link]
.AllowAnyHeader()
.WithMethods("GET", "POST")
.AllowCredentials();
});
// ... other middleware ...
[Link](routes =>
{
[Link]<ChatHub>("/chatHub");
});
// ... other middleware ...
}
Observação
O SignalR não é compatível com o recurso interno de CORS no serviço de aplicativo do Azure.

Página 71 de SignalR para [Link] Core

WebSocket Origin Restriction
As proteções fornecidas pelo CORS não se aplicam ao WebSockets. Para a restrição de origem sobre
WebSockets, leia restrição de origem de WebSockets.

Log de token de acesso

Ao usar WebSockets ou Server-Sent eventos, o cliente de navegador envia o token de acesso na
cadeia de caracteres de [Link] o token de acesso por meio da cadeia de caracteres de
consulta é geralmente tão seguro quanto usar o padrão Authorization cabeçalho. Você sempre deve
usar HTTPS para garantir uma conexão segura de ponta a ponta entre o cliente e o servidor. A URL
para cada solicitação, incluindo a cadeia de caracteres de consulta de log de muitos servidores
web. Registro em log as URLs pode registrar o token de acesso. [Link] Core registra a URL para
cada solicitação, por padrão, o que incluirá a cadeia de caracteres de consulta. Por exemplo:

Copiar
info: [Link][1]
Request starting HTTP/1.1 GET [Link]
Se você tiver dúvidas sobre o log de dados com os logs do servidor, você pode desabilitar esse log
inteiramente, configurando o [Link] agente para o Warning nível ou superior
(essas mensagens são gravadas em Info nível). Consulte a documentação sobre filtragem de Log para
obter mais informações. Se você ainda quiser registrar determinadas informações de solicitação,
você poderá escrever um middleware para registrar os dados necessários e filtrar
o access_token valor de cadeia de caracteres de consulta (se presente).

Exceções
Mensagens de exceção são geralmente consideradas dados confidenciais que não devem ser
revelados para um cliente. Por padrão, o SignalR não envia os detalhes de uma exceção gerada por
um método de hub para o cliente. Em vez disso, o cliente recebe uma mensagem genérica indicando
que ocorreu um erro. Entrega de mensagem de exceção para o cliente pode ser substituída (por
exemplo, no desenvolvimento ou teste) com EnableDetailedErrors . Mensagens de exceção não
devem ser expostas ao cliente em aplicativos de produção.

Gerenciamento de buffer
O SignalR usa buffers por conexão para gerenciar mensagens de entrada e saídas. Por padrão, o
SignalR limita esses buffers para 32 KB. A mensagem maior que um cliente ou servidor pode enviar é
32 KB. O máximo de memória consumido por uma conexão de mensagens é 32 KB. Se as mensagens
são sempre menores que 32 KB, você pode reduzir o limite, que:
• Impede que um cliente que está sendo capaz de enviar uma mensagem maior.
• O servidor nunca será necessário alocar buffers grandes para aceitar mensagens.
Se suas mensagens forem maiores que 32 KB, você pode aumentar o limite. Aumentar esse limite
significa:
• O cliente pode fazer com que o servidor para alocar buffers de memória grandes.
• Alocação de servidor de buffers grandes pode reduzir o número de conexões simultâneas.
Há limites para mensagens de entrada e saídas, ambos podem ser configuradas sobre
o HttpConnectionDispatcherOptions objeto configurado no MapHub:
• ApplicationMaxBufferSize representa o número máximo de bytes do cliente que os buffers de
servidor. Se o cliente tenta enviar uma mensagem maior que esse limite, a conexão poderá ser
fechada.
• TransportMaxBufferSize representa o número máximo de bytes que o servidor pode enviar. Se o
servidor tenta enviar uma mensagem (incluindo valores de retorno de métodos de hub)

Página 72 de SignalR para [Link] Core

 servidor tenta enviar uma mensagem (incluindo valores de retorno de métodos de hub)
maiores que esse limite, uma exceção será lançada.
Definir o limite como 0 desabilita o limite. Remover o limite permite que um cliente enviar uma
mensagem de qualquer tamanho. Os clientes mal-intencionados enviando mensagens extensas
podem provocar alocação de memória em excesso. Uso de memória em excesso pode reduzir
significativamente o número de conexões simultâneas.

Comentários
De <[Link]

Página 73 de SignalR para [Link] Core

 Usar o protocolo de MessagePack Hub no SignalR do
[Link] Core

• 26/02/2019
• 4 minutos para ler

Por Brennan Conroy

Este artigo pressupõe que o leitor esteja familiarizado com os tópicos abordados começar.

O que é MessagePack?
MessagePack é um formato de serialização binária que é rápido e compacto. Ela é útil quando o
desempenho e a largura de banda são uma preocupação porque cria mensagens menores em
comparação comparadas JSON. Porque ele é um formato binário, as mensagens são ilegíveis ao
examinar os logs e rastreamentos de rede, a menos que os bytes são passados por meio de um
analisador MessagePack. O SignalR tem suporte interno para o formato MessagePack e fornece APIs
para o cliente e servidor usar.

Configurar MessagePack no servidor

Para habilitar o protocolo do Hub MessagePack no servidor, instale
o [Link] pacote em seu aplicativo. No arquivo
[Link], adicione AddMessagePackProtocol para o AddSignalR chamada para habilitar o suporte de
MessagePack no servidor.
Observação
JSON é habilitado por padrão. Adicionar MessagePack habilita o suporte para JSON e MessagePack
clientes.

C#Copiar
[Link]()
.AddMessagePackProtocol();
Para personalizar como MessagePack formatará a seus dados, AddMessagePackProtocol aceita um
delegado para configurar as opções. No delegado, o FormatterResolvers propriedade pode ser usada
para configurar as opções de serialização [Link] obter mais informações sobre como
funcionam os resolvedores, visite a biblioteca, MessagePack em [Link]
podem ser usados nos objetos que você deseja serializar para definir como eles devem ser tratados.

C#Copiar
[Link]()
.AddMessagePackProtocol(options =>
{
[Link] = new List<[Link]>()
{
[Link]
};
});

Configurar MessagePack no cliente

Página 74 de SignalR para [Link] Core

 Observação
JSON é habilitado por padrão para os clientes com suporte. Os clientes só podem dar suporte a um
único protocolo. Adicionar suporte MessagePack qualquer substituirá anteriormente protocolos
configurados.

Cliente .NET
Para habilitar MessagePack no cliente .NET, instale
o [Link] pacote e
chame AddMessagePackProtocol em HubConnectionBuilder.

C#Copiar
var hubConnection = new HubConnectionBuilder()
.WithUrl("/chatHub")
.AddMessagePackProtocol()
.Build();
Observação
Isso AddMessagePackProtocol chamada aceita um delegado para configurar opções de como o
servidor.

Cliente JavaScript
MessagePack suporte para o cliente JavaScript é fornecido pelo @aspnet/signalr-protocol-
msgpack pacote npm.

consoleCopiar
npm install @aspnet/signalr-protocol-msgpack
Depois de instalar o pacote npm, o módulo pode ser usado diretamente por meio de um carregador
de módulo de JavaScript ou importado para o navegador fazendo referência a node_modules
\@aspnet\signalr-protocol-msgpack\dist\browser\[Link] arquivo. Em um
navegador, o msgpack5 biblioteca também deve ser referenciada. Use um <script> marca para criar
uma referência. A biblioteca pode ser encontrada em node_modules\msgpack5\dist\[Link].
Observação
Ao usar o <script> elemento, a ordem é importante. Se [Link] é referenciada
antes [Link], ocorre um erro quando tentar se conectar com MessagePack. [Link] também
é necessária antes [Link].

HTMLCopiar
<script src="~/lib/signalr/[Link]"></script>
<script src="~/lib/msgpack5/[Link]"></script>
<script src="~/lib/signalr/[Link]"></script>
Adicionando .withHubProtocol(new [Link]()) para
o HubConnectionBuilder irá configurar o cliente para usar o protocolo MessagePack ao se conectar a
um servidor.

JavaScriptCopiar
const connection = new [Link]()
.withUrl("/chatHub")
.withHubProtocol(new [Link]())
.build();
Observação
Neste momento, não há nenhuma opção de configuração para o protocolo MessagePack no cliente
JavaScript.

MessagePack quirks
Página 75 de SignalR para [Link] Core
MessagePack quirks
Existem algumas questões a serem consideradas ao usar o protocolo de Hub MessagePack.

MessagePack diferencia maiusculas de minúsculas

O protocolo MessagePack diferencia maiusculas de minúsculas. Por exemplo, considere o seguinte
C# classe:

C#Copiar
public class ChatMessage
{
public string Sender { get; }
public string Message { get; }
}
Durante o envio do cliente JavaScript, você deve usar PascalCased nomes de propriedade, uma vez
que as maiusculas e minúsculas devem corresponder a C# classe exatamente. Por exemplo:

JavaScriptCopiar
[Link]("SomeMethod", { Sender: "Sally", Message: "Hello!" });
Usando o camelCased nomes não vincular corretamente para o C# classe. Você pode contornar isso
usando o Key atributo para especificar um nome diferente para a propriedade MessagePack. Para
obter mais informações, consulte a documentação do CSharp MessagePack.

DateTime. Kind não é preservada quando serializar/desserializar

O protocolo MessagePack não fornece uma maneira para codificar a Kind valor de
um DateTime. Como resultado, ao desserializar uma data, o protocolo de Hub MessagePack assume
que a data de entrada está no formato UTC. Se você estiver trabalhando com DateTime valores na
hora local, é recomendável converter para UTC antes de enviá-los. Convertê-los do UTC em hora
local quando você recebê-las.
Para obter mais informações sobre essa limitação, consulte GitHub problema aspnet/SignalR #2632.

Não há suporte para MinValue MessagePack em JavaScript

O msgpack5 biblioteca usada pelo cliente SignalR JavaScript não oferece suporte a timestamp96 tipo
no MessagePack. Esse tipo é usado para codificar os valores de data muito grandes (ou muito no
início no passado ou muito distante no futuro). O valor de [Link] está January 1,
0001 que deve ser codificado em um timestamp96 valor. Devido a isso,
enviando [Link] um JavaScript cliente não tem suporte. Quando [Link] é
recebida pelo cliente JavaScript, o seguinte erro será gerado:

Copiar
Uncaught Error: unable to find ext type 255 at [Link]
Geralmente, [Link] é usado para codificar um "ausente" ou null valor. Se você precisar
codificar esse valor em MessagePack, use um valor anulável DateTime valor (DateTime?) ou codificar
um separado bool valor que indica se a data estiver presente.
Para obter mais informações sobre essa limitação, consulte GitHub problema aspnet/SignalR #2228.

Suporte de MessagePack no ambiente de compilação "ahead-of-

time"
O MessagePack-CSharp usada pelo cliente do .NET e no servidor de biblioteca usa geração de código
para otimizar a serializaçã[Link] resultado, ele não é suportado por padrão em ambientes que

Página 76 de SignalR para [Link] Core

para otimizar a serializaçã[Link] resultado, ele não é suportado por padrão em ambientes que
usam a compilação "ahead of time" (como Unity ou o Xamarin iOS). É possível usar MessagePack
nesses ambientes gerando"pré-" o código do serializador/desserializador. Para obter mais
informações, consulte a documentação do CSharp MessagePack. Depois de gerar previamente os
serializadores, você pode registrá-los usando o delegado de configuração passado
para AddMessagePackProtocol:

C#Copiar
[Link]()
.AddMessagePackProtocol(options =>
{
[Link] = new List<[Link]>()
{
[Link],
[Link]
};
});

Verificações de tipo sejam mais estritas no MessagePack

O protocolo do Hub JSON executará as conversões de tipo durante a desserialização. Por exemplo,
se o objeto de entrada tem um valor de propriedade que é um número ({ foo: 42 }), mas a
propriedade na classe do .NET é do tipo string, o valor será convertido. No entanto, MessagePack
não realiza essa conversão e lançará uma exceção que pode ser vista nos logs do lado do servidor (e
no console do):

Copiar
InvalidDataException: Error binding arguments. Make sure that the types of the provided values match the
types of the hub method being invoked.
Para obter mais informações sobre essa limitação, consulte GitHub problema aspnet/SignalR #2937.

Recursos relacionados
• Introdução
• Cliente .NET
• Cliente JavaScript

Comentários
De <[Link]

Página 77 de SignalR para [Link] Core

 Usar o streaming em SignalR do [Link] Core

• 04/06/2019
• 7 minutos para ler

Por Brennan Conroy

SignalR do [Link] Core dá suporte a streaming valores de retorno dos métodos de servidor. Isso é
útil para cenários em que os fragmentos de dados chegam ao longo do tempo. Quando um valor de
retorno é transmitido ao cliente, cada fragmento é enviado ao cliente assim que ele se torna
disponível, em vez de aguardar que todos os dados fiquem disponíveis.
Exibir ou baixar código de exemplo (como baixar)

Configurar um hub para streaming

Um método de hub automaticamente se torna um método de hub streaming quando ele retorna
um ChannelReader<T> ou um Task<ChannelReader<T>>.

Streaming Server-para-cliente
O exemplo a seguir mostra os conceitos básicos do fluxo de dados para o cliente usando
canais. Sempre que um objeto é gravado para o ChannelWriter<T>, o objeto imediatamente é
enviado ao cliente. No final, o ChannelWriter estiver concluído para dizer ao cliente o fluxo está
fechado.
Observação
Gravar o ChannelWriter<T> em um thread em segundo plano e retorne o ChannelReader assim que
possível. Outras chamadas de hub são bloqueadas até que um ChannelReader é retornado.
Encapsular a lógica em um try ... catch. Conclua o Channel no catch quanto fora o catch para garantir
que o hub de invocação de método é concluída corretamente.

C#Copiar
public class StreamHub : Hub
{
public ChannelReader<int> Counter(
int count,
int delay,
CancellationToken cancellationToken)
{
var channel = [Link]<int>();
// We don't want to await WriteItemsAsync, otherwise we'd end up waiting
// for all the items to be written before returning the channel back to
// the client.
_ = WriteItemsAsync([Link], count, delay, cancellationToken);
return [Link];
}
private async Task WriteItemsAsync(
ChannelWriter<int> writer,
int count,
int delay,
CancellationToken cancellationToken)
{
try
{

Página 78 de SignalR para [Link] Core

 {
for (var i = 0; i < count; i++)
{
// Check the cancellation token regularly so that the server will stop
// producing items if the client disconnects.
[Link]();
await [Link](i);
// Use the cancellationToken in other APIs that accept cancellation
// tokens so the cancellation can flow down to them.
await [Link](delay, cancellationToken);
}
}
catch (Exception ex)
{
[Link](ex);
}
[Link]();
}
}
Métodos de hub do streaming Server para o cliente podem aceitar um CancellationToken parâmetro
que é disparado quando o cliente cancela a assinatura do fluxo. Use esse token para interromper a
operação do servidor e liberar quaisquer recursos se o cliente se desconecta antes do final do fluxo.

Cliente .NET

Streaming Server-para-cliente
O StreamAsChannelAsync método no HubConnection é usado para invocar um método de transmissão
de servidor para cliente. Passe o nome do método de hub e argumentos definidos no método de
hub para StreamAsChannelAsync. O parâmetro genérico em StreamAsChannelAsync<T> Especifica o tipo
de objetos retornados pelo método de transmissão. Um ChannelReader<T> é retornada da invocação
de fluxo e representa o fluxo no cliente.

C#Copiar
// Call "Cancel" on this CancellationTokenSource to send a cancellation message to
// the server, which will trigger the corresponding token in the hub method.
var cancellationTokenSource = new CancellationTokenSource();
var channel = await [Link]<int>(
"Counter", 10, 500, [Link]);
// Wait asynchronously for data to become available
while (await [Link]())
{
// Read all currently available data synchronously, before waiting for more data
while ([Link](out var count))
{
[Link]($"{count}");
}
}
[Link]("Streaming completed");

Cliente JavaScript

Streaming Server-para-cliente
Os clientes JavaScript chamem métodos de streaming do servidor-para-cliente em hubs
com [Link]. O stream método aceita dois argumentos:

Página 79 de SignalR para [Link] Core

com [Link]. O stream método aceita dois argumentos:
• O nome do método de hub. No exemplo a seguir, o nome do método de hub é Counter.
• Argumentos definidos no método de hub. No exemplo a seguir, os argumentos são uma
contagem do número de itens de fluxo para receber e o atraso entre itens de fluxo.
[Link] Retorna um IStreamResult, que contém um subscribe método. Passar
uma IStreamSubscriber para subscribe e defina as next, error, e complete retornos de chamada para
receber notificações do stream invocação.

JavaScriptCopiar
[Link]("Counter", 10, 500)
.subscribe({
next: (item) => {
var li = [Link]("li");
[Link] = item;
[Link]("messagesList").appendChild(li);
},
complete: () => {
var li = [Link]("li");
[Link] = "Stream completed";
[Link]("messagesList").appendChild(li);
},
error: (err) => {
var li = [Link]("li");
[Link] = err;
[Link]("messagesList").appendChild(li);
},
});
Para terminar o fluxo do cliente, chame o dispose método em de ISubscription que é retornado
do subscribe método. Chamar esse método faz com que o cancelamento
do CancellationToken parâmetro do método de Hub, se você tiver fornecido um.

Recursos adicionais
• Hubs
• Cliente .NET
• Cliente JavaScript
• Publicar no Azure

Comentários
De <[Link]

Página 80 de SignalR para [Link] Core

 Diferenças entre o SignalR do [Link] e o SignalR do
[Link] Core

• 13/11/2018
• 4 minutos para ler

SignalR do [Link] Core não é compatível com clientes ou servidores para [Link] SignalR. Este
artigo fornece detalhes sobre os recursos que foram removidos ou alterados no SignalR do [Link]
Core.

Como identificar a versão do SignalR

[Link] SignalR SignalR do [Link] Core
Pacote do NuGet Server [Link] [Link] (.
NET Core)
Microsoft (.NET Framework)
Pacotes NuGet de cliente [Link] [Link]
[Link] [Link]
Pacote npm de cliente signalr @aspnet/signalr
Cliente de Java Repositório GitHub (preterido) Pacote do
Maven [Link]
Tipo de aplicativo de [Link] (System. Web) ou a auto- [Link] Core
servidor hospedagem de OWIN
Plataformas de servidor .NET framework 4.5 ou posterior .NET Framework 4.6.1 ou
com suporte .NET core 2.1 ou posterior
posterior

Diferenças de recursos

Reconexão automática
Reconexão automática não têm suporte no SignalR do [Link] Core. Se o cliente for desconectado,
o usuário explicitamente deve iniciar uma nova conexão, se eles desejam se reconectar. No [Link]
SignalR, SignalR tentará reconectar-se ao servidor se a conexão for interrompida.

Suporte de protocolo
SignalR do [Link] Core dá suporte a JSON, bem como um novo protocolo binário, com base
em MessagePack. Além disso, os protocolos personalizados podem ser criados.

Transportes
Não há suporte para o transporte de quadro para sempre SignalR do [Link] Core.

Página 81 de SignalR para [Link] Core

Não há suporte para o transporte de quadro para sempre SignalR do [Link] Core.

Diferenças no servidor
As bibliotecas do lado do servidor SignalR do [Link] Core são incluídas na metapacote do
Microsoft que faz parte do pacote a aplicativo Web [Link] Core modelo Razor e MVC projetos.
SignalR do [Link] Core é um middleware do [Link] Core, portanto, ele deve ser configurado por
meio da chamada AddSignalRem [Link].

C#Copiar
[Link]()
Para configurar o roteamento, mapear as rotas para os hubs de dentro de UseSignalR chamada de
método no [Link]étodo.

C#Copiar
[Link](routes =>
{
[Link]<ChatHub>("/hub");
});

Sessões temporárias
O modelo de expansão do SignalR do [Link] permite que os clientes para se reconectar e enviar
mensagens para qualquer servidor no farm. No SignalR do [Link] Core, o cliente deve interagir
com o mesmo servidor durante a conexão. Para escala horizontal usando Redis, isso significa que as
sessões temporárias são necessárias. Para o uso de expansão serviço do Azure SignalR, sessões
temporárias não são necessárias porque o serviço lida com as conexões aos clientes.

Hub único por conexão

O SignalR do [Link] Core, o modelo de conexão foi simplificado. As conexões são feitas
diretamente a um único hub, em vez de uma única conexão está sendo usado para compartilhar o
acesso a vários hubs.

Streaming
[Link] SignalR Core agora dá suporte à dados de streaming do hub para o cliente.

Estado
A capacidade de passar o estado arbitrário entre clientes e o hub (geralmente chamado de
HubState) foi removida, bem como suporte para mensagens de progresso. Não há nenhum
equivalente de proxies de hub no momento.

Remoção de PersistentConnection
No SignalR do [Link] Core, o PersistentConnection classe foi removida.

GlobalHost
O [Link] Core tem dentro da estrutura de injeção de dependência (DI). Serviços podem usar a DI

Página 82 de SignalR para [Link] Core

O [Link] Core tem dentro da estrutura de injeção de dependência (DI). Serviços podem usar a DI
para acessar o HubContext. O GlobalHost objeto que é usado no [Link] SignalR para obter
um HubContext não existe no SignalR do [Link] Core.

HubPipeline
SignalR do [Link] Core não tem suporte para HubPipeline módulos.

Diferenças no cliente

TypeScript
O cliente SignalR do [Link] Core é escrito em TypeScript. Você pode escrever em JavaScript ou
TypeScript ao usar o cliente JavaScript.

O cliente JavaScript é hospedado em npm

Nas versões anteriores, o cliente JavaScript foi obtido por meio de um pacote do NuGet no Visual
Studio. Para as versões de núcleo, o @aspnet/signalr pacote npm contém as bibliotecas de
JavaScript. Este pacote não está incluído na aplicativo Web [Link] Coremodelo. Usar npm para
obter e instalar o @aspnet/signalr pacote npm.

consoleCopiar
npm init -y
npm install @aspnet/signalr

jQuery
A dependência no jQuery foi removida, no entanto, projetos ainda podem usar jQuery.

Suporte do Internet Explorer

SignalR do [Link] Core requer o Microsoft Internet Explorer 11 ou posterior (o SignalR do [Link]
com suporte Microsoft Internet Explorer 8 e posterior).

Sintaxe de método de cliente JavaScript

A sintaxe de JavaScript foi alterado da versão anterior do SignalR. Em vez de usar o $connection de
objeto, criar uma conexão usando o HubConnectionBuilder API.

JavaScriptCopiar
const connection = new [Link]()
.withUrl("/hub")
.build();
Use o em método para especificar que o hub pode chamar métodos do cliente.

JavaScriptCopiar
[Link]("ReceiveMessage", (user, message) => {
const msg = [Link](/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
const encodedMsg = user + " says " + msg;
log(encodedMsg);

Página 83 de SignalR para [Link] Core

 log(encodedMsg);
});
Depois de criar o método do cliente, inicie a conexão de hub. Cadeia de um catch método para fazer
logon ou lidar com erros.

JavaScriptCopiar
[Link]().catch(err => [Link]([Link]()));

Proxies de Hub
Os proxies de Hub não automaticamente são gerados. Em vez disso, o nome do método é passado
para o invocar API como uma cadeia de caracteres.

.NET e outros clientes

O [Link] pacote NuGet contém as bibliotecas de cliente .NET para o
SignalR do [Link] Core.
Use o HubConnectionBuilder para criar e compilar uma instância de uma conexão a um hub.

C#Copiar
connection = new HubConnectionBuilder()
.WithUrl("url")
.Build();

Diferenças de expansão
SignalR do [Link] oferece suporte a SQL Server e o Redis. SignalR do [Link] Core dá suporte ao
serviço do Azure SignalR e Redis.

[Link]
• Expansão do SignalR com o barramento de serviço do Azure
• Expansão do SignalR com Redis
• Expansão do SignalR com o SQL Server

[Link] Core
• Serviço Azure SignalR
• Backplane de redis

Recursos adicionais
• Hubs
• Cliente JavaScript
• Cliente .NET
• Plataformas compatíveis

Comentários
De <[Link]

Página 84 de SignalR para [Link] Core

 Suporte ao WebSockets no [Link] Core

• 09/05/2019
• 7 minutos para ler

Por Tom Dykstra e Andrew Stanton-Nurse

Este artigo explica como começar a usar o WebSockets no [Link] Core. WebSocket (RFC 6455) é
um protocolo que permite canais de comunicação persistentes bidirecionais em conexões TCP. Ele é
usado em aplicativos que se beneficiam de comunicação rápida e em tempo real, como chat, painel
e aplicativos de jogos.
Exibir ou baixar um código de exemplo (como baixar). Como executar.

SignalR
SignalR do [Link] Core é uma biblioteca que simplifica a adição da funcionalidade da Web em
tempo real aos aplicativos. Ele usa WebSockets sempre que possível.
Para a maioria dos aplicativos, recomendamos o SignalR sobre WebSockets brutos. O SignalR
fornece o fallback de transporte para os ambientes em que o WebSocket não está disponível. Ele
também fornece um modelo de aplicativo de chamada de procedimento remoto simples. E, na
maioria dos cenários, o SignalR não tem nenhuma desvantagem de desempenho significativa em
comparação ao uso de WebSockets brutos.

Pré-requisitos
• [Link] Core 1.1 ou posterior
• Qualquer sistema operacional compatível com o [Link] Core:
• Windows 7/Windows Server 2008 ou posterior
• Linux
• macOS
• Se o aplicativo é executado no Windows com o IIS:
• Windows 8/Windows Server 2012 ou posterior
• IIS 8/IIS 8 Express
• WebSockets precisam ser habilitados (confira a seção Suporte para IIS/IIS Express).
• Se o aplicativo é executado no [Link]:
• Windows 8/Windows Server 2012 ou posterior
• Para saber quais são os navegadores compatíveis, confira [Link]
#feat=websockets.

Configurar o middleware
Adicione o middleware do WebSockets no método Configure da classe Startup:

C#Copiar
[Link]();
As seguintes configurações podem ser definidas:
• KeepAliveInterval – a frequência para enviar quadros "ping" ao cliente para garantir que os
proxies mantenham a conexão aberta. O padrão é dois minutos.
• ReceiveBufferSize – o tamanho do buffer usado para receber dados. Os usuários avançados
podem precisar alterar isso para ajuste de desempenho com base no tamanho dos dados. O

Página 85 de SignalR para [Link] Core

 podem precisar alterar isso para ajuste de desempenho com base no tamanho dos dados. O
padrão é 4 KB.
• AllowedOrigins – Uma lista de valores de cabeçalho de origem permitidos para solicitações do
WebSocket. Por padrão, todas as origens são permitidas. Consulte "Restrição de origem do
WebSocket" abaixo para obter detalhes.

C#Copiar
var webSocketOptions = new WebSocketOptions()
{
KeepAliveInterval = [Link](120),
ReceiveBufferSize = 4 * 1024
};
[Link](webSocketOptions);

Aceitar solicitações do WebSocket

Futuramente no ciclo de vida da solicitação (mais tarde no método Configure ou em um método de
ação, por exemplo), verifique se é uma solicitação do WebSocket e aceite-a.
O exemplo a seguir é de uma fase posterior do método Configure:

C#Copiar

[Link](async (context, next) =>

{
if ([Link] == "/ws")
{
if ([Link])
{
WebSocket webSocket = await [Link]();
await Echo(context, webSocket);
}
else
{
[Link] = 400;
}
}
else
{
await next();
}
});
Uma solicitação do WebSocket pode entrar em qualquer URL, mas esse código de exemplo aceita
apenas solicitações de /ws.
Ao usar um WebSocket, você deve manter o pipeline de middleware em execução durante a
conexão. Se tentar enviar ou receber uma mensagem do WebSocket após o término do pipeline de
middleware, você poderá receber uma exceção semelhante à seguinte:

Copiar
[Link] (0x80004005): The remote party closed the WebSocket
connection without completing the close handshake. ---> [Link]: Cannot write to
the response body, the response has completed.
Object name: 'HttpResponseStream'.
Se você estiver usando um serviço em segundo plano para gravar dados em um WebSocket,
mantenha o pipeline do middleware em execução. Faça isso usando
um TaskCompletionSource<TResult>. Passe o TaskCompletionSource ao seu serviço em segundo plano
e faça-o chamar TrySetResult quando terminar com o WebSocket. Em seguida await a
propriedade Task durante a solicitação, conforme é mostrado no exemplo a seguir:

C#Copiar
[Link](async (context, next) => {

Página 86 de SignalR para [Link] Core

[Link](async (context, next) => {
var socket = await [Link]();
var socketFinishedTcs = new TaskCompletionSource<object>();
[Link](socket, socketFinishedTcs);
await [Link];
});
A exceção fechada do WebSocket também poderá ocorrer se você retornar muito rapidamente de
um método de ação. Se você aceitar um soquete de um método de ação, aguarde até que o código
que usa o soquete seja concluído antes de retornar do método de ação.
Nunca use [Link](), [Link] ou chamadas de bloqueio semelhantes para aguardar a conclusão
do soquete, pois isso pode causar sérios problemas de threading. Sempre use await.

Enviar e receber mensagens

O método AcceptWebSocketAsync atualiza a conexão TCP para uma conexão WebSocket e fornece
um objeto WebSocket. Use o objeto WebSocket para enviar e receber mensagens.
O código mostrado anteriormente que aceita a solicitação do WebSocket passa o
objeto WebSocket para um método Echo. O código recebe uma mensagem e envia de volta
imediatamente a mesma mensagem. As mensagens são enviadas e recebidas em um loop até que o
cliente feche a conexão:

C#Copiar
private async Task Echo(HttpContext context, WebSocket webSocket)
{
var buffer = new byte[1024 * 4];
WebSocketReceiveResult result = await [Link](new ArraySegment<byte>(buffer),
[Link]);
while (![Link])
{
await [Link](new ArraySegment<byte>(buffer, 0, [Link]), [Link],
[Link], [Link]);
result = await [Link](new ArraySegment<byte>(buffer), [Link]);
}
await [Link]([Link], [Link],
[Link]);
}
Ao aceitar a conexão WebSocket antes de iniciar o loop, o pipeline de middleware é encerrado. Ao
fechar o soquete, o pipeline é desenrolado. Ou seja, a solicitação deixa de avançar no pipeline
quando o WebSocket é aceito. Quando o loop é concluído e o soquete é fechado, a solicitação
continua a avançar no pipeline.

Tratar desconexões de cliente

O servidor não é informado automaticamente quando o cliente se desconecta devido à perda de
conectividade. O servidor recebe uma mensagem de desconexão apenas quando o cliente a envia, e
isso é possível somente quando há conexão com a Internet. Se quiser tomar alguma medida quando
isso ocorrer, defina um tempo limite, caso não receba nada do cliente após uma determinada janela
de tempo.
Se o cliente não envia mensagens com frequência, e você prefere não definir um tempo limite
apenas porque a conexão fica ociosa, peça ao cliente para usar um temporizador a fim de enviar
uma mensagem de ping a cada X segundos. No servidor, se uma mensagem não chegar dentro de 2
*X segundos após a mensagem anterior, encerre a conexão e informe que o cliente se
desconectou. Aguarde o dobro do intervalo de tempo esperado a fim de deixar um tempo extra para
atrasos na rede, que possam atrasar a mensagem de ping.

Restrição de origem do WebSocket

Página 87 de SignalR para [Link] Core
Restrição de origem do WebSocket
As proteções fornecidas pelo CORS não se aplicam ao WebSockets. Navegadores não:
• Executam solicitações de simulação de CORS.
• Respeitam as restrições especificadas em cabeçalhos Access-Control ao fazer solicitações de
WebSocket.
No entanto, os navegadores enviam o cabeçalho Origin ao emitir solicitações de WebSocket. Os
aplicativos devem ser configurados para validar esses cabeçalhos e garantir que apenas WebSockets
provenientes de origens esperadas sejam permitidos.
Se você estiver hospedando o servidor em "[Link] e hospedando seu cliente em
"[Link] adicione "[Link] à lista AllowedOrigins para o WebSockets verificar.

C#Copiar

var webSocketOptions = new WebSocketOptions()

{
KeepAliveInterval = [Link](120),
ReceiveBufferSize = 4 * 1024
};
[Link]("[Link]
[Link]("[Link]
[Link](webSocketOptions);
Observação
O cabeçalho Origin é controlado pelo cliente e, como o cabeçalho Referer, pode ser
falsificado. Não use esses cabeçalhos como um mecanismo de autenticação.

Suporte ao IIS/IIS Express

O Windows Server 2012 ou posterior e o Windows 8 ou posterior com o IIS/IIS Express 8 ou
posterior são compatíveis com o protocolo WebSocket.
Observação
WebSockets estão sempre habilitados ao usar o IIS Express.

Habilitar WebSockets no IIS

Para habilitar o suporte para o protocolo WebSocket no Windows Server 2012 ou posterior:
Observação
Estas etapas não são necessárias ao usar o IIS Express
1. Use o assistente Adicionar Funções e Recursos por meio do menu Gerenciar ou do link
no Gerenciador do Servidor.
2. Selecione Instalação baseada em função ou em recurso. Selecione Avançar.
3. Selecione o servidor apropriado (o servidor local é selecionado por
padrão). Selecione Avançar.
4. Expanda Servidor Web (IIS) na árvore Funções, expanda Servidor Web e, em seguida,
expanda Desenvolvimento de Aplicativos.
5. Selecione o Protocolo WebSocket. Selecione Avançar.
6. Se não forem necessários recursos adicionais, selecione Avançar.
7. Clique em Instalar.
8. Quando a instalação for concluída, selecione Fechar para sair do assistente.
Para habilitar o suporte para o protocolo WebSocket no Windows 8 ou posterior:
Observação
Estas etapas não são necessárias ao usar o IIS Express
1. Navegue para Painel de Controle > Programas > Programas e Recursos > Ativar ou desativar
recursos do Windows (lado esquerdo da tela).
2. Abra os seguintes nós: Serviços de Informações da Internet > Serviços da World Wide
Web > Recursos de Desenvolvimento de Aplicativos.

Página 88 de SignalR para [Link] Core

 Web > Recursos de Desenvolvimento de Aplicativos.
3. Selecione o recurso Protocolo WebSocket. Selecione OK.

Desabilite o WebSocket ao usar o [Link] no [Link]

Se você estiver usando o suporte do WebSocket no [Link] no [Link], desabilite o módulo do
WebSocket do IIS padrão usando o elemento webSocket em [Link] ou
em [Link]. Se essa etapa não for executada, o módulo do WebSocket do IIS tentará
manipular a comunicação do WebSocket em vez do [Link] e o aplicativo.

XMLCopiar
<[Link]>
<webSocket enabled="false" />
</[Link]>

Aplicativo de exemplo
O aplicativo de exemplo que acompanha este artigo é um aplicativo de eco. Ele tem uma página da
Web que faz conexões WebSocket e o servidor reenvia para o cliente todas as mensagens
recebidas. Execute o aplicativo em um prompt de comando (ele não está configurado para execução
no Visual Studio com o IIS Express) e navegue para [Link] A página da Web exibe o
status de conexão no canto superior esquerdo:

Selecione Conectar para enviar uma solicitação WebSocket para a URL exibida. Insira uma
mensagem de teste e selecione [Link] terminar, selecione Fechar Soquete. A seção Log de
Comunicação relata cada ação de abertura, envio e fechamento conforme ela ocorre.

Página 89 de SignalR para [Link] Core

Comentários
De <[Link]

Página 90 de SignalR para [Link] Core

 Registro em log e diagnóstico no SignalR do [Link] Core

• 18/06/2019
• 7 minutos para ler

Por Andrew Stanton-Nurse

Este artigo fornece orientações para reunir diagnósticos de seu aplicativo SignalR do [Link] Core
para ajudar a solucionar problemas.

Registro em log do lado do servidor

Aviso
Logs do lado do servidor podem conter informações confidenciais de seu aplicativo. Nunca postar
logs brutos de aplicativos de produção em fóruns públicos, como o GitHub.
Como o SignalR é parte do [Link] Core, ele usa o sistema de registro do [Link] Core. Na
configuração padrão, SignalR registra informações muito pouco, mas isso pode
configurado. Consulte a documentação sobre registro do [Link] Core para obter detalhes sobre
como configurar o registro do [Link] Core.
O SignalR usa duas categorias de agente:
• [Link] – para logs relacionados aos protocolos de Hub, ativando Hubs,
invocar os métodos e outras atividades relacionadas ao Hub.
• [Link] – para os logs relacionados a transportes, como
WebSockets, sondagem longa e eventos do Server-sent e infraestrutura de baixo nível SignalR.
Para habilitar logs detalhados do SignalR, configure ambos os prefixos anteriores para o Debug nível
em seu appSettings. JSONarquivo adicionando itens a seguir para o LogLevel na seção Logging:

JSONCopiar

{
"Logging": {
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information",
"[Link]": "Debug",
"[Link]": "Debug"
}
}
}
Você também pode configurar isso no código em seu CreateWebHostBuilder método:

C#Copiar

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

[Link](args)
.ConfigureLogging(logging =>
{
[Link]("[Link]", [Link]);
[Link]("[Link]", [Link]);
})
.UseStartup<Startup>();
Se você não estiver usando a configuração baseada em JSON, defina os seguintes valores de
configuração no seu sistema de configuração:

Página 91 de SignalR para [Link] Core

configuração no seu sistema de configuração:
• Logging:LogLevel:[Link] = Debug
• Logging:LogLevel:[Link] = Debug
Verifique a documentação para o seu sistema de configuração determinar como especificar valores
de configuração aninhada. Por exemplo, ao usar variáveis de ambiente, duas _ os caracteres são
usados em vez do : (por exemplo, Logging__LogLevel__Microsoft.[Link]).
É recomendável usar o Debug nível ao reunir mais detalhadas de diagnóstico para seu
aplicativo. O Trace nível produz diagnósticos de nível muito baixo e raramente é necessária para
diagnosticar problemas em seu aplicativo.

Logs do lado do servidor de acesso

Como você pode acessar os logs do lado do servidor depende do ambiente no qual você está
executando.

Como um aplicativo de console fora do IIS

Se você estiver executando em um aplicativo de console, o agente de Console deve ser habilitado
por padrão. Logs do SignalR serão exibidos no console.

Dentro do IIS Express do Visual Studio

O Visual Studio exibe a saída de log na saída janela. Selecione o servidor de Web do [Link]
Core lista suspensa da opção.

Serviço de Aplicativo do Azure

Habilitar o log de aplicativo (Filesystem) opção a logs de diagnóstico seção do portal do serviço de
aplicativo do Azure e configurar o nível para Verbose. Logs devem estar disponíveis a partir
de streaming de Log serviço e nos logs no sistema de arquivos do serviço de aplicativo. Para obter
mais informações, consulte streaming de log do Azure.

Outros ambientes
Se o aplicativo for implantado em outro ambiente (por exemplo, Docker, Kubernetes ou serviço do
Windows), consulte Como fazer registro em log no .NET Core e no [Link] Core para obter mais
informações sobre como configurar provedores de log adequados para o ambiente.

Log de cliente JavaScript

Aviso
Logs do lado do cliente podem conter informações confidenciais de seu aplicativo. Nunca postar logs
brutos de aplicativos de produção em fóruns públicos, como o GitHub.
Ao usar o cliente JavaScript, você pode configurar opções de registro em log usando
o configureLogging método no HubConnectionBuilder:

JavaScriptCopiar

let connection = new [Link]()

.withUrl("/my/hub/url")
.configureLogging([Link])
.build();

Página 92 de SignalR para [Link] Core

 .build();
Para desabilitar o registro em log totalmente,
especifique [Link] no configureLogging método.
A tabela a seguir mostra os níveis de log disponíveis para o cliente JavaScript. Definindo o nível de
log para um desses valores permite o log no nível e todos os níveis acima na tabela.
Nível Descrição
None Nenhuma mensagem será registrada.
Critical Mensagens que indicam uma falha em todo o aplicativo.
Error Mensagens que indicam uma falha na operação atual.
Warning Mensagens que indicam um problema de não-fatais.
Informatio Mensagens informativas.
n
Debug Mensagens de diagnóstico útil para depuração.
Trace Mensagens de diagnóstico muito detalhadas projetadas para diagnosticar problemas
específicos.
Depois de configurar o detalhamento, os logs serão gravados para o Console do navegador (ou a
saída padrão em um aplicativo NodeJS).
Se você quiser enviar logs para um sistema de registro em log personalizado, você pode fornecer um
objeto JavaScript que implementa o ILogger interface. O único método que precisa ser
implementado é log, que usa o nível do evento e a mensagem associada ao evento. Por exemplo:

TypeScriptCopiar

import { ILogger, LogLevel, HubConnectionBuilder } from "@aspnet/signalr";

export class MyLogger implements ILogger {
log(logLevel: LogLevel, message: string) {
// Use `message` and `logLevel` to record the log message to your own system
}
}
// later on, when configuring your connection...
let connection = new HubConnectionBuilder()
.withUrl("/my/hub/url")
.configureLogging(new MyLogger())
.build();

Log de cliente .NET

Aviso
Logs do lado do cliente podem conter informações confidenciais de seu aplicativo. Nunca postar logs
brutos de aplicativos de produção em fóruns públicos, como o GitHub.
Para obter os logs do cliente .NET, você pode usar o ConfigureLogging método
no HubConnectionBuilder. Isso funciona da mesma forma que o ConfigureLogging método
no WebHostBuilder e HostBuilder. Você pode configurar os mesmos provedores de log que você usar
no [Link] Core. No entanto, você precisa instalar e habilitar os pacotes do NuGet para os
provedores de log individuais manualmente.

Log de console
Para habilitar o log de Console, adicione a [Link] pacote. Em seguida,
use o AddConsole método para configurar o agente de console:

C#Copiar

var connection = new HubConnectionBuilder()

.WithUrl("[Link]
.ConfigureLogging(logging =>

Página 93 de SignalR para [Link] Core

 .ConfigureLogging(logging =>
{
// Log to the Console
[Link]();
// This will set ALL logging to Debug level
[Link]([Link]);
})
.Build();

O log de janela de saída de depuração

Você também pode configurar logs para ir para o saída janela no Visual Studio. Instalar
o [Link] de pacote e usar o AddDebug método:

C#Copiar

var connection = new HubConnectionBuilder()

.WithUrl("[Link]
.ConfigureLogging(logging =>
{
// Log to the Output Window
[Link]();
// This will set ALL logging to Debug level
[Link]([Link])
})
.Build();

Outros provedores de log

O SignalR dá suporte a outros provedores de log como Serilog, Seq, NLog ou qualquer outro sistema
de registro em log que se integra ao [Link]. Se o seu sistema de log fornece
um ILoggerProvider, você pode registrá-lo com AddProvider:

C#Copiar

var connection = new HubConnectionBuilder()

.WithUrl("[Link]
.ConfigureLogging(logging =>
{
// Log to your custom provider
[Link](new MyCustomLoggingProvider());
// This will set ALL logging to Debug level
[Link]([Link])
})
.Build();

Nível de detalhes de controle

Se você está fazendo logon de outros locais em seu aplicativo, alterando o nível padrão
a Debug pode ser muito detalhado. Você pode usar um filtro para configurar o nível de log para logs
do SignalR. Isso pode ser feito no código, em grande parte da mesma maneira que no servidor:

C#Copiar

var connection = new HubConnectionBuilder()

.WithUrl("[Link]
.ConfigureLogging(logging =>
{

Página 94 de SignalR para [Link] Core

 {
// Register your providers
// Set the default log level to Information, but to Debug for SignalR-related loggers.
[Link]([Link]);
[Link]("[Link]", [Link]);
[Link]("[Link]", [Link]);
})
.Build();

Rastreamentos de rede
Aviso
Um rastreamento de rede contém todo o conteúdo de cada mensagem enviada pelo
aplicativo. Nunca postar rastreamentos de rede brutos de aplicativos de produção em fóruns
públicos, como o GitHub.
Se você encontrar um problema, um rastreamento de rede, às vezes, pode fornecer várias
informações úteis. Isso é particularmente útil se você pretender arquivar um problema no nosso
rastreador de problemas.

Coletar um rastreamento de rede com o Fiddler (opção

preferencial)
Esse método funciona para todos os aplicativos.
O Fiddler é uma ferramenta muito poderosa para coletar rastreamentos HTTP. Instale-o
em [Link]/fiddler, iniciá-lo e, em seguida, execute o aplicativo e reproduza o problema. O
Fiddler está disponível para Windows, e há versões beta para macOS e Linux.
Se você se conectar usando HTTPS, há algumas etapas adicionais para garantir que o Fiddler pode
descriptografar o tráfego [Link] obter mais detalhes, consulte o documentação do Fiddler.
Depois de coletar o rastreamento, você pode exportar o rastreamento,
escolhendo arquivo > salvar > todas as sessões na barra de menus.

Coletar um rastreamento de rede com tcpdump (macOS e

Linux somente)
Esse método funciona para todos os aplicativos.
Você pode coletar rastreamentos TCP brutos usando tcpdump, executando o seguinte comando em

Página 95 de SignalR para [Link] Core

Você pode coletar rastreamentos TCP brutos usando tcpdump, executando o seguinte comando em
um shell de comando. Você talvez precise ser root ou prefixar o comando com sudo se você receber
um erro de permissões:

consoleCopiar
tcpdump -i [interface] -w [Link]
Substitua [interface] com a interface de rede que você deseja capturar no. Geralmente, isso é algo
como /dev/eth0 (para sua interface Ethernet padrão) ou /dev/lo0 (para tráfego de localhost). Para
obter mais informações, consulte o tcpdump página do manual no sistema de host.

Coletar um rastreamento de rede no navegador

Esse método só funciona para aplicativos baseados em navegador.
A maioria das ferramentas de desenvolvedor do navegador tem uma guia de "Rede" que permite
que você capture a atividade de rede entre o navegador e o servidor. No entanto, esses
rastreamentos não incluem o WebSocket e Server-Sent mensagens de evento. Se você estiver
usando esses transportes, usando uma ferramenta como o Fiddler ou TcpDump (descritos abaixo) é
uma abordagem melhor.

Internet Explorer e Microsoft Edge

(As instruções são as mesmas para o Edge e Internet Explorer)
1. Pressione F12 para abrir as ferramentas de desenvolvimento
2. Clique na guia rede
3. Atualize a página (se necessário) e reproduzir o problema
4. Clique no ícone Salvar na barra de ferramentas para exportar o rastreamento como um
arquivo de "HAR":

Google Chrome
1. Pressione F12 para abrir as ferramentas de desenvolvimento
2. Clique na guia rede
3. Atualize a página (se necessário) e reproduzir o problema
4. Clique com botão direito em qualquer lugar na lista de solicitações e escolha "Salvar como
HAR com conteúdo":

Página 96 de SignalR para [Link] Core

Mozilla Firefox
1. Pressione F12 para abrir as ferramentas de desenvolvimento
2. Clique na guia rede
3. Atualize a página (se necessário) e reproduzir o problema
4. Clique com botão direito em qualquer lugar na lista de solicitações e escolha "Salvar todos os
como HAR"

Anexar arquivos de diagnóstico de problemas do GitHub

Você pode anexar arquivos de diagnóstico para problemas do GitHub ao renomeá-las para que eles
tenham um .txt extensão arrastando e soltando-os para o problema.
Observação
Não cole o conteúdo de arquivos de log ou de rastreamentos de rede em um problema do
GitHub. Esses logs e rastreamentos podem ser muito grandes e GitHub geralmente trunca-los.

Página 97 de SignalR para [Link] Core

Recursos adicionais
• Configuração do Signalr [Link] Core
• Cliente JavaScript do Signalr [Link] Core
• Cliente de .NET do SignalR do [Link] Core

Comentários
De <[Link]

Página 98 de SignalR para [Link] Core