"unity3d" 태그로 연결된 43개 게시물개의 게시물이 있습니다.

// Bad code! Do not use!
public sealed class Singleton
{
    private static Singleton instance=null;

    private Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            if (instance==null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }
}

public sealed class Singleton
{
    private static Singleton instance = null;
    private static readonly object padlock = new object();

    private Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}

using System;  
using System.Reflection;  

public class Singleton<T> where T : class  
{   
   private static object _syncobj = new object();   
   private static volatile T _instance = null;  

   public static T Instance
   {  
       get  
       {  
           if (_instance == null)  
           {  
               CreateInstance();  
           }  
           return _instance;  
       }  
   }  

   private static void CreateInstance()  
   {   
      lock (_syncobj)  
      {  
          if (_instance == null)  
          {  
              Type t = typeof(T);  

              // Ensure there are no public constructors...  
              ConstructorInfo[] ctors = t.GetConstructors();  
              if (ctors.Length > 0)  
              {  
                  throw new InvalidOperationException(String.Format("{0} has at least one accesible ctor making it impossible to enforce singleton behaviour", t.Name));  
              }  

              // Create an instance via the private constructor  
              _instance = (T)Activator.CreateInstance(t, true);  
           }  
       }      
   }   
}  

using UnityEngine;
using System.Collections;

public class Singleton: MonoBehaviour
{
    public static Singleton instance = null;              //Static instance of GameManager which allows it to be accessed by any other script.

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

using UnityEngine;
using System.Collections;

/// <summary>
/// Be aware this will not prevent a non singleton constructor
///   such as `T myT = new T();`
/// To prevent that, add `protected T () {}` to your singleton class.
/// As a note, this is made as MonoBehaviour because we need Coroutines.
/// </summary>
public abstract class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T _instance = null;
    private static object _syncobj = new object();
    private static bool appIsClosing = false;

    public static T Instance
    {
        get
        {
            if (appIsClosing)
                return null;

            lock (_syncobj)  
            {  
                if (_instance == null)
                {
                    T[] objs = FindObjectsOfType<T>();

                    if (objs.Length > 0)
                        _instance = objs[0];

                    if (objs.Length > 1)
                        Debug.LogError("There is more than one " + typeof(T).Name + " in the scene.");

                    if (_instance == null)
                    {
                        string goName = typeof(T).ToString();
                        GameObject go = GameObject.Find(goName);
                        if (go == null)
                            go = new GameObject(goName);
                        _instance = go.AddComponent<T>();
                    }
                }
                return _instance;
            }
        }
    }

    /// <summary>
    /// When Unity quits, it destroys objects in a random order.
    /// In principle, a Singleton is only destroyed when application quits.
    /// If any script calls Instance after it have been destroyed,
    ///   it will create a buggy ghost object that will stay on the Editor scene
    ///   even after stopping playing the Application. Really bad!
    /// So, this was made to be sure we're not creating that buggy ghost object.
    /// </summary>
    protected virtual void OnApplicationQuit()
    {
        // release reference on exit
        appIsClosing = true;
    }
}

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

    public string myGlobalVar = "whatever";
}