使用 MonoBehavior 的构造函数的 Unity3D Singleton

Question

I have several MonoBehavior subclasses that need to be a Singleton however assigning an Instance property in Awake() is too late for some classes and results in race conditions so I was wondering is there anything that speaks against assigning Instance in a private c-tor, like this:

public class Foo: MonoBehaviour
{
    public static Foo Instance { get; private set; }

    private Foo()
    {
        Instance = this;
    }
}

Or are there any negative side effects to this approach that I need to be aware of?

Answer 1

I agree with Lorek's answer but there is one problem with it.

You shouldn't use the constructor of a MonoBehavior as that itself has undesired behaviors. Since it will not be part of a specific GameObject. So you will have to add it to the Init , Awake or Start method of that Behavior; Or create a new class to contain the logic you want to share. (The new class should not be extended by the MonoBehavior class)

And then create a singleton as Lorek describes above.

You could also change the Script Execution Order to make sure that your MonoBehavior that needs to work as a "singleton" being executed before all other scripts. However, it will be necessary to already have this MonoBehavior attached to an existing GameObject in the scene and not added automatically/by code.

http://docs.unity3d.com/Manual/class-ScriptExecution.html

Answer 2

The technique you are using allows the Instance property to be set more than once, even though if only by other members of the same class. That is a no-no. I would do something like this:

private static readonly Foo instance = new Foo();
public static Foo Instance
{
    get
    {
        return instance;
    }
}

This is a simple way to be certain the singleton variable is set only once. If you want lazy instantiation you could do something like this:

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

But with this technique you could still write to your instance variable more than once. So, you'll need to make sure you always reference the property and not the variable. And if this property is going to be accessed from multiple threads you'll want to prevent race conditions by using a critical section like this:

private static readonly object singletonSection = new object();
private static Foo instance = null;
public static Foo Instance
{
    get
    {
        if (null == instance)
        {
            lock(singletonSection)
            {
                if (null == instance)
                    instance = new Foo();
            } 
        }
        return instance;
    }
}

This is the double-checked locking pattern. You could use regular locking if the code is not accessed much and/or performance is not a problem.

Answer 3

Thanks for the input anyone! I eventually came up with the following method because in my case those Singletons are created via the Editor (from a menu) and the singletons should be components on a container game object.

public static T GetInstance<T>(string containerName) where T : Component
{
    /* Find container or create if it doesn't exist. */
    var container = GameObject.Find(containerName);
    if (container == null) container = new GameObject(containerName);
    /* Get existing instance or create new one if not found. */
    return container.GetComponent<T>() ?? container.AddComponent<T>();
}

Of course it's not perfect either because it relies only on object names. But it works for me.

Answer 4

MonoSingleton class is useful if you need to have a single global MonoBehaviour script accessible from anywhere. Here is the MonoSingleton class:

using UnityEngine;
public class MonoSingleton<T> where T : MonoBehaviour
{
    private static T _instance;
    private static bool isFound;
    private bool createMissingInstance;
    static MonoSingleton()
    {
        isFound = false;
        _instance = null;
    }
    public MonoSingleton(bool createNewInstanceIfNeeded = true)
    {
        this.createMissingInstance = createNewInstanceIfNeeded;
    }
    public T Instance
    {
        get
        {
            if (isFound && _instance)
            {
                return _instance;
            }
            else
            {
                UnityEngine.Object[] objects = GameObject.FindObjectsOfType(typeof(T));
                if (objects.Length > 0)
                {
                    if (objects.Length > 1)
                        Debug.LogWarning(objects.Length + " " + typeof(T).Name + "s were found! Make sure to have only one at a time!");
                    isFound = true;
                    _instance = (T) System.Convert.ChangeType(objects[0], typeof(T));
                    return _instance;
                }
                else
                {
                    Debug.LogError(typeof(T).Name + " script cannot be found in the scene!!!");
                     if (createMissingInstance)
                    {
                        GameObject newInstance = new GameObject(typeof(T).Name);
                        isFound = true;
                        _instance = newInstance.AddComponent<T>();
                        Debug.Log(typeof(T).Name + " was added to the root of the scene");
                        return _instance;
                    }
                    else
                    {
                        isFound = false;
                        return null; // or default(T)
                    }
                }
            }
        }
    }
}

Then define MonoSingletons inside a static class. For example:

public static class Global
{
    public static MonoSingleton<GameProgress> progress = new MonoSingleton<GameProgress>(true); //true means that new GameObject with script GameProgress will be created if it is missing from the scene
    public static MonoSingleton<CharacterController> characterController = new MonoSingleton<CharacterController>(false); //will return null if there is no character controller present in the scene.
}

And then simply access global MonoBehaviors from any script!

Global.progress.Instance.score++;