استفاده از ThreadStatic برای شبیه سازی Scoped Dependency در C#

using System;
using System.Collections.Generic;

namespace External.Writer
{
    public class BlockCommandWriter : RabbitmqSyncWriter
    {
        [ThreadStatic]
        private static BlockCommandWriter _instance;
        
        private static readonly object LockObj = new object();

        private BlockCommandWriter(List<string> hostNames,
            string username,
            string password,
            string exchange,
            string routingKey,
            bool shouldSend,
            bool automaticRecoveryEnabled)
            : base(hostNames, username, password, exchange, routingKey, shouldSend, automaticRecoveryEnabled, true)
        {
        }

        public static BlockCommandWriter GetInstance()
        {
            if (_instance == null)
            {
                lock (LockObj)
                {
                    if (_instance == null)
                    {
                        var hostNames = new List<string>();
                        var hosts = Configs.Hostname;

                        if (hosts.Contains(","))
                        {
                            hostNames.AddRange(hosts.Split(','));
                        }
                        else
                        {
                            hostNames.Add(hosts);
                        }

                        _instance = new DecreaseBlockCommandWriter(hostNames,
                            Configs.Username,
                            Configs.Password,
                            Configs.Exchange,
                            Configs.BlockRoutingKey,
                            Configs.BlockShouldSend,
                            Configs.AutomaticRecoveryEnabled);
                    }
                }
            }

            return _instance;
        }

        public void SendToQueue(string message)
        {
            base.Send(message);
        }
    }
}

[ThreadStatic]
private static int _item = 40;

public sealed class Singleton
{
    private Singleton()
    {
        // Do some initialization here
    }

    public void DoSomething()
    {
        // Do something here
    }
}

private static ThreadLocal<Singleton> threadLocal = new ThreadLocal<Singleton>(() => new Singleton());

public static Singleton Instance
{
    get
    {
        return threadLocal.Value;
    }
}

// Example usage
class Program
{
    static void Main(string[] args)
    {
        var tasks = new Task[10];

        for (int i = 0; i < 10; i++)
        {
            tasks[i] = Task.Run(() =>
            {
                var singleton = Singleton.Instance;

                singleton.DoSomething();

                // Print the hash code of the instance to verify that it is different for each thread
                Console.WriteLine("Thread {0} has singleton instance {1}", Thread.CurrentThread.ManagedThreadId, singleton.GetHashCode());
            });
        }

        Task.WaitAll(tasks);
    }
}