设计模式---单例模式---14

单例就不多说了！

1.饿汉模式

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

    private Singleton() { }

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

2.懒汉模式

public sealed class Singleton
{
    private static Singleton instance = null;

    private static object locker = new object();

    private Singleton() { }

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

3.泛型饿汉模式：

public class Singleton<T> where T : Singleton<T>
{
    private static T instance = null;   

    private Singleton() { }

    static Singleton()
    {
        var type = typeof(T);
        var cons = type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);

        var ctor = Array.Find(cons, c => c.GetParameters().Length == 0);

        if (ctor == null)
        {
            throw new Exception($"未找到派生类{typeof(T)}：无参私有构造函数");
        }

        instance = ctor.Invoke(null) as T;   
    }

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

4.泛型懒汉模式：派生类构造自己私有化

public class Singleton<T> where T : Singleton<T>
{
    private static T instance = default;

    private static object locker = new object();

    private Singleton() { }

    public static T Instance
    {
        get
        {
            if (instance == null)
            {
                lock (locker)
                {
                    if (instance == null)
                    {                      
                        var type = typeof(T);
				        var cons = type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
				
				        var ctor = Array.Find(cons, c => c.GetParameters().Length == 0);
				
				        if (ctor == null)
				        {
				            throw new Exception($"未找到派生类{typeof(T)}：无参私有构造函数");
				        }
				
				        instance = ctor.Invoke(null) as T;   
                        }
                    }
                }
            }
            return instance;
        }
    }
}

5.Unity脚本单例：

    public class MonoSingleton<T> : MonoBehaviour where T : MonoSingleton<T>
    {
        private static object locker = new object();       
        private static T instance;
        public static T Instance
        {
            get
            {              
                if (instance == null)
                {
                    lock (locker)
                    {                        
                        instance = FindObjectOfType<T>();
                        if (instance == null)
                        {
                            new GameObject("Singlton_" + typeof(T)).AddComponent<T>();//立即执行Awake
                        }
                        else
                        {
                            instance.Init();
                        }
                    }
                }
                return instance;
            }
        }
       
        public bool isDontDestroy;      
        protected void Awake()
        {
            if (instance == null)
            {
                instance = this as T;
                Init();
            }
        }
        
        public virtual void Init()
        {
            if (isDontDestroy)
                DontDestroyOnLoad(gameObject);
        }
    }

6.另一种Unity脚本单例：abstract可以让脚本不能添加到GameObject上。

public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoSingleton<T>
{
    private static T instance = null;   

    static MonoSingleton()
    {
        var go = new GameObject($"MonoSingleton_{typeof(T)}");
        instance = go.AddComponent<T>();
        DontDestroyOnLoad(go);
    }

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