Revised the singletons implementation

Added PersistentMonoSingleton which is persistent across scenes
Made MonoSingleton non-persistent
Added ISingleton interface for unifying the methods and calls
Add assembly definition
Added namespace (UnityCommunity.UnitySingleton)

Author: hasanbayatme

.vsconfig

@@ -0,0 +1,6 @@
+{
+  "version": "1.0",
+  "components": [
+    "Microsoft.VisualStudio.Workload.ManagedGame"
+  ]
+}

Assets/Scripts/GameManager.cs

@@ -0,0 +1,21 @@
+using System.Collections;
+using System.Collections.Generic;
+
+using UnityEngine;
+
+namespace UnityCommunity.UnitySingleton
+{
+
+    /// <summary>
+    /// The singleton interface.
+    /// </summary>
+    public interface ISingleton
+    {
+
+        public void InitializeSingleton();
+
+        public void ClearSingleton();
+
+    }
+
+}

Assets/Scripts/MonoSingleton.cs

@@ -0,0 +1,155 @@
+using System.Collections;
+using System.Collections.Generic;
+
+using UnityCommunity.UnitySingleton;
+
+using UnityEngine;
+
+namespace UnityCommunity.UnitySingleton
+{
+
+    /// <summary>
+    /// The basic MonoBehaviour singleton implementation, this singleton is destroyed after scene changes, use <see cref="PersistentMonoSingleton{T}"/> if you want a persistent and global singleton instance.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class MonoSingleton<T> : MonoBehaviour, ISingleton where T : MonoSingleton<T>
+    {
+
+        #region Fields
+
+        /// <summary>
+        /// The instance.
+        /// </summary>
+        private static T instance;
+
+        /// <summary>
+        /// The initialization status of the singleton's instance.
+        /// </summary>
+        private SingletonInitializationStatus initializationStatus = SingletonInitializationStatus.None;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets the instance.
+        /// </summary>
+        /// <value>The instance.</value>
+        public static T Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = FindObjectOfType<T>();
+                    if (instance == null)
+                    {
+                        GameObject obj = new GameObject();
+                        obj.name = typeof(T).Name;
+                        instance = obj.AddComponent<T>();
+                        instance.OnMonoSingletonCreated();
+                    }
+                }
+                return instance;
+            }
+        }
+
+        /// <summary>
+        /// Gets whether the singleton's instance is initialized.
+        /// </summary>
+        public virtual bool IsInitialized => this.initializationStatus == SingletonInitializationStatus.Initialized;
+
+        #endregion
+
+        #region Unity Messages
+
+        /// <summary>
+        /// Use this for initialization.
+        /// </summary>
+        protected virtual void Awake()
+        {
+            if (instance == null)
+            {
+                instance = this as T;
+
+                // Initialize existing instance
+                InitializeSingleton();
+            }
+            else
+            {
+
+                // Destory duplicates
+                if (Application.isPlaying)
+                {
+                    Destroy(gameObject);
+                }
+                else
+                {
+                    DestroyImmediate(gameObject);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Protected Methods
+
+        /// <summary>
+        /// This gets called once the singleton's instance is created.
+        /// </summary>
+        protected virtual void OnMonoSingletonCreated()
+        {
+
+        }
+
+        protected virtual void OnInitializing()
+        {
+
+        }
+
+        protected virtual void OnInitialized()
+        {
+
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        public virtual void InitializeSingleton()
+        {
+            if (this.initializationStatus != SingletonInitializationStatus.None)
+            {
+                return;
+            }
+
+            this.initializationStatus = SingletonInitializationStatus.Initializing;
+            OnInitializing();
+            this.initializationStatus = SingletonInitializationStatus.Initialized;
+            OnInitialized();
+        }
+
+        public virtual void ClearSingleton() { }
+
+        public static void CreateInstance()
+        {
+            DestroyInstance();
+            instance = Instance;
+        }
+
+        public static void DestroyInstance()
+        {
+            if (instance == null)
+            {
+                return;
+            }
+
+            instance.ClearSingleton();
+            instance = default(T);
+        }
+
+        #endregion
+
+    }
+
+}

Assets/Scripts/SceneSingleton.meta renamed to Assets/Scripts/Runtime.meta

@@ -0,0 +1,33 @@
+using System.Collections;
+using System.Collections.Generic;
+
+using UnityCommunity.UnitySingleton;
+
+using UnityEngine;
+
+namespace UnityCommunity.UnitySingleton
+{
+
+    /// <summary>
+    /// This singleton is persistent across scenes by calling <see cref="UnityEngine.Object.DontDestroyOnLoad(Object)"/>.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class PersistentMonoSingleton<T> : MonoSingleton<T> where T : MonoSingleton<T>
+    {
+
+        #region Protected Methods
+
+        protected override void OnInitializing()
+        {
+            base.OnInitializing();
+            if (Application.isPlaying)
+            {
+                DontDestroyOnLoad(gameObject);
+            }
+        }
+
+        #endregion
+
+    }
+
+}