.NET-Core

// using Microsoft.Extensions.DependencyInjection
ServiceCollection services = new ServiceCollection();

ServiceCollection services = new ServiceCollection();

// 向services注册各种类型

IServiceProvider sp = services.BuildServiceProvider();

//从此以后，任何握有 sp 的对象可以从ServiceCollection里获取实例。

// AddTransient 方法将一个类型注册为 Transient 生命周期。因此，每一次你从依赖注入中请求一个 MyTransientClass 实例，你都会得到一个全新实例化的实例。请求10次，就得到10个不同的实例。
service.AddTransient<MyTransientClass>();

// AddSingleton 方法将一个类型注册为 Singleton 生命周期。单体大家都懂，就是无论请求多少次，你从依赖注入都会得到同一个 MySingletonClass 实例。请求10次，得到的却是同一个实例。
service.AddSingleton<MySingletonClass>();

// AddScoped 方法将一个类型注册为 Scoped 生命周期。这个生命周期比较特别。如果你的程序里创建了若干个 "Scope"，依赖注入会确保在同一个 Scope 里，你将得到同一个 MyScopedClass 实例，而不同 Scope 里的 MyScopedClass 实例是不同的
// 假设你有3个Scope，每个Scope里请求10次，那么你将得到3个不同的 MyScopedClass 实例。其中每个 Scope 里一个。
// 至于 Scope 到底是什么含义，这就因程序而异了。比如在 ASP.NET Core 里，一个Scope意味着一次浏览器请求往返。而在我们的示例程序里，一个Scope代表一个线程内部。
service.AddScoped<MyScopedClass>();

public class MyClass { }

public class ReferenceEqualComparer<T> : IEqualityComparer<T>
{
    public bool Equals(T x, T y)
    {
        return Object.ReferenceEquals(x, y);
    }

    public int GetHashCode(T obj)
    {
        return obj.GetHashCode();
    }
}

public static class IEnumerableExtensions
{
    public static bool AreIdentical<T>(this IEnumerable<T> bag)
    {
        return bag.Distinct(new ReferenceEqualComparer<T>()).Count() == 1;
    }

    public static bool AreDifferent<T>(this IEnumerable<T> bag)
    {
        return bag.Distinct(new ReferenceEqualComparer<T>()).Count() == bag.Count();
    }
}

public static ConcurrentBag<MyClass> GetObjectsFromDI(ServiceCollection services)
{
    int threadCount = 10;
    IServiceProvider sp = services.BuildServiceProvider();
    ConcurrentBag<MyClass> bag = new ConcurrentBag<MyClass>();
    Thread[] threads = new Thread[threadCount];

    for (int i = 0; i < threadCount; i++)
    {
        Thread thread = new Thread(RunPerThread);
        threads[i] = thread;
        thread.Start(new Tuple<IServiceProvider, ConcurrentBag<MyClass>>(sp, bag));
    }

    // 确保所有线程都执行完毕之后再继续
    for (int i = 0; i < threadCount; i++)
    {
        threads[i].Join();
    }

    return bag;
}

public static void RunPerThread(object threadParam)
{
    Tuple<IServiceProvider, ConcurrentBag<MyClass>> args = threadParam as Tuple<IServiceProvider, ConcurrentBag<MyClass>>;
    IServiceProvider sp = args.Item1;
    ConcurrentBag<MyClass> bag = args.Item2;
    for (int i = 0; i < 10; i++)
    {
        bag.Add(sp.GetRequiredService<MyClass>());
    }
}

private static void TryOutSingleton()
{
    ServiceCollection services = new ServiceCollection(); // 准备好我们的容器
    services.AddSingleton<MyClass>(); //把MyClass注册为 Singleton 生命周期 

    ConcurrentBag<MyClass> bag = GetObjectsFromDI(services); // 调用我们准备好的方法，用若干线程从 IServiceProvider 中获取 MyClass 实例，并加入到集合

    Console.WriteLine(bag.AreIdentical()); // 验证集合中的所有元素是否指向内存中的同一个对象。
}

private static void TryOutTransient()
{
    ServiceCollection services = new ServiceCollection(); // 准备好我们的容器
    services.AddTransient<MyClass>(); //把MyClass注册为 Transient 生命周期 

    ConcurrentBag<MyClass> bag = GetObjectsFromDI(services); // 调用我们准备好的方法，用若干线程从 IServiceProvider 中获取 MyClass 实例，并加入到集合
    
    Console.WriteLine(bag.AreDifferent()); // 验证集合中的所有元素是否各不相同
}

ServiceCollection services = new ServiceCollection();

// ...

IServiceProvider serviceProvider = services.BuildServiceProvider();

IServiceScope scope = serviceProvider.CreateScope();

