HostedService 阻塞 UI 线程？

Question

I have the following code for a MQTT Subscriber in a Background Task:

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using PickByLight.BackgroundTask.Models;
using PickByLight.Database.Wrapper.Interfaces;
using PickByLight.Logic;
using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using uPLibrary.Networking.M2Mqtt;
using uPLibrary.Networking.M2Mqtt.Messages;

namespace PickByLight.BackgroundTask
{
    /// <summary>
    /// Hosted MQTT Background Service
    /// </summary>
    public class HostedMQTTService : IHostedService, IDisposable
    {


        private readonly Task _executingTask;
        private readonly CancellationTokenSource _stoppingCts = new CancellationTokenSource();
        /// <summary>
        /// MQTT Client
        /// </summary>
        private MqttClient MqttClient { get; set; }

        /// <summary>
        /// Name of the Pick by Light
        /// </summary>
        private string PickByLight_Name { get; set; }

        /// <summary>
        /// MQTT is activated
        /// </summary>
        private bool MqttIsActive { get; set; }

        /// <summary>
        /// IP Adress of the MQTT URL
        /// </summary>
        private string MqttURL { get; set; }


        /// <summary>
        /// Storage Process for an material
        /// </summary>
        private MaterialStorageProcess StorageProcess { get; set; }

        /// <summary>
        /// Service Scope Factory
        /// </summary>
        private IServiceScopeFactory ServiceScopeFactory { get; set; }

        /// <summary>
        /// Configuration
        /// </summary>
        private IConfiguration Configuration { get; set; }

        /// <summary>
        /// Logger
        /// </summary>
        private readonly ILogger<HostedMQTTService> _logger;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="configuration"></param>
        public HostedMQTTService(IConfiguration configuration, ILogger<HostedMQTTService> logger, IServiceScopeFactory serviceScopeFactory)
        {
            this.PickByLight_Name = configuration.GetValue<string>("PickByLight_Name");
            this.MqttURL = configuration.GetValue<string>("MQTTUrl");
            this.MqttIsActive = configuration.GetValue<bool>("MQTTConnection");
            this.ServiceScopeFactory = serviceScopeFactory;
            this.Configuration = configuration;
            this._logger = logger;
        }

        /// <summary>
        /// Start the Task of the Background Service
        /// </summary>
        public Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Background-Service started...");
            while (true)
            {
                try
                {
                    //No Object is created
                    if (this.MqttClient == null)
                    {
                        _logger.LogInformation("Try to establishe new MQTT Client");
                        this.MqttClient = CreateNewMqttConnection();
                    }
                    else if (this.MqttClient.IsConnected == false)
                    {
                        _logger.LogInformation("MQTT Client is disconnected... Try to reconnect!");
                        this.MqttClient = CreateNewMqttConnection();
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Ein schwerwiegender Fehler im MQTT Background-Service ist aufgetreten.");
                }
            }
        }

        /// <summary>
        /// Prints out all received messages
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Mqtt_Message_Received(object sender, MqttMsgPublishEventArgs e)
        {
            try
            {
                var agcMessage = Encoding.UTF8.GetString(e.Message);
                _logger.LogInformation("Topic: " + e.Topic + " | Nachricht: " + agcMessage + " | QOS: " + e.QosLevel);

                var resultString = Encoding.UTF8.GetString(e.Message);
                MqttReadTopicClass mqttContent = JsonConvert.DeserializeObject<MqttReadTopicClass>(resultString);

                using (var scope = this.ServiceScopeFactory.CreateScope())
                {
                    var storageConfigurationManager = scope.ServiceProvider.GetService<IStorageConfigurationManager>();
                    var storageElementManager = scope.ServiceProvider.GetService<IStorageElementManager>();
                    this.StorageProcess = new MaterialStorageProcess(storageConfigurationManager, storageElementManager, this.Configuration);


                    StorageProcess.Remove(mqttContent.storageLocation);
                }

            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Schwerwiegender Fehler beim Lesen von MQTT Nachrichten");
            }
        }




        /// <summary>
        /// Create new MQTT connection if connection is lost or doesn't exist
        /// </summary>
        private MqttClient CreateNewMqttConnection()
        {
            _logger.LogInformation("Create MQTT Client");
            MqttClient client = new MqttClient(this.MqttURL, 32005, false, null, null, MqttSslProtocols.None);
            string clientId = Guid.NewGuid().ToString();
            client.MqttMsgPublishReceived += Mqtt_Message_Received;
            client.Connect(clientId);
            client.Subscribe(new string[] { "buttonpress_sepioo_pdi/" + this.PickByLight_Name }, new byte[] { MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE });
            _logger.LogInformation("MQTT Client created");
            return client;
        }

        /// <summary>
        /// Stop the Task of the Background Service
        /// </summary>
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            //Stop called without start
            if (_executingTask == null)
            {
                return;
            }

            try
            {
                //Signal cancellation to the executing method
                _stoppingCts.Cancel();
            }
            finally
            {
                //wait until the task completes or the stop token triggers
                await Task.WhenAny(_executingTask, Task.Delay(Timeout.Infinite, cancellationToken));
            }
        }

        /// <summary>
        /// Dispose the Background Service
        /// </summary>
        public void Dispose()
        {
            _stoppingCts.Cancel();
        }

    }
}

In my startup.cs File i am doing the following:

//Register Background Task
services.AddHostedService<HostedMQTTService>();

The problem is, that it seems to me that the hosted service is blocking the user-interface/webserver threads because i can not access the url of the .net 6 mvc application.

Could you give me a hint or a solution to this problem?

Thanks.

Answer 1

You are blocking the process, because your hosted service never starts.

1. Remove the while(true) loop from the Start method.
2. Ensure base.StartAsync(cancellationToken); is always called.

Edit : I saw you implement the IHostedService interface. Try to inherits from the BackgroundService class

Answer 2

You will need to change your StartAsync -method to something like this:

   public Task StartAsync(CancellationToken cancellationToken)
    {
        return Task.Run(() => 
        {
            _logger.LogInformation("Background-Service started...");

            while (!cancellationToken.IsCancellationRequested)
            {
                try
                {
                    //No Object is created
                    if (this.MqttClient == null)
                    {
                        _logger.LogInformation("Try to establish new MQTT Client");
                        this.MqttClient = CreateNewMqttConnection();
                    }
                    else if (this.MqttClient.IsConnected == false)
                    {
                        _logger.LogInformation("MQTT Client is disconnected... Try to reconnect!");
                        this.MqttClient = CreateNewMqttConnection();
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Ein schwerwiegender Fehler im MQTT Background-Service ist aufgetreten.");
                }
            }
        });
    }