Unity设计模式之单例模式-Toy模板网

这篇具有很好参考价值的文章主要介绍了Unity设计模式之单例模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Unity设计模式之单例模式

定义

单例模式（Singleton）是设计模式中很常见的一种设计模式，目的是为了让一个类在程序运行期间有且仅有一个实例，且方便全局访问。

实现

1、私有的构造函数。

2、含有一个该类的静态私有对象。

3、静态的公有函数或属性，方便用户创建或者获取它本身的静态私有对象。

适用场景

当项目中的某一个对象，在程序运行的过程中，只有一个对象，可以使用单例模式。

例如：资源管理类，日志管理类等，受项目影响比较小，可以多个项目共同使用。

优缺点

优点

1、单例模式只生成一个实例，限制对象数量，减少内存开支和系统性能消耗。

2、使用方便，提供全局访问的函数或属性。

缺点

1、容易为了使用方便造成过度使用的问题，但并不是要求设计者不使用这个模式，而是在仔细设计和特定的前提下，适当使用。

举例

C# 单例


/// <summary>
/// 一个简单的单例
/// </summary>
public class Test
{
    #region Instance

    private static Test _Instance;
    public static Test Instance
    {
        get
        {
            if (_Instance == null)
            {
                _Instance = new Test();
            }
            return _Instance;
        }
    }

    private Test() { }
    #endregion
}

Unity mono单例

相比于C#单例，mono单例需要注意的是

1、创建对象的时候，需要创建一个相应的对象，然后将脚本添加。

2、对象Awake的时候，需要判断是否已经创建了对象，如果创建了，需要销毁当前对象。

3、我这里在OnDestroy的时候，把静态变量销毁了，是因为有些逻辑里面可能需要销毁这个对象，重新创建。

using UnityEngine;

/// <summary>
/// 一个简单的mono单例
/// </summary>
public class Test : MonoBehaviour
{
    #region Instance
    private static Test _Instance;
    public static Test Instance
    {
        get
        {
            if (!_Instance)
            {
                _Instance = GameObject.FindObjectOfType<Test>();
                if (!_Instance)
                {
                    GameObject obj = new GameObject();
                    _Instance = obj.AddComponent<Test>();
                }
            }
            return _Instance;
        }
    }

    private void Awake()
    {
        if (_Instance)
        {
            Destroy(gameObject);
        }
    }

    private void OnDestroy()
    {
        _Instance = null;
    }
    #endregion
}

通用mono单例

要做一个通用的mono单例，这里我们需要使用泛型来实现一个基类。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// mono单例
/// </summary>
/// <typeparam name="T"></typeparam>
public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoSingleton<T>
{
    protected static T _instance;

    /// <summary>
    /// 是否实例化
    /// </summary>
    public static bool initialized;

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = FindObjectOfType<T>();
                if (FindObjectsOfType<T>().Length > 1)
                {
                    return _instance;
                }
                if (_instance == null)
                {
                    string name = typeof(T).Name;
                    GameObject obj = GameObject.Find(name);
                    if (obj == null)
                    {
                        obj = new GameObject(name);
                    }
                    _instance = obj.AddComponent<T>();
                    DontDestroyOnLoad(obj);
                }
            }
            initialized = true;
            return _instance;
        }
    }

    protected virtual void Awake()
    {
        if (initialized)
        {
            Destroy(gameObject);
        }
    }

    protected virtual void OnDestroy()
    {
        _instance = null;
        initialized = false;
    }
}

实现类

using UnityEngine;

/// <summary>
/// 一个简单的mono单例
/// </summary>
public class Test : MonoSingleton<Test>
{
    public void MonoTest() {
        Debug.Log("test");
    }
}