C# 如何在控制器以外的位置调用signar Clients.All.InvokeAsync（）？

我可以通过构造函数中的DI访问.NET Core WebAPI控制器中的

IHubContext

fine and dandy，但我也希望在其他地方访问它

具体来说，当我使用来自RabbitMQ的消息时，有时我想通过

\u myHubContext.clients.All.InvokeAsync（）

更新客户端，但我就是不知道如何获取它

我在寻找在控制器之外执行此类操作的文档时也遇到了问题

任何帮助都将不胜感激

编辑：

[Route("api/[controller]")]
public class MyController: Controller
{
    private IDataService _dataService;
    private readonly IConfiguration configuration;
    private static IHubContext<StatusHub> hubContext;

    public NodesController(IConfiguration config, IDataService dataService, IHubContext<StatusHub> _hubContext)
    {
        _dataService = dataService;
        configuration = config;
        hubContext = _hubContext;
    }

    [HttpGet]
    public string Get()
    {
        hubContext.Clients.All.InvokeAsync("Send", "Blarg!");
        return "Well, I tried.";
    }
}

为了添加一些细节，以及问题的起因，我正在尝试访问我的

Startup

类中的IHubContext（以及我自己在

ConfigureServices

中注册的一些服务），特别是在

iaapplicationlifetime

ApplicationStarted

和

ApplicationStopped

期间，它们调用RabbitMQ使用者的方法来连接和断开连接

我猜对了，我可能无法访问

启动

类中的注册服务？如果是，我将如何开始这些服务

更新：

[Route("api/[controller]")]
public class MyController: Controller
{
    private IDataService _dataService;
    private readonly IConfiguration configuration;
    private static IHubContext<StatusHub> hubContext;

    public NodesController(IConfiguration config, IDataService dataService, IHubContext<StatusHub> _hubContext)
    {
        _dataService = dataService;
        configuration = config;
        hubContext = _hubContext;
    }

    [HttpGet]
    public string Get()
    {
        hubContext.Clients.All.InvokeAsync("Send", "Blarg!");
        return "Well, I tried.";
    }
}

在

Program.cs

中移动

services.addsignal（）

和一些在启动时调用的服务，直到

WebHost.ConfigureServices

，解决了我的一些问题，当然还有更多问题

当我收到来自RabbitMQ的消息时，我的JS客户端上没有收到任何消息，但我的客户端已成功连接。“奇怪……”我想。为了获取更多信息，我在控制器中连接了一个get操作，通过signar

Hub

发送一些内容。无论何时我打电话给GET，它都能工作。。。

IHubContext

。我通过RabbitMQ侦听器中的构造函数获得

hubContext

，就像我使用控制器一样

新问题：在控制器中注入的东西是否与我在启动时注册的服务中注入的东西不同？如何做到这一点，我如何克服这一点

一些与之配套的代码

摘自

程序.cs

