Unity: Static reference disappears after domain reload (editor reload)

Question

I have a C# script that boils down to this:

public class SingletonTest : MonoBehaviour
{
    public static SingletonTest Singleton = null;
    public int Value = 42;

    void Start() {
        Singleton = this;
    }
}

This runs fine at first, but my issue is that when I edit a script and then click back into the Unity editor/IDE, I get a whole string of NullReferenceExceptions for the line SingletonTest.Singleton.Value in some other class.

I googled around a bit and this editor reload seems to trigger a process called Domain Reloading (see also). Apparently domain reloading also resets all static fields which explains my error message. I tried a few workarounds suggested on that page but none of them work:

using UnityEngine;

public class SingletonTest : MonoBehaviour
{
    public static SingletonTest Singleton = null;
    public int Value = 42;

    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] 
    static void StaticStart()
    {
        var arr = FindObjectsOfType<SingletonTest>();
        Debug.Log($"Len arr: {arr.Length}");  // This is 0! :(
        if (arr.Length > 0)
            Singleton = arr[0];
    }

    void Start()
    {
        Singleton = this;
    }

    void OnAfterDeserialize()
    {
        Singleton = this;
    }
}

I am able to kind-of get it to work by putting Singleton = this in the Update() function but that solution is ugly, and still gives me a NullReferenceException on the first frame after reload.

(Please don't suggest making the Value field static, that is just a simplified example, I do need/want a singleton class)

Answer 1

Consider using a private constructor to force the static field to be initialized with a value when the SingletonTest object is created by the CLR.

Although Unity normally doesn't recommend using constructors with MonoBehvior because they're supposed to be scripts(among other Mono and Unity Quirks). I found this works great for my use cases for singletons(such as static editor Dictionary<T>s that hold loaded metadata etc...

public class SingletonTest : MonoBehaviour
{
    public static SingletonTest Singleton { get; set; } = null;

    public int Value = 42;

    protected SingletonTest()
    {
        Singleton ??= this;
    }
}

Alternatively consider avoiding the assumption that the given field/property is never null.

For example:

void Awake()
{
     // call method example ↓ (null-coalescing operator)
     SingletonTest.Singleton?.Invoke("Something");
     
     // property example
     if(SingletonTest.Singleton != null)
     {
         Debug.Log($"{SingletonTest.Singleton.gameObject.Name}");
     }
}

Answer 2

First of all: You didn't implement any Singleton so far.

The main concept of "Singleton" as the name suggests is to make sure there exists one single instance. In your code there is no control if maybe another instance overwrites the instance field.

Singleton is then only abused to also have public access.

The way you have it is also quite dangerous: Any other script could simply set the field to something else.

When/If I do such thing I would usually use a lazy initialization via property like e.g.

public class SingletonTest : MonoBehaviour
{
    // Here you store the actual instance
    private static SingletonTest _instance;

    // Only allow read access for others
    public static SingletonTest Instance
    {
        get
        {
            // If instance is assigned and exists return it right away
            if(_instance) return _instance;

            // Otherwise try to find one in the scene
            _instance = FindObjectOfType<SingletonTest>();

            // Found one? Nice return it
            // this would only happen if this getter is called before the 
            // Awake had its chance to set the instance
            if(_instance) return _instance;

            // Otherwise create an instance now 
            // this will only happen if you forgot to put one into your scene
            // it is not active/enabled
            // or it was destroyed for some reason
            _instance = new GameObject("SingletonTest").AddComponent<SingletonTest>();

            return _instance;
        }
    }

    public int Value = 42;

    private void Awake() 
    {
        // If another instance exists already then destroy this one
        // This is the actual Singleton Pattern
        if(_instance && _instance != this)
        {
            Destroy(gameObject);
            return;
        }

        _instance = this;

        // Optional: also make sure this instance survives any scene changes
        DontDestroyOnLoad(gameObject);
    }
}

Then if you need such a thing also in the Editor, not in PlayMode/runtime you could use [InitializeOnLoadMethod] (NOT [RuntimeInitializeOnLoadMethod] which as the name suggests is for runtime/PlayMode).

Of course you could have both like

#if UNITY_EDITOR
    [UnityEditor.InitializeOnLoadMethod]
#endif
    [RuntimeInitializeOnLoadMethod]
    private static void Init()
    {
        Debug.Log("Initialized", Instance);
    }

The simple access to the Instance property already makes sure it is initialized.