Compartilhar via

Cliente do ASP.NET Core SignalR Swift

SignalR Swift é uma biblioteca de clientes para se conectar a servidores SignalR de aplicativos Swift. Este documento fornece uma visão geral de como instalar o cliente, estabelecer uma conexão, manipular chamadas de servidor para cliente, invocar métodos de servidor, trabalhar com respostas de streaming e configurar a reconexão automática e outras opções.

Instalar o SignalR pacote do cliente

A SignalR biblioteca de clientes Swift é entregue como um pacote Swift. Você pode adicioná-lo ao seu projeto usando o Gerenciador de Pacotes Swift.

Requisitos

  • Swift >= 5,10
  • macOS >= 11,0
  • iOS >= 14

Instalar com o Gerenciador de Pacotes Swift

Adicione o SignalR pacote Swift como uma dependência em seu Package.swift arquivo:

// swift-tools-version: 5.10
import PackageDescription

let package = Package(
    name: "signalr-client-app",
    dependencies: [
        .package(url: "https://github.com/dotnet/signalr-client-swift", branch: "main")
    ],
    targets: [
        .executableTarget(name: "YourTargetName", dependencies: [.product(name: "SignalRClient", package: "signalr-client-swift")])
    ]
)

Depois de adicionar a dependência, importe a biblioteca em seu código Swift:

import SignalRClient

Conectar-se a um hub

Para estabelecer uma conexão, crie uma HubConnectionBuilder e configure-a com a URL do servidor SignalR usando o withUrl() método. Depois que a conexão for criada, chame start() para se conectar ao servidor:

import SignalRClient

let connection = HubConnectionBuilder()
    .withUrl(url: "https://your-signalr-server")
    .build()

try await connection.start()

Chamar métodos de cliente do hub

Para receber mensagens do servidor, registre um manipulador usando o on método. O método on usa o nome do método hub e um fechamento que será executado quando o servidor chamar esse método.

No seguinte, o nome do método é ReceiveMessage. Os nomes dos argumentos sãouser:message

await connection.on("ReceiveMessage") { (user: String, message: String) in
    print("\(user) says: \(message)")
}

O código anterior em connection.on executa quando o código do lado do servidor o chama usando o método SendAsync:

using Microsoft.AspNetCore.SignalR;
namespace SignalRChat.Hubs;

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

SignalR determina qual método de cliente chamar, combinando o nome do método e os argumentos definidos em SendAsync e connection.on.

Uma prática recomendada é chamar o try await connection.start() método no HubConnection depois de on. Isso garante que os manipuladores sejam registrados antes que as mensagens sejam recebidas.

Chamar métodos de hub do cliente

Os clientes Swift podem invocar métodos de hub no servidor usando os métodos invoke ou send do HubConnection. O invoke método aguarda a resposta do servidor e gerará um erro se a chamada falhar, enquanto o send método não aguarda uma resposta.

No código a seguir, o nome do método no hub é SendMessage. O segundo e o terceiro argumentos passados para o invoke mapear os argumentos user e message do método de hub:

// Using invoke, which waits for a response
try await connection.invoke(method: "SendMessage", arguments: "myUser", "Hello")

// Using send, which does not wait for a response
try await connection.send(method: "SendMessage", arguments: "myUser", "Hello")

O invoke método retorna com o valor retornado (se houver) quando o método no servidor retorna. Se o método no servidor gerar um erro, a função gerará um erro.

Registro em log

A biblioteca cliente do Swift inclui um sistema de logs leve projetado para aplicativos Swift. Ele fornece uma maneira estruturada de registrar mensagens em diferentes níveis de gravidade usando um manipulador de log personalizável. Nas plataformas da Apple, ele utiliza os.Logger para registro de log eficiente do sistema, enquanto reverte para a saída padrão do console em outras plataformas.

Nível de log

Use HubConnectionBuilder().withLogLevel(LogLevel:) para definir o nível de log. As mensagens são registradas com o nível de log especificado e superior:

  • LogLevel.debug: informações detalhadas úteis para depuração.
  • LogLevel.information: mensagens gerais do aplicativo.
  • LogLevel.warning: avisos sobre possíveis problemas.
  • LogLevel.error: erros que precisam de atenção imediata.

Resultados de clientes

Além de invocar métodos de servidor, o servidor pode chamar métodos no cliente e aguardar uma resposta. Para oferecer esse suporte, defina um manipulador de cliente que retorna um resultado de seu fechamento:

await connection.on("ClientResult") { (message: String) in
    return "client response"
}