public static IWebHost BuildWebHost(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseKestrel()
        .UseIISIntegration()
        .ConfigureServices(services => {
            services.AddSignalR();
            services.AddTransient<ISubscriber, Subscriber>();
            services.AddTransient<IDataService, DataService>();
            services.AddTransient<IHealthCheckProcessor, HealthCheckProcessor>();
            services.AddTransient<INodeProcessor, NodeProcessor>();
        })
        .UseStartup<Startup>()
        .Build();

public class Startup
{
    public Startup(IConfiguration _configuration, ISubscriber _subscriber)
    {
        configuration = _configuration;
        subscriber = _subscriber;
    }
    public IConfiguration configuration { get; }
    public ISubscriber subscriber { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors();
        services.AddMvc();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime applicationLifetime)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseCors(builder => builder
            // CORS stuff);

        app.UseSignalR(routes =>
        {
            routes.MapHub<StatusHub>("Status");
        });
        app.UseMvc();
        applicationLifetime.ApplicationStarted.Register(OnStartup);
        applicationLifetime.ApplicationStopping.Register(OnShutdown);
    }

    private void OnStartup() {
        // MessageBroker stuff
        subscriber.Start(messageBroker);
    }

    private void OnShutdown() {
        subscriber.Stop();
    }
}

public class Subscriber : ISubscriber {
    public static IConnection connection;
    public static IModel channel;
    public IHubContext<StatusHub> hubContext;

    public static IHealthCheckProcessor healthCheckProcessor;
    public static INodeProcessor nodeProcessor;

    public Subscriber(IHubContext<StatusHub> _hubContext, INodeProcessor _nodeProcessor, IHealthCheckProcessor _healthCheckProcessor)
    {
        connection = new ConnectionFactory().CreateConnection();
        channel = connection.CreateModel();
        hubContext = _hubContext;
        nodeProcessor = _nodeProcessor;
        healthCheckProcessor = _healthCheckProcessor;
    }

    public void Start(MessageBroker messageBroker)
    {
        var factory = new ConnectionFactory() { HostName = messageBroker.URL }.CreateConnection();

        foreach (Queue queue in messageBroker.Queues)
        {
            channel.QueueDeclare(
                queue: queue.Name,
                durable: queue.Durable,
                exclusive: queue.Exclusive,
                autoDelete: queue.AutoDelete,
                arguments: null
            );

            EventingBasicConsumer consumer = new EventingBasicConsumer(channel);

            consumer.Received += (model, ea) =>
            {
                byte[] body = ea.Body;
                string message = Encoding.UTF8.GetString(body);

                RouteMessage(queue, message);
            };

            channel.BasicConsume(
                    queue: queue.Name,
                    autoAck: queue.AutoAck,
                    consumer: consumer
                );
            hubContext.Clients.All.InvokeAsync("Send", "It worked - from the subscriber");
        }
    }

    public void RouteMessage(Queue queue, string message) {
        if(queue.Name == "discovery") {
            nodeProcessor.Process(message);
        }
        if(queue.Name == "health") {
            healthCheckProcessor.Process(message);
        }
    }

    public void Stop()
    {
        Console.WriteLine("Terminating connection to RabbitMQ instance.");
        channel.Close(200, "Goodbye");
        connection.Close();
    }
}

public class HealthCheckProcessor : IHealthCheckProcessor {
    private IDataService dataService;
    private IHubContext<StatusHub> hubContext;

    public HealthCheckProcessor(IDataService _dataService, IHubContext<StatusHub> _hubContext)
    {
        dataService = _dataService;
        hubContext = _hubContext;
    }
    public void Process(string message) {
        HealthCheck health = JsonConvert.DeserializeObject<HealthCheck>(message);
        Node node = dataService.GetSingle(health.NodeId);
        node.Health = health;

        dataService.Update(node);
        Console.WriteLine("It's sending.");
        hubContext.Clients.All.InvokeAsync("Send", "It worked - from the processor");
    }
}

来自

Subscriber.cs

public static IWebHost BuildWebHost(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseKestrel()
        .UseIISIntegration()
        .ConfigureServices(services => {
            services.AddSignalR();
            services.AddTransient<ISubscriber, Subscriber>();
            services.AddTransient<IDataService, DataService>();
            services.AddTransient<IHealthCheckProcessor, HealthCheckProcessor>();
            services.AddTransient<INodeProcessor, NodeProcessor>();
        })
        .UseStartup<Startup>()
        .Build();

public class Startup
{
    public Startup(IConfiguration _configuration, ISubscriber _subscriber)
    {
        configuration = _configuration;
        subscriber = _subscriber;
    }
    public IConfiguration configuration { get; }
    public ISubscriber subscriber { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors();
        services.AddMvc();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime applicationLifetime)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseCors(builder => builder
            // CORS stuff);

        app.UseSignalR(routes =>
        {
            routes.MapHub<StatusHub>("Status");
        });
        app.UseMvc();
        applicationLifetime.ApplicationStarted.Register(OnStartup);
        applicationLifetime.ApplicationStopping.Register(OnShutdown);
    }

    private void OnStartup() {
        // MessageBroker stuff
        subscriber.Start(messageBroker);
    }

    private void OnShutdown() {
        subscriber.Stop();
    }
}

public class Subscriber : ISubscriber {
    public static IConnection connection;
    public static IModel channel;
    public IHubContext<StatusHub> hubContext;

    public static IHealthCheckProcessor healthCheckProcessor;
    public static INodeProcessor nodeProcessor;

    public Subscriber(IHubContext<StatusHub> _hubContext, INodeProcessor _nodeProcessor, IHealthCheckProcessor _healthCheckProcessor)
    {
        connection = new ConnectionFactory().CreateConnection();
        channel = connection.CreateModel();
        hubContext = _hubContext;
        nodeProcessor = _nodeProcessor;
        healthCheckProcessor = _healthCheckProcessor;
    }

    public void Start(MessageBroker messageBroker)
    {
        var factory = new ConnectionFactory() { HostName = messageBroker.URL }.CreateConnection();

        foreach (Queue queue in messageBroker.Queues)
        {
            channel.QueueDeclare(
                queue: queue.Name,
                durable: queue.Durable,
                exclusive: queue.Exclusive,
                autoDelete: queue.AutoDelete,
                arguments: null
            );

            EventingBasicConsumer consumer = new EventingBasicConsumer(channel);

            consumer.Received += (model, ea) =>
            {
                byte[] body = ea.Body;
                string message = Encoding.UTF8.GetString(body);

                RouteMessage(queue, message);
            };

            channel.BasicConsume(
                    queue: queue.Name,
                    autoAck: queue.AutoAck,
                    consumer: consumer
                );
            hubContext.Clients.All.InvokeAsync("Send", "It worked - from the subscriber");
        }
    }

    public void RouteMessage(Queue queue, string message) {
        if(queue.Name == "discovery") {
            nodeProcessor.Process(message);
        }
        if(queue.Name == "health") {
            healthCheckProcessor.Process(message);
        }
    }

    public void Stop()
    {
        Console.WriteLine("Terminating connection to RabbitMQ instance.");
        channel.Close(200, "Goodbye");
        connection.Close();
    }
}

public class HealthCheckProcessor : IHealthCheckProcessor {
    private IDataService dataService;
    private IHubContext<StatusHub> hubContext;

    public HealthCheckProcessor(IDataService _dataService, IHubContext<StatusHub> _hubContext)
    {
        dataService = _dataService;
        hubContext = _hubContext;
    }
    public void Process(string message) {
        HealthCheck health = JsonConvert.DeserializeObject<HealthCheck>(message);
        Node node = dataService.GetSingle(health.NodeId);
        node.Health = health;

        dataService.Update(node);
        Console.WriteLine("It's sending.");
        hubContext.Clients.All.InvokeAsync("Send", "It worked - from the processor");
    }
}

来自控制器：

[Route("api/[controller]")]
public class MyController: Controller
{
    private IDataService _dataService;
    private readonly IConfiguration configuration;
    private static IHubContext<StatusHub> hubContext;

    public NodesController(IConfiguration config, IDataService dataService, IHubContext<StatusHub> _hubContext)
    {
        _dataService = dataService;
        configuration = config;
        hubContext = _hubContext;
    }

    [HttpGet]
    public string Get()
    {
        hubContext.Clients.All.InvokeAsync("Send", "Blarg!");
        return "Well, I tried.";
    }
}

[路由（“api/[控制器]”）]
公共类MyController:Controller
{
私有IDataService(数据服务);；
专用只读IConfiguration配置；
私有静态IHubContext-hubContext；
公共节点控制器（IConfiguration配置、IDataService数据服务、IHubContext\u hubContext）
{
_数据服务=数据服务；
配置=配置；
hubContext=\u hubContext；
}
[HttpGet]
公共字符串Get（）
{
hubContext.Clients.All.InvokeAsync（“Send”，“Blarg！”）；
return“我试过了。”；
}
}

您正在尝试访问请求时不可用的服务

Configure

在

ConfigureServices

之后调用，以便可以访问注册的任何服务

public class Startup {
    public Startup(IConfiguration _configuration) {
        configuration = _configuration;
    }

    public IConfiguration configuration { get; }

    public void ConfigureServices(IServiceCollection services) {        
        services.AddCors();
        services.AddMvc();

        services.AddSignalR();
        services.AddTransient<ISubscriber, Subscriber>();
        services.AddTransient<IDataService, DataService>();
        services.AddTransient<IHealthCheckProcessor, HealthCheckProcessor>();
        services.AddTransient<INodeProcessor, NodeProcessor>();
    }

    public void Configure(
        IApplicationBuilder app, 
        IHostingEnvironment env, 
        IApplicationLifetime applicationLifetime, 
        IServiceProvider sp
    ) {
        if (env.IsDevelopment()) {
            app.UseDeveloperExceptionPage();
        }
        app.UseCors(builder => builder
            // CORS stuff);

        app.UseMvc();

        app.UseSignalR(routes => {
            routes.MapHub<StatusHub>("Status");
        });

        //At this point all the necessary dependencies have been registered and configured
        var subscriber = sp.GetService<ISubscriber>();

        applicationLifetime.ApplicationStarted.Register(() => OnStartup(subscriber));
        applicationLifetime.ApplicationStopping.Register(() => OnShutdown(subscriber));
    }

    private void OnStartup(ISubscriber subscriber) {
        // MessageBroker stuff
        subscriber.Start(messageBroker);
    }

    private void OnShutdown(ISubscriber subscriber) {
        subscriber.Stop();
    }
}

---

我想你指的是核心信号机，对吗？如果是这样的话，如果你改变标签就好了。你的具体问题是什么？由于

IHubContext

是在DI容器中注册的，所以只要该对象也是由DI容器创建的，您就可以将其注入到任何东西中，无论是否是控制器。@ChisPratt

IHubContext

可能没有正确注册。我只添加了

app.UseSignalR（）；和
Startup.cs
中的services.AddSignalR（）`。我不确定是否/如何将我的
IHubContext
作为服务注入。我使用什么作为接口和实现？我将我的集线器添加为services.AddSingleton（）；这对我来说很好。我从来没有在我的控制器中使用集线器，我有一个额外的服务。@Nickdb93是
ISubscriber
被正确注入启动？工作正常，干得不错。不过要跟进。为什么即使在调用
Startup
中的任何内容之前就注入了服务，该服务仍然不可用？为什么我不能在
Startup
的构造函数中使用它？（顺便说一句，我仍然无法在2小时内奖励赏金）在用户被注入时，信号器并没有完全配置为可以使用。这就是为什么我之后要求它。例如，控制器将在所有配置完成后请求上下文。啊，我明白了，我认为在
Program.cs
中调用
services.addsignal（）
就足够了。太好了，谢谢你。