Incorrect dispose order when a dependency class is registered as both Singleton and KeyedSingleton

[alexey-leonovich]

I reference Microsoft.Extensions.Hosting 8.0 in my .NET 8.0 console application.
In my host I have two classes (SecondaryClass depends on PrimaryClass). PrimaryClass is registered as both Singleton and KeyedSingleton.
I also have two hosted services (one has those classes interfaces injected directly into constructor, another one obtains PrimaryClass with IServiceProvider.GetKeyedService<IPrimary>("key") call).
And it looks like those classes dispose order depend on registration code - this initialization does not cause problems:

s.AddKeyedSingleton<IPrimary, PrimaryClass>("key");
s.AddSingleton(p => p.GetKeyedService<IPrimary>("key"));

This initialization causes problems (PrimaryClass is disposed before SecondaryClass ):

s.AddSingleton<IPrimary, PrimaryClass>();
s.AddKeyedSingleton("key", (p, _) => p.GetService<IPrimary>());

Sample code

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace TestConsoleAppForDI
{
    internal static class Program
    {
        const bool problem = true;

        private static void Main(string[] _)
        {
            // Create instances explicitly
            var hostBuilder = Host.CreateDefaultBuilder();
            hostBuilder.ConfigureServices((_, s) =>
            {
                if (problem)
                {
                    /* This initialization causes problems */
                    s.AddSingleton<IPrimary, PrimaryClass>();
                    s.AddKeyedSingleton("key", (p, _) => p.GetService<IPrimary>());
                }
                else
                {
                    /* This initialization does not cause problems */
                    s.AddKeyedSingleton<IPrimary, PrimaryClass>("key");
					s.AddSingleton(p => p.GetKeyedService<IPrimary>("key"));                    
                }

                s.AddSingleton<ISecondary, SecondaryClass>();

                s.AddHostedService<HostedServiceWithGetKeyed>();
                s.AddHostedService<HostedServiceWithSingletons>();
            });

            using var host = hostBuilder.Build();
            var timer = new System.Timers.Timer
            {
                Interval = 3000
            };
            timer.Elapsed += (sender, e) => {
                host.StopAsync();
                timer.Stop();
            };
            timer.Start();
            host.Run();
        }
    }

    internal class HostedServiceWithSingletons(ISecondary secondary, IPrimary primary) : IHostedService
    {
        public Task StartAsync(CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }
    }

    internal class HostedServiceWithGetKeyed(IServiceProvider provider) : IHostedService
    {
        private IPrimary classFromKeyed;
        public Task StartAsync(CancellationToken cancellationToken)
        {
            classFromKeyed = provider.GetKeyedService<IPrimary>("key");
            return Task.CompletedTask;
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }
    }

    internal interface IPrimary : IDisposable
    {
        bool Disposed { get; }
    }

    internal interface ISecondary : IDisposable;

    internal class SecondaryClass(IPrimary primary) : ISecondary
    {
        public void Dispose()
        {
            Console.WriteLine(primary.Disposed
                ? "!!!! PROBLEM on SecondaryClass Disposing"
                : "1. SecondaryClass Disposed.");
        }
    }

    internal class PrimaryClass : IPrimary
    {
        private bool _disposed;
        private readonly object _sync = new();


        public void Dispose()
        {
            lock (_sync)
            {
                if (_disposed)
                    return;
                _disposed = true;
            }
            Console.WriteLine("2. PrimaryClass Disposed");
        }

        public bool Disposed => _disposed;
    }
}

I've uploaded an online example to run as-is (problem = true shows problematic scenario, change it to false to see correct scenario).

Is that a bug in Generic Host's DI or am I missing something?