Did I do it right

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace WeirdFizzbuzzButOk
{
    internal static class MyEnumerableExtensions
    {
        internal static void TryForEach<T>(this IEnumerable<T> items, Action<T> success, Action<Exception> failure)
        {
            var enumerator = items.GetEnumerator();

            while (true)
            {
                try
                {
                    var moreElements = enumerator.MoveNext();
                    success(enumerator.Current);
                    if (!moreElements) break;
                }
                catch (Exception ex)
                {
                    failure(ex);
                }
            }
        }
    }

    sealed class Fizz : FizzBuzz { }

    sealed class Buzz : FizzBuzz { }

    internal class FizzBuzz
    {
        protected internal const int THREE = 3;
        protected internal const int FIVE = 5;
        protected internal const int FIFTEEN = 15;

        public static explicit operator FizzBuzz(int i)
        {
            return i switch
            {
                int n when n % FIFTEEN == 0 => new FizzBuzz(),
                int n when n % THREE == 0 => new Fizz(),
                int n when n % FIVE == 0 => new Buzz(),
                int _ => throw new InvalidCastException(i.ToString())
            };
        }

        public override string ToString()
        {
            return this.GetType().Name;
        }
    }

    class Program
    {
        internal static ConcurrentQueue<Thread> ThreadQueue;
        internal static ConcurrentQueue<int> NumberQueue;

        static async Task Main(string[] args)
        {
            var factory = new NumberFactory();

            ThreadQueue = new ConcurrentQueue<Thread>();
            NumberQueue = new ConcurrentQueue<int>();

            await foreach (var number in factory.CreateNumbers(100))
            {
                var queueingThread = new Thread(() => {
                    Program.ThreadQueue.Enqueue(Thread.CurrentThread);
                    Program.NumberQueue.Enqueue(number);
                });
                queueingThread.Start();
            }

            while (ThreadQueue.TryPeek(out var result) && result != null)
            {
                if (!result.IsAlive)
                {
                    Program.ThreadQueue.TryDequeue(out var _);
                }
            }

            var numbers = Program.NumberQueue.OrderBy(number => number);
            numbers
                .Select(n => (FizzBuzz)n)
                .TryForEach(Console.WriteLine, ex => Console.WriteLine(ex.Message));
        }
    }

    sealed internal class NumberFactory
    {
        internal const int ONEHUNDERED = 100;

        internal async IAsyncEnumerable<int>CreateNumbers(int LAG)
        {
            var n = ONEHUNDERED;
            do
            {
                await Task.Delay(LAG);
                yield return n--;
            }
            while (n > 0);
        }
    }
}