Por exemplo, o servidor pode invocar o ClientResult método no cliente e aguardar o valor retornado:

public class ChatHub : Hub
{
    public async Task TriggerClientResult()
    {
        var message = await Clients.Client(connectionId).InvokeAsync<string>("ClientResult");
    }
}

Trabalhar com respostas de transmissão

Para receber um fluxo de dados do servidor, use o stream método. O método retorna um fluxo que você pode iterar de forma assíncrona:

let streamResult: any StreamResult<String> = try await connection.stream(method: "StreamMethod")
for try await item in streamResult.stream {
    print("Received item: \(item)")
}

Gerenciar conexão perdida

Reconexão automática

O SignalR cliente Swift dá suporte à reconexão automática. Para habilitá-lo, chame withAutomaticReconnect() durante a criação da conexão. A reconexão automática é desabilitada por padrão.

let connection = HubConnectionBuilder()
    .withUrl(url: "https://your-signalr-server")
    .withAutomaticReconnect()
    .build()

Sem parâmetros, withAutomaticReconnect() configura o cliente para aguardar 0, 2, 10 e 30 segundos, respectivamente, antes de cada tentativa de reconexão. Após quatro tentativas com falha, o cliente para de tentar se reconectar.

Antes de iniciar qualquer tentativa de reconexão, o HubConnection transiciona para o estado Reconnecting e aciona seus retornos de chamada onReconnecting.

Depois que a reconexão for bem-sucedida, o HubConnection transiciona para o estado connected e dispara seus retornos de chamada onReconnected.

Uma maneira geral de usar onReconnecting e onReconnected é marcar as alterações de estado de conexão:

connection.onReconnecting { error in
    // connection is disconnected because of error
}

connection.onReconnected {
    // connection is connected back
}

Configurar estratégia na reconexão automática

Para personalizar o comportamento de reconexão, você pode passar uma matriz de números que representam o atraso em segundos antes de cada tentativa de reconexão. Para um controle mais granular, passe um objeto que esteja em conformidade com o protocolo RetryPolicy.

Usando uma matriz de valores de atraso

let connection = HubConnectionBuilder()
    .withUrl(url: "https://your-signalr-server")
    .withAutomaticReconnect([0, 0, 1]) // Wait 0, 0, and 1 second before each reconnect attempt; stop after 3 attempts.
    .build()

Usando uma política de repetição personalizada

Implemente o protocolo RetryPolicy para controlar o tempo de reconexão:

// Define a custom retry policy
struct CustomRetryPolicy: RetryPolicy {
    func nextRetryInterval(retryContext: RetryContext) -> TimeInterval? {
        // For example, retry every 1 second indefinitely.
        return 1
    }
}

let connection = HubConnectionBuilder()
    .withUrl(url: "https://your-signalr-server")
    .withAutomaticReconnect(CustomRetryPolicy())
    .build()

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

Você pode personalizar o tempo limite do cliente e manter as configurações ativas por meio do HubConnectionBuilder:

Opções Valor Padrão Descrição
withKeepAliveInterval 15 (segundos) Determina o intervalo no qual o cliente envia mensagens de ping e é definido diretamente no HubConnectionBuilder. Essa configuração permite que o servidor detecte desconexões físicas, como quando um cliente desconecta o computador da rede. Enviar qualquer mensagem do cliente reinicia o temporizador para o começo do intervalo. Se o cliente não tiver enviado uma mensagem no conjunto ClientTimeoutInterval no servidor, o servidor considerará o cliente desconectado.
withServerTimeout 30 (segundos) Determina o intervalo no qual o cliente aguarda uma resposta do servidor antes de considerar o servidor desconectado. Essa configuração é definida diretamente no HubConnectionBuilder.

Configurar o transporte

O SignalR cliente Swift dá suporte a três transportes: LongPolling, ServerSentEvents e WebSockets. Por padrão, o cliente usará WebSockets se o servidor der suporte a ele e retornará para ServerSentEvents e LongPolling se não o fizer. Você pode configurar o cliente para usar um transporte específico chamando withUrl(url:transport:) ao criar a conexão.

let connection = HubConnectionBuilder()
    .withUrl(url: "https://your-signalr-server", transport: .webSockets) // use websocket only
    .build()

let connection = HubConnectionBuilder()
    .withUrl(url: "https://your-signalr-server", transport: [.webSockets, .serverSentEvents]) // use websockets and server sent events
    .build()

Recursos adicionais

  • Last updated on