单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，在 C# 中，单例模式有多种实现方式。

尽管在.NETCore中已经内置了Ioc容器，容器可以确保

1、饿汉式

public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();

    // 私有构造函数，防止外部实例化
    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            return instance;
        }
    }
}

这是最简单的单例模式，巧妙利用C#中static静态变量全局只能被初始化一次的机制来创建当前类的实例对象，确保线程安全。这也是我最喜欢的一种实现方式，尽管大部分人认为这种写法可能会有一些性能上的损失，创建对象耗时较长。但是我个人认为在当前的硬件性能环境下，这些损失几乎可以忽略不计。

2、懒汉式（双重检查锁定）

public sealed class Singleton
{
    private static Singleton instance = null;
    private static readonly object padlock = new object();

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock (padlock)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

这种方式确保只有在第一次使用的时候，才创建实例对象，if双重判定和lock锁可以确保线程安全。即使并发执行，也只会创建一个实例对象。

双重检查既可以确保访问的高效，又可以保证线程安全。

3、静态构造函数

public sealed class Singleton
{
    private static readonly Singleton instance;

    // 私有构造函数，防止外部实例化
    private Singleton() { }

    static Singleton()
    {
        instance = new Singleton();
    }

    public static Singleton Instance
    {
        get
        {
            return instance;
        }
    }
}

静态构造函数在整个应用程序生命周期只会执行一次，所以利用这个机制。可以在静态构造函数中，来构造类的唯一实例对象。线程的安全，交给运行来确保，我们不需要下像懒汉式那样通过锁来保证线程安全。

4、Lazy<T>懒加载

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy = new Lazy<Singleton>(() => new Singleton());

    private Singleton() { }

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

Lazy<T> 提供了一种更优雅的方式来实现单例模式，具有以下优点：
1.    延迟初始化：Lazy<T> 实例在第一次访问时才会被创建，这样可以避免不必要的资源消耗。
2.    线程安全：Lazy<T> 默认是线程安全的，确保在多线程环境下也能正确地创建单例实例。
3.    简洁性：使用 Lazy<T> 可以简化代码，不需要显式地编写双重检查锁定等复杂的线程同步代码。