Dela via

Skicka meddelanden utanför ett nav

Hubben SignalR är den viktigaste abstraktionen för att skicka meddelanden till klienter som är anslutna SignalR till servern. Det går också att skicka meddelanden från andra platser i appen med hjälp av IHubContext tjänsten. Den här artikeln beskriver hur du får åtkomst till en SignalRIHubContext för att skicka meddelanden till klienter utanför en hubb.

Note

IHubContext är för att skicka meddelanden till klienter, det används inte för att anropa metoder på Hub.

Visa eller ladda ned exempelkod(ladda ned)

Hämta en instans av IHubContext

I ASP.NET Core SignalR kan du komma åt en instans av IHubContext via beroendeinjektion. Du kan mata in en instans av IHubContext i en kontrollant, mellanprogram eller annan DI-tjänst. Använd instansen för att skicka meddelanden till klienter.

Mata in en instans av IHubContext i en kontroller

Du kan mata in en instans av IHubContext i en kontrollant genom att lägga till den i konstruktorn:

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

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

Med åtkomst till en instans av IHubContextanropar du klientmetoder som om du vore i själva hubben:

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

Hämta en instans av IHubContext i mellanprogram

Få åtkomst till pipelinen IHubContext för mellanprogram så här:

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

Note

När klientmetoder anropas utanför Hub klassen finns det ingen anropare som är associerad med anropet. Därför finns det ingen åtkomst till ConnectionIdegenskaperna , Calleroch Others .

Appar som behöver mappa en användare till anslutnings-ID:t och bevara den mappningen kan göra något av följande:

  • Upprätthåll mappning av en eller flera anslutningar som grupper. För mer information, se Grupper i SignalR.
  • Behåll anslutning och användarinformation via en singleton-tjänst. Mer information finns i Mata in tjänster i en hubb . Singleton-tjänsten kan använda valfri lagringsmetod, till exempel:
    • Minnesintern lagring i en ordlista.
    • Permanent extern lagring. Till exempel en databas eller Azure Table Storage med hjälp av NuGet-paketet Azure.Data.Tables.
  • Skicka anslutnings-ID:t mellan klienter.

Hämta en instans av IHubContext från IHost

Att komma åt en IHubContext från webbvärden är användbart för att integrera med områden utanför ASP.NET Core, till exempel genom att använda tredjepartsramverk för dependency injection.

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

Sätt in en starkt typad HubContext

För att injicera en starkt typad HubContext, se till att hubben ärver från Hub<T>. Mata in den med hjälp av IHubContext<THub, T> gränssnittet i stället IHubContext<THub>för .

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);
    }
}

Mer information finns i Starkt typade hubbar.

Använda IHubContext i allmän kod

En injicerad IHubContext<THub>-instans kan omvandlas till IHubContext utan att en generell Hub-typ har angetts.

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

Detta är användbart när:

  • Skriva bibliotek som inte har någon referens till den specifika Hub-typ som används av appen.
  • Skriva kod som är allmän och kan tillämpas på flera olika Hub implementeringar

Ytterligare resurser