L'unité singleton gestionnaire de classes

Comme toujours: ça dépend. J'utilise les singletons de deux sortes, les composants reliés à GameObject et autonome classes ne proviennent pas de l' MonoBehaviour. IMO l'ensemble de la question est de savoir comment les instances liées à la lifcycle des scènes, des objets de jeu, ... Et ne pas oublier parfois, il est plus pratique de disposer d'un composant en particulier référence à d'autres MonoBehaviour objets est plus facile et plus sûr.

1. Il y a des classes qui a juste besoin de fournir certaines valeurs, comme par exemple une config classe qui en a besoin pour charger les paramètres de la couche de persistance, lorsqu'il est appelé. Je conçois ces classes aussi simple singletons.
2. D'autre part, certains objets ont besoin de savoir quand une scène est commencé c'est à dire Start est appelé ou qui ont à effectuer des actions dans Update ou d'autres méthodes. Puis-je les mettre en œuvre, de composants et de les attacher à un objet de jeu qui survit chargement de nouvelles scènes.

J'ai conçu à base de composants singletons (type 2) avec deux parties: une persistante GameObject appelé Main, qui détient tous les composants et d'une télévision singleton (type 1) appelé MainComponentManager pour la gérer. Certains le code de démonstration:

public class MainComponentManger {
    private static MainComponentManger instance;
    public static void CreateInstance () {
        if (instance == null) {
            instance = new MainComponentManger ();
            GameObject go = GameObject.Find ("Main");
            if (go == null) {
                go = new GameObject ("Main");
                instance.main = go;
                //important: make game object persistent:
                Object.DontDestroyOnLoad (go);
            }
            //trigger instantiation of other singletons
            Component c = MenuManager.SharedInstance;
            //...
        }
    }

    GameObject main;

    public static MainComponentManger SharedInstance {
        get {
            if (instance == null) {
                CreateInstance ();
            }
            return instance;
        }
    }

    public static T AddMainComponent <T> () where T : UnityEngine.Component {
        T t = SharedInstance.main.GetComponent<T> ();
        if (t != null) {
            return t;
        }
        return SharedInstance.main.AddComponent <T> ();
    }

Maintenant d'autres célibataires qui veulent s'inscrire comme Main composant simplement ressembler à:

public class AudioManager : MonoBehaviour {
    private static AudioManager instance = null;
    public static AudioManager SharedInstance {
        get {
            if (instance == null) {
                instance = MainComponentManger.AddMainComponent<AudioManager> ();
            }
            return instance;
        }
    }

Si cette classe est juste pour l'accès à des variables globales, alors vous n'avez pas vraiment besoin d'un pattern singleton pour cela, ou utiliser un GameObject.

Il suffit de créer une classe public static membres.

public class Globals
{
    public static int mStatic1 = 0;
    public static float mStatic2 = 0.0f;
    //....etc
}

Les autres solutions sont très bien mais trop si vous avez besoin d'un accès global à des variables.

C'est la configuration que j'ai créé.

D'abord créer ce script:

MonoBehaviourUtility.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.IO;

static public class MonoBehaviourUtility 
{

    static public T GetManager<T>( ref T manager ) where T : MonoBehaviour
    {
        if (manager == null)
        {
            manager = (T)GameObject.FindObjectOfType( typeof( T ) );
            if (manager == null)
            {
                GameObject gameObject = new GameObject( typeof( T ).ToString() );
                manager = (T)gameObject.AddComponent( typeof( T ) );
            }
        }
        return manager;
    }

}

Ensuite dans n'importe quelle classe vous voulez être un singleton ce faire:

public class ExampleManager : MonoBehaviour 
{   
    static public ExampleManager sharedManager 
    {
        get 
        {
            return MonoBehaviourUtility.GetManager<ExampleManager>( ref _sharedManager );
        }
    }   
    static private ExampleManager _sharedManager;       
}

Ici est un simple code à partir de l'Unité Tutoriel. pour une meilleure compréhension ouvrir le lien

using System.Collections.Generic;       //Allows us to use Lists. 

public class GameManager : MonoBehaviour
{

    public static GameManager instance = null;              //Static instance of GameManager which allows it to be accessed by any other script.
    private BoardManager boardScript;                       //Store a reference to our BoardManager which will set up the level.
    private int level = 3;                                  //Current level number, expressed in game as "Day 1".

    //Awake is always called before any Start functions
    void Awake()
    {
        //Check if instance already exists
        if (instance == null)

            //if not, set instance to this
            instance = this;

        //If instance already exists and it's not this:
        else if (instance != this)

            //Then destroy this. This enforces our singleton pattern, meaning there can only ever be one instance of a GameManager.
            Destroy(gameObject);    

        //Sets this to not be destroyed when reloading scene
        DontDestroyOnLoad(gameObject);

        //Get a component reference to the attached BoardManager script
        boardScript = GetComponent<BoardManager>();

        //Call the InitGame function to initialize the first level 
        InitGame();
    }

    //Initializes the game for each level.
    void InitGame()
    {
        //Call the SetupScene function of the BoardManager script, pass it current level number.
        boardScript.SetupScene(level);

    }



    //Update is called every frame.
    void Update()
    {

    }