Meilleure façon d'utiliser les singletons dans l'unité

Instance est un champ statique donc vous devriez obtenir vos références au singleton avec Manager.Instance .

Manager.Instance est une instance accessible globalement car elle est publique statique. Il n'y a pas de variable globale en C #.

Accéder à un champ statique directement par le nom de la classe est certainement mieux que de créer une deuxième instance en tant que champ dans A, puis d'accéder à l'instance statique en l'utilisant.

Je confirme la réponse de Ruzihm (et je suis également d'accord avec le commentaire de derHugo, je préfère personnellement SO et je les référence si nécessaire. Beaucoup plus propre que l'approche directe de Singleton ou DI).

Pour être précis, accéder au gestionnaire du membre de l'instance .Instance.value est plus lent et nécessite également une allocation supplémentaire de mémoire sur le tas, ce qui nuit à la fois à l'utilisation de la mémoire et aux performances de vitesse. (Très petits problèmes de performances, mais quand même.)

Il y a aussi d'autres possibilités d'amélioration sur le singleton, surtout si vous n'avez pas besoin qu'il dérive de MonoBehaviour.

Vous pouvez:

1. Assurez-vous qu'il est également construit si vous oubliez de l'ajouter à la scène
2. Rendez-le thread-safe (non requis par unité, généralement)
3. Mettez-le en œuvre paresseusement (cela signifie que vous ne le créez que lorsque vous en avez besoin)
4. De plus, en règle générale, il est préférable de sceller la classe singleton pour améliorer les performances (encore une fois une très légère amélioration lorsque vous utilisez des méthodes virtuelles)

Ce serait l'implémentation (en considérant que vous utilisez le Manager comme instance d'assistance et YourManagerMono si vous avez besoin d'une logique de monobéissance:

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 excellent article sur l'implémentation de singleton pour C # par Jon Skeet (j'ai utilisé mise en œuvre 4).

MODIFIER:
Encore une fois, je suis d'accord avec derHugo (dans le nouveau commentaire sur cette réponse). Mon exemple est utilisé pour montrer une perspective intéressante et pour offrir autant de performances que possible, mais si vous avez juste besoin d'un Monobehaviour avec juste les points 1 et 3, vous pouvez continuer avec un implémentation générique de singleton de Unify Community (n'oubliez pas de définir la classe de fin comme scellée pour aider le compilateur).

p >

Pour les Singletons que vous voulez exister dans une seule scène, j'utilise:

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

Et puis j'hérite de votre classe, comme ceci:

public class MyManager : SceneSingleton<MyManager>