O que é o padrão de projeto Singleton ?

O Singleton é um padrão de projeto ou design pattern do tipo criação que garante que haverá uma única instância para um tipo de objeto. Tal design pattern pode ser útil  no desenvolvimento de jogos para garantir instancias únicas de objetos como GameManager, Inventory, CoinManager e etc. 

 

 

Exemplo de singleton em C# no Unity 

 

public class GameManager : MonoBehavior {
    private static GameManager _instance;

    public static GameManager instance { get { return _instance; } }


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

 

 

Exemplo de Singleton com Generics

A principal vantagem de utilizar este tipo de implementação é que você não terá que implementar toda vez o Singleton em uma classe bastando apenas herdar esta classe. 

 

 using UnityEngine;
 /// <Summary>
 /// Be aware this will not Prevent the non singleton constructor
 /// such as `T MYT = new T ();
 ///` To Prevent que, add `protected T () {}` To your singleton class.
 ///
 /// As a note, this is made the MonoBehaviour because we need coroutines.
 /// </ Summary>


 public class Singleton < 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) + +"Will not create again - returning null."
"' Already destroyed on application quit.");
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 shouldnt never be more than one singleton" + "Reopening the scene might fix it.");
_instance
return;
}
If(_instance == null) {
GameObject 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, Singleton is only destroyed when application quits.
/// If any script calls Instance after it Have Been destroyed,
/// it will create a ghost buggy object que will stay on the scene
/// Editor 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;
}
}


}
}

Como usar o Singleton Genérico 

public class Manager: Singleton <Manager> {
	 protected Manager () {} // guarantee this will be always the only singleton - can not use the constructor!

	 public string myGlobalVar = "whatever";
 } 

 

Singletor vs classes, métodos e parâmetros estáticos

É possível ter um resultado semelhante do padrão de projeto Singleton usando classes, métodos e parâmetros estáticos, porém há algumas vantagens em usar o Singleton como listado abaixo: 

1. Singleton permite usar Herança enquanto classes, métodos e parâmetros estáticos não.

2. Singleton permite implementar Interfaces.

 



Referência:

https://www.tutorialspoint.com/design_pattern/singleton_pattern.htm

http://wiki.unity3d.com/index.php/Singleton

https://github.com/Naphier/unity-design-patterns