C#

var products = _context.Products.ToList();

var products = await _context.Products.ToListAsync();

public class UserModel
{
    [Key]
    public int UserID { get; set; }
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    [Required]
    public string FirstName { get; set; }
    [Required]
    public string LastName { get; set; }
    [Required]
    public string Role { get; set; }

    //Navigation property
    public Department Department { get; set; }
}

User-SubUser table
------------------------------------
UserID          ReceiverUserID
------          --------------
23                    11
42                    11
19                    -
34                    23

public class PacketWriter : BinaryWriter
    {
        public MemoryStream MemoryStream;
        public BinaryWriter BinaryWriter;

        public PacketWriter()
        {
            MemoryStream = new MemoryStream();
            BinaryWriter = new BinaryWriter(MemoryStream);
        }
        public void WriteOpCode(byte opCode)
        {
            MemoryStream.WriteByte(opCode);
        }

        public void WriteNextChunckSize(int chunkSize)
        {
            BinaryWriter.Write((Int32)chunkSize);
        }

        public void WriteMessage(string message)
        {
            WriteNextChunckSize(message.Length);
            BinaryWriter.Write(message);
        }
        public byte[] GetPacketBytes()
        {
            return MemoryStream.ToArray();
        }
    }

public class PacketReader : BinaryReader
    {
        private NetworkStream _memoryStream;
        public PacketReader(NetworkStream memoryStream) : base(memoryStream)
        {
            _memoryStream = memoryStream;
        }

        public int ReadOpCode()
        {
            return _memoryStream.ReadByte();
        }

        public string ReadMessage(int chunkSize)
        {
            byte[] readMessage;
            readMessage = new byte[chunkSize];
            _memoryStream.Read(readMessage, 0, chunkSize);
            var message = Encoding.ASCII.GetString(readMessage);
            return message;
        }
        public int ReadChunkSize()
        {
            byte[] readChunkSize;
            readChunkSize = new byte[4];
            _memoryStream.Read(readChunkSize, 0, 3);
            return BitConverter.ToInt32(readChunkSize, 0);
        }
    }

Hello,

I have a problem with a self programmed windows service for .Net 6 that inherits from BackgroundService:

namespace WooComMesserschmidt
{
	internal class Worker : BackgroundService
	{
		private	readonly HttpClient						Client			= new()
		private	string									BaseAddress		= string.Empty;
		private	readonly IConfiguration					Configuration;
		private	string									ConfigFile		= string.Empty;
		private readonly Dictionary<string, dynamic?>	_ConfigPar;
		internal static	 Dictionary<string, string>		ConfigPar		= new();
		private readonly ILogger<Worker>				_logger;

		public struct LogInfo
		{
			public ILogger<Worker>? Logger;
			public string?			LogFile;

			public LogInfo(ILogger<Worker>? logger, string logfile)
			{
				Logger	= logger;
				LogFile	= logfile;
			}
		}

		public static LogInfo logInfo;

		public Worker(ILogger<Worker> logger, IConfiguration configuration, Dictionary<string, dynamic?> configpar)
		{
			Configuration	= configuration;
			_ConfigPar      = configpar;
			_logger         = logger;

			Init();
		}
...

In the method "Init()" relatively extensive tasks take place (on my PC it takes about 2 seconds). If these are through, it goes on here:

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
		{
			if (int.TryParse(ConfigPar[cpQueryInterval], out int QueryInterval) == false)
			{
				QueryInterval = QueryIntervalStd;
				Log.LogInformation(logInfo, $"Abfrageintervall konnte nicht ermittelt werden. Es wird daher der Standardwert von {QueryInterval} Millisekunden verwendet. Prüfen Sie die Angaben in der Parameterdatei.");
			}

			Log.LogInformation(logInfo, $"{Process.GetCurrentProcess().ProcessName} gestartet.");
			Log.LogInformation(logInfo, $"Worker arbeitet mit Abfrageintervall von {QueryInterval} Millisekunden.");

			while (stoppingToken.IsCancellationRequested == false)
			{
				await ProcessNewOrders();

				await UpdateProducts();

				Dhl_Polling();

				await Task.Delay(QueryInterval, stoppingToken);
			}
		}
...

The service is supposed to fetch orders from an eShop every few minutes, update items and process DHL shipments.

Well, when I start the program manually in the command line (i.e. not as a service), everything works as expected. Now I have registered the program as a service and every time I try to start the service I get the following error:

We started everything in Main:

private static async Task<int> Main(string[] args)
		{
			try
			{
				IHost host = Host.CreateDefaultBuilder(args)
					.UseWindowsService(options =>
					{
						options.ServiceName = ServiceName;
					})
					.ConfigureServices(services =>
					{
						services.AddSingleton<Dictionary<string, dynamic?>> (_ConfigPar);

						services.AddHostedService<Worker>();
					})
					.Build();

				await host.RunAsync();

				Log.LogInformation((LogInfo)_ConfigPar[cpLogInfo], $"{Process.GetCurrentProcess().ProcessName} beendet.");

				if (Debugger.IsAttached == true)
				{
					Console.ReadLine();
				}
			}
			catch (Exception ex)
			{
				Console.WriteLine($"{ex}{Environment.NewLine}{Environment.NewLine}");
...

How do I proceed to avoid this error?

Many thanks

René