Udostępnij za pośrednictwem

Wysyłanie komunikatów spoza centrum

  • Artykuł

Piasta to podstawowa SignalR abstrakcja wysyłania komunikatów do klientów połączonych z serwerem SignalR . Istnieje również możliwość wysyłania komunikatów z innych miejsc w aplikacji przy użyciu IHubContext usługi. W tym artykule wyjaśniono, jak uzyskać dostęp do elementu SignalRIHubContext w celu wysyłania powiadomień do klientów spoza centrum.

Uwaga

Element IHubContext jest przeznaczony do wysyłania powiadomień do klientów, nie jest używany do wywoływania metod w obiekcie Hub.

Wyświetl lub pobierz przykładowy kod (jak pobrać)

Pobieranie wystąpienia IHubContext

W ASP.NET Core SignalRmożna uzyskać dostęp do wystąpienia za IHubContext pośrednictwem wstrzykiwania zależności. Możesz wstrzyknąć wystąpienie IHubContext do kontrolera, oprogramowania pośredniczącego lub innej usługi DI. Użyj wystąpienia do wysyłania komunikatów do klientów.

Wstrzykiwanie wystąpienia IHubContext obiektu w kontrolerze

Możesz wstrzyknąć wystąpienie IHubContext do kontrolera, dodając je do konstruktora:

public class HomeController : Controller
{
    private readonly IHubContext<NotificationHub> _hubContext;

    public HomeController(IHubContext<NotificationHub> hubContext)
    {
        _hubContext = hubContext;
    }
}

Z dostępem do wystąpienia IHubContextprogramu wywołaj metody klienta tak, jakby znajdowały się w samym centrum:

public async Task<IActionResult> Index()
{
    await _hubContext.Clients.All.SendAsync("Notify", $"Home page loaded at: {DateTime.Now}");
    return View();
}

Pobieranie wystąpienia oprogramowania pośredniczącego IHubContext

IHubContext Uzyskaj dostęp do potoku oprogramowania pośredniczącego w następujący sposób:

app.Use(async (context, next) =>
{
    var hubContext = context.RequestServices
                            .GetRequiredService<IHubContext<ChatHub>>();
    //...
    
    if (next != null)
    {
        await next.Invoke();
    }
});

Uwaga

Gdy metody klienta są wywoływane spoza Hub klasy, nie ma wywołania skojarzonego z wywołaniem. W związku z tym nie ma dostępu do ConnectionIdwłaściwości , Calleri Others .

Aplikacje, które muszą mapować użytkownika na identyfikator połączenia i utrwalać to mapowanie, mogą wykonywać jedną z następujących czynności:

  • Utrwalanie mapowania pojedynczych lub wielu połączeń jako grup. Aby uzyskać więcej informacji, zobacz Grupy w SignalR programie .
  • Zachowaj informacje o połączeniu i użytkowniku za pośrednictwem pojedynczej usługi. Aby uzyskać więcej informacji, zobacz Wstrzykiwanie usług do centrum . Usługa singleton może używać dowolnej metody magazynowania, takiej jak:
    • Magazyn w pamięci w słowniku.
    • Trwały magazyn zewnętrzny. Na przykład baza danych lub usługa Azure Table Storage korzystająca z pakietu NuGet Azure.Data.Tables.
  • Przekaż identyfikator połączenia między klientami.

Pobieranie wystąpienia z IHubContext usługi IHost

Uzyskiwanie dostępu do elementu IHubContext z hosta internetowego jest przydatne do integrowania z obszarami spoza platformy ASP.NET Core, na przykład przy użyciu struktur iniekcji zależności innych firm:

    public class Program
    {
        public static void Main(string[] args)
        {
            var host = CreateHostBuilder(args).Build();
            var hubContext = host.Services.GetService(typeof(IHubContext<ChatHub>));
            host.Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder => {
                    webBuilder.UseStartup<Startup>();
                });
    }

Wstrzykiwanie silnie typizowanego elementu HubContext

Aby wstrzyknąć silnie typizowane centrumContext, upewnij się, że centrum dziedziczy z Hub<T>klasy . Wstrzyknąć go przy użyciu interfejsu IHubContext<THub, T> , a nie IHubContext<THub>.

public class ChatController : Controller
{
    public IHubContext<ChatHub, IChatClient> _strongChatHubContext { get; }

    public ChatController(IHubContext<ChatHub, IChatClient> chatHubContext)
    {
        _strongChatHubContext = chatHubContext;
    }

    public async Task SendMessage(string user, string message)
    {
        await _strongChatHubContext.Clients.All.ReceiveMessage(user, message);
    }
}

Aby uzyskać więcej informacji, zobacz Silnie typizowane koncentratory .

Używanie IHubContext w kodzie ogólnym

Iniekcyjne IHubContext<THub> wystąpienie można rzutować bez IHubContext określonego typu ogólnego Hub .

class MyHub : Hub
{ }

class MyOtherHub : Hub
{ }

app.Use(async (context, next) =>
{
    var myHubContext = context.RequestServices
                            .GetRequiredService<IHubContext<MyHub>>();
    var myOtherHubContext = context.RequestServices
                            .GetRequiredService<IHubContext<MyOtherHub>>();
    await CommonHubContextMethod((IHubContext)myHubContext);
    await CommonHubContextMethod((IHubContext)myOtherHubContext);

    await next.Invoke();
}

async Task CommonHubContextMethod(IHubContext context)
{
    await context.Clients.All.SendAsync("clientMethod", new Args());
}

Jest to przydatne, gdy:

  • Pisanie bibliotek, które nie mają odwołania do określonego Hub typu używanego przez aplikację.
  • Pisanie kodu ogólnego i może mieć zastosowanie do wielu różnych Hub implementacji

Dodatkowe zasoby