IServiceProvider newServiceProvider = scope.ServiceProvider; // 以后靠它来正确处理 Singleton, Transient 和 Scoped 生命周期的实例

MyClass obj = newServiceProvider.GetRequiredService<MyClass>(); // 无论MyClass是哪种生命周期类型，这里都可以得到正确的实例。

/*
public class MySingleton { }
public class MyTransient { }
public class MyScoped { }
*/

private static void TryOutScoped()
{
    Console.WriteLine($"RUNNING {nameof(TryOutScoped)}");

    ServiceCollection services = new ServiceCollection();
    services.AddSingleton<MySingleton>();
    services.AddTransient<MyTransient>();
    services.AddScoped<MyScoped>();

    IServiceProvider sp = services.BuildServiceProvider();

    // 线程1执行
    ConcurrentBag<MySingleton> thread1SingletonBag = new ConcurrentBag<MySingleton>();
    ConcurrentBag<MyTransient> thread1TransientBag = new ConcurrentBag<MyTransient>();
    ConcurrentBag<MyScoped> thread1ScopedBag = new ConcurrentBag<MyScoped>();

    Thread thread1 = new Thread(RunPerThreadWithScopedLifetime);
    thread1.Start(new Tuple<IServiceProvider, ConcurrentBag<MySingleton>, ConcurrentBag<MyTransient>, ConcurrentBag<MyScoped>>(sp, thread1SingletonBag, thread1TransientBag, thread1ScopedBag));

    // 线程2执行
    ConcurrentBag<MySingleton> thread2SingletonBag = new ConcurrentBag<MySingleton>();
    ConcurrentBag<MyTransient> thread2TransientBag = new ConcurrentBag<MyTransient>();
    ConcurrentBag<MyScoped> thread2ScopedBag = new ConcurrentBag<MyScoped>();

    Thread thread2 = new Thread(RunPerThreadWithScopedLifetime);
    thread2.Start(new Tuple<IServiceProvider, ConcurrentBag<MySingleton>, ConcurrentBag<MyTransient>, ConcurrentBag<MyScoped>>(sp, thread2SingletonBag, thread2TransientBag, thread2ScopedBag));

    // 等待执行完毕
    thread1.Join();
    thread2.Join();

    // 验证所有 MySingleton 的实例都指向内存里同一个对象
    IEnumerable<MySingleton> singletons = thread1SingletonBag.Concat(thread2SingletonBag);
    Console.WriteLine($"Singleton: {singletons.Count()} objects are IDENTICAL? {singletons.AreIdentical()}");

    // 验证所有 MyTransient 的实例都各不相同
    IEnumerable<MyTransient> transients = thread1TransientBag.Concat(thread2TransientBag);
    Console.WriteLine($"Transient: {transients.Count()} objects are DIFFERENT? {transients.AreDifferent()}");

    // 对于Scoped生命周期，每个线程集合内的实例应该指向内存里同一个对象，而2个线程集合里的实例应该是不同的。
    Console.WriteLine($"collection of thread 1 has {thread1ScopedBag.Count} objects and they are IDENTICAL: {thread1ScopedBag.AreIdentical()}");
    Console.WriteLine($"collection of thread 2 has {thread2ScopedBag.Count} objects and they are IDENTICAL: {thread2ScopedBag.AreIdentical()}");
    Console.WriteLine($"the first object from thread 1 and the first object from thread 2 are IDENTICAL: {Object.ReferenceEquals(thread1ScopedBag.First(), thread2ScopedBag.First())}");

}

/* the following methods have high performance and come from: http://stackoverflow.com/a/24343727/2753545 */

private static readonly uint[] _lookup32 = CreateLookup32();

private static uint[] CreateLookup32()
{
    var result = new uint[256];
    for (int i = 0; i < 256; i++)
    {
        string s = i.ToString("X2");
        result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
    }
    return result;
}

public static string ByteArrayToHexViaLookup32(byte[] bytes)
{
    uint[] lookup32 = _lookup32;
    char[] result = new char[bytes.Length * 2];
    for (int i = 0; i < bytes.Length; i++)
    {
        uint val = lookup32[bytes[i]];
        result[2 * i] = (char)val;
        result[2 * i + 1] = (char)(val >> 16);
    }
    return new string(result);
}

// this method is from http://stackoverflow.com/a/17923942/2753545
public static byte[] HexToByteUsingByteManipulation(string s)
{
    byte[] bytes = new byte[s.Length / 2];
    for (int i = 0; i < bytes.Length; i++)
    {
        int hi = s[i * 2] - 65;
        hi = hi + 10 + ((hi >> 31) & 7);

        int lo = s[i * 2 + 1] - 65;
        lo = lo + 10 + ((lo >> 31) & 7) & 0x0f;

        bytes[i] = (byte)(lo | hi << 4);
    }
    return bytes;
}