La mejor manera de usar Singletons en la unidad [cerrado]

Me pregunto cuál es la forma correcta de usar la instancia de singleton: cuando creo una clase singleton llamada "Administrador" y contiene una variable int llamada "valor" y tengo otra clase llamada "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);
            }
        }
    }

Entonces dentro de mi clase A puedo hacer una instancia del singleton como esta: // ejemplo pseudocódigo clase pública 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; 
        }
    }

Entonces, mi problema es: ¿debo crear una instancia global y luego usar esa instancia como en la primera o debo usar el segundo ejemplo?

¿Ambos son iguales en términos de consumo de memoria y eficiencia? ¿O hay otra forma de usar singletons?

Confirmo la respuesta de Ruzihm (y también estoy de acuerdo con el comentario de derHugo, personalmente prefiero SO y hago referencia a ellos cuando sea necesario. Mucho más limpio que el enfoque directo Singleton o DI).

Para ser específico, el acceso al miembro de la instancia manager.Instance.valuees más lento y también requiere una mayor asignación de memoria en el montón, por lo que perjudica tanto el uso de la memoria como el rendimiento de la velocidad. (Problemas de rendimiento muy pequeños, pero aún así).

También hay más margen de mejora en el singleton, especialmente si no necesita que se derive de MonoBehaviour.

Usted puede:

1. Asegúrese de que esté construido también si olvida agregarlo en la escena
2. Hágalo seguro para subprocesos (no requerido por la unidad, generalmente)
3. Impleméntelo de manera perezosa (significa que lo crea solo cuando lo necesita)
4. Además, como regla general, es mejor sellar la clase singleton para mejorar el rendimiento (nuevamente, una mejora realmente leve cuando usa métodos virtuales)

Esta sería la implementación (considerando que usa Managercomo instancia auxiliar y YourManagerMonosi necesita una lógica de monocomportamiento:

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);
        }
    }
}

Un gran artículo sobre la implementación de singleton para C # por Jon Skeet (usé la implementación 4).

EDITAR:
De nuevo, estoy de acuerdo con derHugo (en el nuevo comentario sobre esta respuesta). Mi ejemplo se usa para mostrar una perspectiva interesante y ofrecer tanto rendimiento como pueda, pero si solo necesita un Monobehaviour con solo los puntos 1 y 3, puede continuar con una implementación genérica de singleton de Unify Community (solo recuerde establecer la clase final como sellada para ayudar al compilador).

Instancees un campo estático, por lo que debe obtener sus referencias al singleton con Manager.Instance.

Manager.Instancees una instancia accesible globalmente porque es estática pública. No existe una variable global en C #.

Acceder a un campo estático directamente por el nombre de la clase es definitivamente mejor que hacer una segunda instancia como un campo en A y luego acceder a la instancia estática usándola.

Para Singletons que desea que existan en una sola escena, uso:

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;
        }
    }
}

Y luego hereda su clase, así:

public class MyManager : SceneSingleton<MyManager>

Si necesita que su singleton se mantenga vivo entre todas las escenas, intente usar esto:

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()
   { }
}