Hubs fortemente tipados
Defina interfaces de hub tipadas para obter segurança em tempo de compilação e IntelliSense nas chamadas de métodos do cliente.
Hubs fortemente tipados é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.
O problema dos nomes de métodos em cadeias de caracteres
As chamadas padrão do SignalR usam SendAsync("MethodName", ...) com cadeias de caracteres mágicas. Uma digitação incorreta no nome do método causa uma falha silenciosa — o cliente simplesmente nunca recebe a mensagem. Os hubs fortemente tipados resolvem isso.
Definição da interface do cliente
Crie uma interface que declare todos os métodos que o servidor pode invocar no cliente. Os nomes dos métodos e os tipos dos parâmetros formam o seu contrato.
// INotificationClient.cs
public interface INotificationClient
{
Task ReceiveMessage(string user, string message);
Task OrderShipped(int orderId, string trackingNumber);
Task UserJoined(string username);
Task UserLeft(string username);
Task SystemAlert(string message);
}Criação de um hub fortemente tipado
Herda de Hub<T>, em que T é a sua interface do cliente. A propriedade Clients agora é tipada — o IntelliSense mostra os métodos disponíveis, e erros de digitação são erros de compilação.
public class ChatHub : Hub<INotificationClient>
{
public async Task SendMessage(string message)
{
var user = Context.User!.Identity!.Name ?? "Anonymous";
// Compile-time safety — no magic strings!
await Clients.All.ReceiveMessage(user, message);
await Clients.Others.UserJoined(user); // IntelliSense works
}
}Direcionamento de clientes específicos com um hub tipado
Todos os métodos padrão de direcionamento funcionam no hub tipado: Clients.User, Clients.Group, Clients.Caller, Clients.Client — todos retornando a interface tipada.
public async Task NotifyOrderShipped(int orderId, string customerId)
{
await Clients.User(customerId)
.OrderShipped(orderId, "TRK-12345");
await Clients.Group("admins")
.SystemAlert($"Order {orderId} shipped to {customerId}");
await Clients.Caller.ReceiveMessage("System", "Notification sent");
}IHubContext tipado
Injete IHubContext<THub, TClient> nos serviços para obter a mesma segurança em tempo de compilação ao enviar mensagens de fora do hub.
public class ShipmentService
{
private readonly IHubContext<ChatHub, INotificationClient> _hub;
public ShipmentService(
IHubContext<ChatHub, INotificationClient> hub) => _hub = hub;
public async Task ProcessShipmentAsync(int orderId, string customerId)
{
// Fully typed — no magic strings
await _hub.Clients.User(customerId)
.OrderShipped(orderId, "TRK-99999");
}
}Regras da interface do cliente
Os métodos da interface do cliente devem retornar Task (não Task<T>). O SignalR dispara as invocações do cliente sem aguardar o resultado — não há valor de retorno do cliente para o servidor.
// CORRECT
public interface IMyClient
{
Task ReceiveMessage(string msg); // OK
Task UpdateProgress(int percent); // OK
Task<string> GetUserInput(); // NOT SUPPORTED
}
// Return types other than Task are not supported in hub client interfaces
// For request-response patterns, use client-callable hub methods insteadCombinação de hubs tipados com grupos
Os grupos tipados funcionam da mesma forma que os não tipados — a API é a mesma, apenas com nomes de métodos verificados em tempo de compilação.
public class RoomHub : Hub<IRoomClient>
{
public async Task JoinRoom(string room)
{
await Groups.AddToGroupAsync(Context.ConnectionId, room);
await Clients.Group(room).UserJoined(Context.User!.Identity!.Name!);
}
public async Task BroadcastToRoom(string room, string message)
{
var user = Context.User!.Identity!.Name!;
await Clients.Group(room).ReceiveMessage(user, message);
}
}Testando hubs fortemente tipados
Como as chamadas aos métodos do cliente passam por uma interface, você pode simular o cliente em testes unitários para verificar se os métodos corretos foram chamados com os argumentos certos.
// NSubstitute test
var mockClients = Substitute.For<IHubCallerClients<INotificationClient>>();
var mockAllClients = Substitute.For<INotificationClient>();
mockClients.All.Returns(mockAllClients);
var hub = new ChatHub { Clients = mockClients };
await hub.SendMessage("Hello!");
await mockAllClients.Received(1).ReceiveMessage("System", "Hello!");Vários hubs por aplicação
Uma aplicação pode ter vários endpoints de hub para diferentes recursos em tempo real, cada um com sua própria interface de cliente tipada.
// Three separate hubs
app.MapHub<ChatHub>("/hubs/chat");
app.MapHub<NotificationHub>("/hubs/notifications");
app.MapHub<DashboardHub>("/hubs/dashboard");
// Each with its own client interface:
// Hub<IChatClient>, Hub<INotificationClient>, Hub<IDashboardClient>Enviando dados estruturados
Os métodos da interface do cliente podem aceitar DTOs complexos. O SignalR os serializa automaticamente em JSON — certifique-se de que seus tipos possam ser serializados.
public interface IOrderClient
{
Task OrderUpdated(OrderStatusDto status);
}
public record OrderStatusDto(
int OrderId,
string Status,
decimal Total,
DateTime UpdatedAt);
// Usage in hub:
await Clients.User(customerId).OrderUpdated(
new OrderStatusDto(order.Id, order.Status.ToString(),
order.Total, DateTime.UtcNow));Verificação rápida
Qual é a restrição do tipo de retorno para os métodos em uma interface de cliente de hub do SignalR?
Recapitulação: hubs fortemente tipados
Principais conclusões:
- Defina uma interface (IMyClient) listando todos os métodos que o servidor pode chamar nos clientes
- Herda de
Hub<IMyClient>— a propriedade Clients torna-se totalmente tipada - Injete
IHubContext<THub, TClient>para fazer envios tipados de fora do hub - Os métodos da interface do cliente devem retornar
Task, nãoTask<T> - Clientes baseados em interfaces podem ser simulados — hubs fortemente tipados são mais fáceis de testar
Perguntas Frequentes
A aula “Hubs fortemente tipados” é grátis?
Sim — o texto completo de “Hubs fortemente tipados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.
O que vou aprender em “Hubs fortemente tipados”?
Defina interfaces de hub tipadas para obter segurança em tempo de compilação e IntelliSense nas chamadas de métodos do cliente. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C# Academy?
Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Hubs fortemente tipados”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C# Academy?
Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Hubs e conexões do SignalR
- Grupos, usuários e gerenciamento de conexões
- Hubs fortemente tipados
- Escalonamento com Redis Backplane