为什么使用单例模式

  单例模式的效果是系统中对应类只有一个实例对象，根据不同的场景原因各有不同，有的是为了避免多次创建带来的资源开销，有的是为了方便数据的统一处理和保存等等。

经验中可使用单例的情景

• 游戏数据管理器：管理游戏数据如最新的关卡，上次进行关卡的数据等。
• 声音管理器：播放背景音乐或者点击音效。
• 内购管理：管理内购。
• 广告管理器：管理广告的显示和隐藏，统一管理广告的各种回调如广告的关闭。
• 更多

实践

  当单例无需使用MonoBehaviour的特性如开启协程的时候，可以直接使用C#的单例。

C#单例(饿汉)

using System;
public class Singleton{
  private object _lock = new object();
  private Singleton _instance = null;
  
  public static Instance{
    get{
      if(_instance==null){
            lock(_lock){
                 if(_instance==null){
                       
                        _instance = new Singleton();
                    
                  }
  
            }
        }

      return _instance;
    }

  }

}

MonoBehaviour单例

   我在网上找到一个MonoBehaviour单例的写法，如下所示。

using UnityEngine;
public abstract class SingletonMono<T> : MonoBehaviour where T : MonoBehaviour
    {
        private static T _instance;

        private static object _lock = new object();

        public static T Instance
        {
            get
            {
                if (applicationIsQuitting)
                {
                    Debug.LogWarning("[Singleton] Instance '" + typeof(T) +
                                     "' already destroyed on application quit." +
                                     " Won't create again - returning null.");
                    return null;
                }

                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = (T) FindObjectOfType(typeof(T));

                        if (FindObjectsOfType(typeof(T)).Length > 1)
                        {
                            Debug.LogError("[Singleton] Something went really wrong " +
                                           " - there should never be more than 1 singleton!" +
                                           " Reopening the scene might fix it.");
                            return _instance;
                        }

                        if (_instance == null)
                        {
                            GameObject singletonPrefab = null;
                            GameObject singleton = null;

                            // Check if exists a singleton prefab on Resources Folder.
                            // -- Prefab must have the same name as the Singleton SubClass
                            singletonPrefab =
                                (GameObject) Resources.Load("Prefabs/" + typeof(T).ToString(), typeof(GameObject));

                            // Create singleton as new or from prefab
                            if (singletonPrefab != null)
                            {
                                singleton = Instantiate(singletonPrefab);
                                _instance = singleton.GetComponent<T>();
                            }
                            else
                            {
                                singleton = new GameObject();
                                _instance = singleton.AddComponent<T>();
                            }

                            singleton.name = "(singleton) " + typeof(T).ToString();

                            DontDestroyOnLoad(singleton);

                            Debug.Log("[Singleton] An instance of " + typeof(T) +
                                      " is needed in the scene, so '" + singleton +
                                      "' was created with DontDestroyOnLoad.");
                        }
                        else
                        {
                            Debug.Log("[Singleton] Using instance already created: " +
                                      _instance.gameObject.name);
                        }
                    }

                    return _instance;
                }
            }
        }


        private static bool applicationIsQuitting = false;

        /// <summary>
        /// When Unity quits, it destroys objects in a random order.
        /// In principle, a Singleton is only destroyed when application quits.
        /// If any script calls Instance after it have been destroyed, 
        ///   it will create a buggy ghost object that will stay on the Editor scene
        ///   even after stopping playing the Application. Really bad!
        /// So, this was made to be sure we're not creating that buggy ghost object.
        /// </summary>
        public void OnDestroy()
        {
            applicationIsQuitting = true;
        }


        void Awake()
        {
            if (_instance != null && _instance != this)
            {
                Destroy(this.gameObject);
            }
            else
            {
                Init();
            }
            DontDestroyOnLoad(this.gameObject);
        }

        protected virtual void Init()
        {
        }
    }

其中下列语句是重要，可要到Resource目录下加载与类名相对应的Prefab预制体

singletonPrefab =(GameObject)Resources.Load(typeof(T).ToString(),typeof(GameObject)); 

Init()方法在生命周期函数Awake()中调用，可重写该函数扩展操作。

 protected virtual void Init()
  {
  }

我的实践

SoundManager C#脚本

  对于声音管理器，我定义了下面显示的SoundManager用于声音的管理。SoundManager继承了上述的SingletonMono类。

using System.Collections;
using System.Collections.Generic;
using Model;
using UnityEngine;
using zbUtil;

public class SoundManager : SingletonMono<SoundManager>
{
    public AudioClip[] AudioClips;
    private AudioSource _audioSource;

    public enum SoundType
    {
        Click = 0,
        CorrectLetter,
        Coin,
        Win,
        Move,
    }

    protected override void Init()
    {
        base.Init();
        _audioSource = GetComponent<AudioSource>();
    }

    private bool _soundOn
    {
        get { return GameDataManager.getInstance().IsSoundOn(); }
    }

    public void Play(SoundType type)
    {
        if (!_soundOn)
        {
            return;
        }
        _audioSource.PlayOneShot(AudioClips[(int) type]);
    }
}

SoundManager的预制体

• 存储目录
• Inspector

使用

SoundManager.Instance.Play(SoundManager.SoundType.Click);