Best way to use Singletons in unity

Question

I am wondering which is the right way to use singleton instance: when I create a singleton Class called "Manager" and it contains an int variable called "value" and I have a another class called "A"...

    //singleton class
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    public class Manager : MonoBehaviour {
        public static Manager Instance{ set; get;}
        public int value;
        private void Awake () {
            if (Instance == null) {
                Instance = this;
                DontDestroyOnLoad (this.gameObject);
            } else {
                Destroy (gameObject);
            }
        }
    }

So inside my A class I can make a instance of the singleton like this: // example pseudo code public class A {

        // First
        // using as a global variable
        Manager manager;

        //------------------------------------

        Public void tstOne(){
             // First
             // using that global variable
             manager.Instance.value = 0;

             // Second
             // or this way
             Manager.Instance.value = 0; 
        }
        Public void tstTwo(){
             // First
             // using that global variabl
             manager.Instance.value = 1;

             // Second
             // or this way
             Manager.Instance.value = 1; 
        }
    }

So my problem is - should I create A global instance and then use that instance like in first one or should I use the second example?

Are they both are same in terms of memory consumption and efficiency? Or is there another way to use singletons?

Answer 1

Instance is a static field so you should get your references to the singleton with Manager.Instance.

Manager.Instance is a globally accessible instance because it's public static. There's no such thing as a global variable in C#.

Accessing a static field directly by the class name is definitely better than making a second instance as a field in A and then accessing the static instance using it.

Answer 2

I confirm Ruzihm answer (and I also agree with derHugo comment, I personally prefer SO and reference them where required. Much cleaner than Singleton or DI direct approach).

To be specific accessing the instance member manager.Instance.value is slower and also requires further memory allocation on the heap so it hurts both memory usage and speed performance. (Very small performance issues, but still.)

There's also further room of improvement on the singleton, especially if you do not require it to derive from MonoBehaviour.

You can:

1. Make sure it is build also if you forget to add it in the scene
2. Make it thread safe (not required by unity, usually)
3. Implement it lazily (means you create it only when you need it)
4. Also, as a general rule is better to seal the singleton class for improved performance (again really slight improvement when you use virtual methods)

This would be the implementation (considering you use the Manager as helper instance and YourManagerMono if you require monobehaviour logic:

public class YourManagerMono : MonoBehaviour
{
}

public sealed class Manager
{
    private static readonly Manager instance = new Manager();
    //use a gameobject to relate it in the scene
    private YourManagerMono monoManager;

    public static Manager Instance => instance;

    // Explicit static constructor to tell C# compiler
    // not to mark type as beforefieldinit
    static Manager() {}

    private Manager()
    {
        //find or create a manager
        monoManager = GameObject.FindWithTag("Manager").GetComponent<YourManagerMono>();
        if (monoManager == null)
        {
            monoManager = new GameObject().AddComponent<YourManagerMono>();
            monoManager.gameObject.tag = "Manager";
            Object.DontDestroyOnLoad(monoManager.gameObject);
        }
    }
}

A great article about singleton implementation for C# by Jon Skeet (I used implementation 4).

EDIT:
Again I agree with derHugo (in the new comment on this answer). My example is used to show an interesting prospective and to offer as much performance as I can, but if you just require a Monobehaviour with just point 1 and 3 you may go ahead with a generic implementation of singleton from Unify Community (just remember to set the end class as sealed to help the compiler).

Answer 3

For Singletons that you want to exist in one scene only, I use:

public class SceneSingleton<T> : MonoBehaviour
    where T : SceneSingleton<T>
{
    static T s_instance = null;

    public static T Instance
    {
        get
        {
            if (s_instance == null)
            {
                s_instance = Object.FindObjectOfType<T>();
            }

            return s_instance;
        }
    }
}

And then inherit your class from it, like this:

public class MyManager : SceneSingleton<MyManager>

If you need your singleton to stay alive between all scenes, try to use this:

public class GlobalSingleton<T> : MonoBehaviour
    where T : GlobalSingleton<T>
{
    static T s_instance = null;

    public static T Instance
    {
        get
        {
            if (s_instance == null)
            {
                GameObject prefab = Resources.Load(typeof(T).Name) as GameObject;

                if (prefab == null || prefab.GetComponent<T>() == null)
                {
                    Debug.LogError("Prefab for game manager " + typeof(T).Name + " is not found");
                }
                else
                {
                    GameObject gameManagers = GameObject.Find("GameManagers");
                    if (gameManagers == null)
                    {
                        gameManagers = new GameObject("GameManagers");
                        DontDestroyOnLoad(gameManagers);
                    }

                    GameObject gameObject = Instantiate(prefab);
                    gameObject.transform.parent = gameManagers.transform;

                    s_instance = gameObject.GetComponent<T>();
                    s_instance.Init();
                }
            }

            return s_instance;
        }
    }

   protected virtual void Init()
   { }
}