Update CppExplorer.cs

* Fix for a crash that can occur when inspecting unsupported Dictionaries
* Added a scroll bar to the REPL console input area, fixes the issue of the code just being cut off when it goes too long.

README.md

@@ -1,4 +1,4 @@
-# CppExplorer [![Version](https://img.shields.io/badge/MelonLoader-0.2.7.1-green.svg)]()
+# CppExplorer [![Version](https://img.shields.io/badge/MelonLoader-0.2.7.1-green.svg)](https://github.com/HerpDerpinstine/MelonLoader)
 
 <p align="center">
   <img align="center" src="https://sinai-dev.github.io/images/thumbs/02.png">

src/CachedObjects/CacheObjectBase.cs

@@ -4,7 +4,6 @@ using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
-using Explorer.CachedObjects;
 using MelonLoader;
 using UnhollowerBaseLib;
 using UnityEngine;
@@ -15,16 +14,16 @@ namespace Explorer
     {
         public object Value;
         public string ValueTypeName;
+        public Type ValueType;
 
-        // Reflection Inspector only
         public MemberInfo MemInfo { get; set; }
         public Type DeclaringType { get; set; }
         public object DeclaringInstance { get; set; }
-        public string ReflectionException { get; set; }
-
         public int PropertyIndex { get; private set; }
         private string m_propertyIndexInput = "0";
 
+        public string ReflectionException { get; set; }
+
         public string RichTextName => m_richTextName ?? GetRichTextName();
         private string m_richTextName;
 
@@ -80,11 +79,7 @@ namespace Explorer
         {
             Type type = null;
 
-            if (obj != null)
-            {
-                type = ReflectionHelpers.GetActualType(obj);
-            }
-            else if (memberInfo != null)
+            if (memberInfo != null)
             {
                 if (memberInfo is FieldInfo fi)
                 {
@@ -99,6 +94,10 @@ namespace Explorer
                     type = mi.ReturnType;
                 }
             }
+            else if (obj != null)
+            {
+                type = ReflectionHelpers.GetActualType(obj);
+            }
 
             if (type == null)
             {
@@ -115,6 +114,11 @@ namespace Explorer
         {
             CacheObjectBase holder;
 
+            // This is pretty ugly, could probably make a cleaner implementation.
+            // However, the only cleaner ways I can think of are slower and probably not worth it. 
+
+            // Note: the order is somewhat important.
+
             if (memberInfo is MethodInfo mi)
             {
                 if (CacheMethod.CanEvaluate(mi))
@@ -154,20 +158,22 @@ namespace Explorer
             {
                 holder = new CacheRect();
             }
-            else if (ReflectionHelpers.IsArray(valueType) || ReflectionHelpers.IsList(valueType))
-            {
-                holder = new CacheList();
-            }
+            // must check this before IsEnumerable
             else if (ReflectionHelpers.IsDictionary(valueType))
             {
                 holder = new CacheDictionary();
             }
+            else if (ReflectionHelpers.IsEnumerable(valueType) || ReflectionHelpers.IsCppList(valueType))
+            {
+                holder = new CacheList();
+            }
             else
             {
                 holder = new CacheOther();
             }
 
             holder.Value = obj;
+            holder.ValueType = valueType;
             holder.ValueTypeName = valueType.FullName;
 
             if (memberInfo != null)

src/CachedObjects/Object/CacheDictionary.cs

@@ -1,34 +1,357 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using MelonLoader;
 using UnityEngine;
+using System.Reflection;
+using UnhollowerBaseLib;
 
 namespace Explorer
 {
-    public class CacheDictionary : CacheObjectBase
+    public class CacheDictionary : CacheObjectBase, IExpandHeight
     {
+        public bool IsExpanded { get; set; }
+        public float WhiteSpace { get; set; } = 215f;
+        public float ButtonWidthOffset { get; set; } = 290f;
 
+        public PageHelper Pages = new PageHelper();
 
-        public override void Init()
+        private CacheObjectBase[] m_cachedKeys;
+        private CacheObjectBase[] m_cachedValues;
+
+        public Type TypeOfKeys
         {
-            //base.Init();
+            get
+            {
+                if (m_keysType == null) GetGenericArguments();
+                return m_keysType;
+            }
+        }
+        private Type m_keysType;
 
-            Value = "Unsupported";
+        public Type TypeOfValues
+        {
+            get
+            {
+                if (m_valuesType == null) GetGenericArguments();
+                return m_valuesType;
+            }
+        }
+        private Type m_valuesType;
+
+        public IDictionary IDict
+        {
+            get => m_iDictionary ?? (m_iDictionary = Value as IDictionary) ?? Il2CppDictionaryToMono();
+            set => m_iDictionary = value;
+        }
+        private IDictionary m_iDictionary;
+
+        // ========== Methods ==========
+
+        // This is a bit janky due to Il2Cpp Dictionary not implementing IDictionary.
+        private IDictionary Il2CppDictionaryToMono()
+        {
+            // note: "ValueType" is the Dictionary itself, TypeOfValues is the 'Dictionary.Values' type.
+
+            // make generic dictionary from key and value type
+            var dict = (IDictionary)Activator.CreateInstance(typeof(Dictionary<,>)
+                                             .MakeGenericType(TypeOfKeys, TypeOfValues));
+
+            // get keys and values
+            var keys   = ValueType.GetProperty("Keys")  .GetValue(Value);
+            var values = ValueType.GetProperty("Values").GetValue(Value);
+
+            // create lists to hold them
+            var keyList   = new List<object>();
+            var valueList = new List<object>();
+
+            // get keys enumerator and store keys
+            var keyEnumerator = keys.GetType().GetMethod("GetEnumerator").Invoke(keys, null);
+            var keyCollectionType = keyEnumerator.GetType();
+            var keyMoveNext = keyCollectionType.GetMethod("MoveNext");
+            var keyCurrent = keyCollectionType.GetProperty("Current");
+            while ((bool)keyMoveNext.Invoke(keyEnumerator, null))
+            {
+                keyList.Add(keyCurrent.GetValue(keyEnumerator));
+            }
+
+            // get values enumerator and store values
+            var valueEnumerator = values.GetType().GetMethod("GetEnumerator").Invoke(values, null);
+            var valueCollectionType = valueEnumerator.GetType();
+            var valueMoveNext = valueCollectionType.GetMethod("MoveNext");
+            var valueCurrent = valueCollectionType.GetProperty("Current");
+            while ((bool)valueMoveNext.Invoke(valueEnumerator, null))
+            {
+                valueList.Add(valueCurrent.GetValue(valueEnumerator));
+            }
+
+            // finally iterate into actual dictionary
+            for (int i = 0; i < keyList.Count; i++)
+            {
+                dict.Add(keyList[i], valueList[i]);
+            }
+
+            return dict;
+        }
+
+        private void GetGenericArguments()
+        {
+            if (this.MemInfo != null)
+            {
+                Type memberType = null;
+                switch (this.MemInfo.MemberType)
+                {
+                    case MemberTypes.Field:
+                        memberType = (MemInfo as FieldInfo).FieldType;
+                        break;
+                    case MemberTypes.Property:
+                        memberType = (MemInfo as PropertyInfo).PropertyType;
+                        break;
+                }
+
+                if (memberType != null && memberType.IsGenericType)
+                {
+                    m_keysType = memberType.GetGenericArguments()[0];
+                    m_valuesType = memberType.GetGenericArguments()[1];
+                }
+            }
+            else if (Value != null)
+            {
+                var type = Value.GetType();
+                if (type.IsGenericType)
+                {
+                    m_keysType = type.GetGenericArguments()[0];
+                    m_valuesType = type.GetGenericArguments()[1];
+                }
+            }
         }
 
         public override void UpdateValue()
         {
-            //base.UpdateValue();
+            // first make sure we won't run into a TypeInitializationException.
+            if (!EnsureDictionaryIsSupported())
+            {
+                ReflectionException = "Dictionary Type not supported with Reflection!";
+                return;
+            }
 
+            base.UpdateValue();
 
+            // reset
+            IDict = null;
+
+            if (Value == null || IDict == null)
+            {
+                return;
+            }
+
+            var keys = new List<CacheObjectBase>();
+            foreach (var key in IDict.Keys)
+            {
+                var cache = GetCacheObject(key, TypeOfKeys);
+                cache.UpdateValue();
+                keys.Add(cache);
+            }
+
+            var values = new List<CacheObjectBase>();
+            foreach (var val in IDict.Values)
+            {
+                var cache = GetCacheObject(val, TypeOfValues);
+                cache.UpdateValue();
+                values.Add(cache);
+            }
+
+            m_cachedKeys = keys.ToArray();
+            m_cachedValues = values.ToArray();
         }
 
+        private bool EnsureDictionaryIsSupported()
+        {
+            try
+            {
+                //var ilTypes = new List<Il2CppSystem.Type>();
+                var monoTypes = new Type[] { TypeOfKeys, TypeOfValues };
+
+                foreach (var type in monoTypes)
+                {
+                    var generic = typeof(Il2CppClassPointerStore<>).MakeGenericType(type);
+                    if (generic == null) return false;
+
+                    var genericPtr = (IntPtr)generic.GetField("NativeClassPtr").GetValue(null);
+                    if (genericPtr == null) return false;
+
+                    var classPtr = IL2CPP.il2cpp_class_get_type(genericPtr);
+                    if (classPtr == null) return false;
+
+                    var internalType = Il2CppSystem.Type.internal_from_handle(classPtr);
+                    if (internalType == null) return false;
+
+                    //ilTypes.Add(internalType);
+                }
+            }
+            catch 
+            { 
+                return false; 
+            }
+
+            // Should be fine if we got this far, but I'll leave the rest below commented out just in case.
+            return true;
+
+            //MelonLogger.Log("Got both generic types, continuing...");
+
+            //var dictIlClass = IL2CPP.GetIl2CppClass("mscorlib.dll", "System.Collections.Generic", "Dictionary`2");
+            //if (dictIlClass == null) return;
+
+            //MelonLogger.Log("Got base dictionary Il2Cpp type");
+
+            //var ilClassFromType = IL2CPP.il2cpp_class_get_type(dictIlClass);
+            //if (ilClassFromType == null) return;
+
+            //MelonLogger.Log("got IntPtr from base dictionary type");
+
+            //var internalHandle = Il2CppSystem.Type.internal_from_handle(ilClassFromType);
+            //if (internalHandle == null) return;
+
+            //var generic = internalHandle.MakeGenericType(new Il2CppReferenceArray<Il2CppSystem.Type>(new Il2CppSystem.Type[]
+            //{
+            //        ilTypes[0], ilTypes[1]
+            //}));
+            //if (generic == null) return;
+
+            //MelonLogger.Log("Made generic handle for our entry types");
+
+            //var nativeClassPtr = generic.TypeHandle.value;
+            //if (nativeClassPtr == null) return;
+
+            //MelonLogger.Log("Got the actual nativeClassPtr for the handle");
+
+            //var dictType = typeof(Il2CppSystem.Collections.Generic.Dictionary<,>).MakeGenericType(TypeOfKeys, TypeOfValues);
+            //if (dictType == null) return;
+
+            //MelonLogger.Log("Made the generic type for the dictionary");
+
+            //var pointerStoreType = typeof(Il2CppClassPointerStore<>).MakeGenericType(dictType);
+            //if (pointerStoreType == null) return;
+
+            //MelonLogger.Log("Made the generic PointerStoreType for our dict");
+
+            //var ptrToSet = IL2CPP.il2cpp_class_from_type(nativeClassPtr);
+            //if (ptrToSet == null) return;
+
+            //MelonLogger.Log("Got class from nativeClassPtr, setting value...");
+
+            //pointerStoreType.GetField("NativeClassPtr").SetValue(null, ptrToSet);
+
+            //MelonLogger.Log("Ok");
+        }
+
+        // ============= GUI Draw =============
+
         public override void DrawValue(Rect window, float width)
         {
-            GUILayout.Label("<color=red>Dictionary (unsupported)</color>", null);
+            if (m_cachedKeys == null || m_cachedValues == null)
+            {
+                GUILayout.Label("Cached keys or values is null!", null);
+                return;
+            }
+
+            int count = m_cachedKeys.Length;
+
+            if (!IsExpanded)
+            {
+                if (GUILayout.Button("v", new GUILayoutOption[] { GUILayout.Width(25) }))
+                {
+                    IsExpanded = true;
+                }
+            }
+            else
+            {
+                if (GUILayout.Button("^", new GUILayoutOption[] { GUILayout.Width(25) }))
+                {
+                    IsExpanded = false;
+                }
+            }
+
+            GUI.skin.button.alignment = TextAnchor.MiddleLeft;
+            string btnLabel = $"<color=yellow>[{count}] Dictionary<{TypeOfKeys.FullName}, {TypeOfValues.FullName}></color>";
+            if (GUILayout.Button(btnLabel, new GUILayoutOption[] { GUILayout.MaxWidth(window.width - ButtonWidthOffset) }))
+            {
+                WindowManager.InspectObject(Value, out bool _);
+            }
+            GUI.skin.button.alignment = TextAnchor.MiddleCenter;
+
+            GUILayout.Space(5);
+
+            if (IsExpanded)
+            {
+                float whitespace = WhiteSpace;
+                if (whitespace > 0)
+                {
+                    ClampLabelWidth(window, ref whitespace);
+                }
+
+                Pages.ItemCount = count;
+
+                if (count > Pages.ItemsPerPage)
+                {
+                    GUILayout.EndHorizontal();
+                    GUILayout.BeginHorizontal(null);
+
+                    GUILayout.Space(whitespace);
+
+                    Pages.CurrentPageLabel();
+
+                    // prev/next page buttons
+                    if (GUILayout.Button("< Prev", new GUILayoutOption[] { GUILayout.Width(60) }))
+                    {
+                        Pages.TurnPage(Turn.Left);
+                    }
+                    if (GUILayout.Button("Next >", new GUILayoutOption[] { GUILayout.Width(60) }))
+                    {
+                        Pages.TurnPage(Turn.Right);
+                    }
+
+                    Pages.DrawLimitInputArea();
+
+                    GUILayout.Space(5);
+                }
+
+                int offset = Pages.CalculateOffsetIndex();
+
+                for (int i = offset; i < offset + Pages.ItemsPerPage && i < count; i++)
+                {
+                    var key = m_cachedKeys[i];
+                    var val = m_cachedValues[i];
+
+                    //collapsing the BeginHorizontal called from ReflectionWindow.WindowFunction or previous array entry
+                    GUILayout.EndHorizontal();
+                    GUILayout.BeginHorizontal(null);
+
+                    //GUILayout.Space(whitespace);
+
+                    if (key == null || val == null)
+                    {
+                        GUILayout.Label($"[{i}] <i><color=grey>(null)</color></i>", null);
+                    }
+                    else
+                    {
+                        GUI.skin.label.alignment = TextAnchor.MiddleCenter;
+                        GUILayout.Label($"[{i}]", new GUILayoutOption[] { GUILayout.Width(30) });
+
+                        GUILayout.Label("Key:", new GUILayoutOption[] { GUILayout.Width(40) });
+                        key.DrawValue(window, (window.width / 2) - 30f);
+
+                        GUILayout.Label("Value:", new GUILayoutOption[] { GUILayout.Width(40) });
+                        val.DrawValue(window, (window.width / 2) - 30f);
+                    }
+
+                }
+
+                GUI.skin.label.alignment = TextAnchor.UpperLeft;
+            }
         }
     }
 }

src/CachedObjects/Object/CacheList.cs

@@ -8,13 +8,13 @@ using UnityEngine;
 
 namespace Explorer
 {
-    public class CacheList : CacheObjectBase
+    public class CacheList : CacheObjectBase, IExpandHeight
     {
         public bool IsExpanded { get; set; }
-        public PageHelper Pages = new PageHelper();
+        public float WhiteSpace { get; set; } = 215f;
+        public float ButtonWidthOffset { get; set; } = 290f;
 
-        public float WhiteSpace = 215f;
-        public float ButtonWidthOffset = 290f;
+        public PageHelper Pages = new PageHelper();
 
         private CacheObjectBase[] m_cachedEntries;
 
@@ -52,6 +52,7 @@ namespace Explorer
         {
             get => GetItemProperty();
         }
+
         private PropertyInfo m_itemProperty;
 
         // ========== Methods ==========
@@ -218,6 +219,7 @@ namespace Explorer
 
                     if (GetCacheObject(obj, t) is CacheObjectBase cached)
                     {
+                        cached.UpdateValue();
                         list.Add(cached);
                     }
                     else
@@ -262,7 +264,7 @@ namespace Explorer
             }
 
             GUI.skin.button.alignment = TextAnchor.MiddleLeft;
-            string btnLabel = "<color=yellow>[" + count + "] " + EntryType + "</color>";
+            string btnLabel = "<color=yellow>[" + count + "] " + EntryType.FullName + "</color>";
             if (GUILayout.Button(btnLabel, new GUILayoutOption[] { GUILayout.MaxWidth(window.width - ButtonWidthOffset) }))
             {
                 WindowManager.InspectObject(Value, out bool _);
@@ -305,12 +307,6 @@ namespace Explorer
                     GUILayout.Space(5);
                 }
 
-                //int offset = ArrayOffset * ArrayLimit;
-                //if (offset >= count)
-                //{
-                //    offset = 0;
-                //    ArrayOffset = 0;
-                //}
                 int offset = Pages.CalculateOffsetIndex();
 
                 for (int i = offset; i < offset + Pages.ItemsPerPage && i < count; i++)

src/CachedObjects/Other/CacheMethod.cs

@@ -18,28 +18,17 @@ namespace Explorer
         private ParameterInfo[] m_arguments;
         private string[] m_argumentInput;
 
-        public bool HasParameters
-        {
-            get
-            {
-                if (m_hasParams == null)
-                {
-                    m_hasParams = (MemInfo as MethodInfo).GetParameters().Length > 0;
-                }
-                return (bool)m_hasParams;
-            }
-        }
-        private bool? m_hasParams;
+        public bool HasParameters => m_arguments != null && m_arguments.Length > 0;
 
         public static bool CanEvaluate(MethodInfo mi)
         {
-            // generic type args not supported yet
+            // TODO generic args
             if (mi.GetGenericArguments().Length > 0)
             {
                 return false;
             }
 
-            // only primitive and string args supported
+            // primitive and string args supported
             foreach (var param in mi.GetParameters())
             {
                 if (!param.ParameterType.IsPrimitive && param.ParameterType != typeof(string))
@@ -64,7 +53,84 @@ namespace Explorer
         public override void UpdateValue()
         {
             //base.UpdateValue();
-        }        
+        }
+
+        private void Evaluate()
+        {
+            var mi = MemInfo as MethodInfo;
+
+            object ret = null;
+
+            if (!HasParameters)
+            {
+                ret = mi.Invoke(mi.IsStatic ? null : DeclaringInstance, new object[0]);
+                m_evaluated = true;
+            }
+            else
+            {
+                var parsedArgs = new List<object>();
+                for (int i = 0; i < m_arguments.Length; i++)
+                {
+                    var input = m_argumentInput[i];
+                    var type = m_arguments[i].ParameterType;
+
+                    if (type == typeof(string))
+                    {
+                        parsedArgs.Add(input);
+                    }
+                    else
+                    {
+                        try
+                        {
+                            if (type.GetMethod("Parse", new Type[] { typeof(string) }).Invoke(null, new object[] { input }) is object parsed)
+                            {
+                                parsedArgs.Add(parsed);
+                            }
+                            else
+                            {
+                                // try add a null arg i guess
+                                parsedArgs.Add(null);
+                            }
+
+                        }
+                        catch
+                        {
+                            MelonLogger.Log($"Unable to parse '{input}' to type '{type.Name}'");
+                            break;
+                        }
+                    }
+                }
+
+                try
+                {
+                    ret = mi.Invoke(mi.IsStatic ? null : DeclaringInstance, parsedArgs.ToArray());
+                    m_evaluated = true;
+                }
+                catch (Exception e)
+                {
+                    MelonLogger.Log($"Exception evaluating: {e.GetType()}, {e.Message}");
+                }
+            }
+
+            if (ret != null)
+            {
+                m_cachedReturnValue = GetCacheObject(ret);
+
+                if (m_cachedReturnValue is IExpandHeight expander)
+                {
+                    expander.WhiteSpace = 0f;
+                    expander.ButtonWidthOffset += 70f;
+                }
+
+                m_cachedReturnValue.UpdateValue();
+            }
+            else
+            {
+                m_cachedReturnValue = null;
+            }
+        }
+
+        // ==== GUI DRAW ====
 
         public override void DrawValue(Rect window, float width)
         {
@@ -124,15 +190,7 @@ namespace Explorer
             {
                 if (m_cachedReturnValue != null)
                 {
-                    try
-                    {
-                        m_cachedReturnValue.DrawValue(window, width);
-                    }
-                    catch (Exception e)
-                    {
-                        MelonLogger.Log("Exception drawing m_cachedReturnValue!");
-                        MelonLogger.Log(e.ToString());
-                    }
+                    m_cachedReturnValue.DrawValue(window, width);
                 }
                 else
                 {
@@ -147,77 +205,5 @@ namespace Explorer
 
             GUILayout.EndVertical();
         }
-
-        private void Evaluate()
-        {
-            var mi = MemInfo as MethodInfo;
-
-            object ret = null;
-
-            if (!HasParameters)
-            {
-                ret = mi.Invoke(mi.IsStatic ? null : DeclaringInstance, new object[0]);
-                m_evaluated = true;
-            }
-            else
-            {
-                var arguments = new List<object>();
-                for (int i = 0; i < m_arguments.Length; i++)
-                {
-                    var input = m_argumentInput[i];
-                    var type = m_arguments[i].ParameterType;
-
-                    if (type == typeof(string))
-                    {
-                        arguments.Add(input);
-                    }
-                    else
-                    {
-                        try
-                        {
-                            if (type.GetMethod("Parse", new Type[] { typeof(string) }).Invoke(null, new object[] { input }) is object parsed)
-                            {
-                                arguments.Add(parsed);
-                            }
-                            else
-                            {
-                                throw new Exception();
-                            }
-
-                        }
-                        catch
-                        {
-                            MelonLogger.Log($"Unable to parse '{input}' to type '{type.Name}'");
-                            break;
-                        }
-                    }
-                }
-
-                if (arguments.Count == m_arguments.Length)
-                {
-                    ret = mi.Invoke(mi.IsStatic ? null : DeclaringInstance, arguments.ToArray());
-                    m_evaluated = true;
-                }
-                else
-                {
-                    MelonLogger.Log($"Did not invoke because {m_arguments.Length - arguments.Count} arguments could not be parsed!");
-                }
-            }
-
-            if (ret != null)
-            {
-                m_cachedReturnValue = GetCacheObject(ret);
-                if (m_cachedReturnValue is CacheList cacheList)
-                {
-                    cacheList.WhiteSpace = 0f;
-                    cacheList.ButtonWidthOffset += 70f;
-                }
-                m_cachedReturnValue.UpdateValue();
-            }
-            else
-            {
-                m_cachedReturnValue = null;
-            }
-        }
     }
 }

src/CachedObjects/Struct/CacheColor.cs

@@ -5,7 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using UnityEngine;
 
-namespace Explorer.CachedObjects
+namespace Explorer
 {
     public class CacheColor : CacheObjectBase
     {
@@ -79,7 +79,8 @@ namespace Explorer.CachedObjects
                 && float.TryParse(b, out float fB)
                 && float.TryParse(a, out float fA))
             {
-                Value = new Color(fR, fB, fG, fA);                
+                Value = new Color(fR, fB, fG, fA);
+                SetValue();
             }
         }
     }

src/CachedObjects/Struct/CacheEnum.cs

@@ -51,7 +51,7 @@ namespace Explorer
                 }
             }
 
-            GUILayout.Label(Value.ToString(), null);// + "<color=yellow><i> (" + ValueType + ")</i></color>", null);
+            GUILayout.Label(Value.ToString() + "<color=yellow><i> (" + ValueType + ")</i></color>", null);
         }
 
         public void SetEnum(ref object value, int change)

src/CachedObjects/Struct/CachePrimitive.cs

@@ -8,91 +8,37 @@ namespace Explorer
 {
     public class CachePrimitive : CacheObjectBase
     {
-        public enum PrimitiveTypes
-        {
-            Bool,
-            Double,
-            Float,
-            Int,
-            String,
-            Char
-        }
+        private bool m_isBool;
+        private bool m_isString;
 
         private string m_valueToString;
 
-        public PrimitiveTypes PrimitiveType;
-
-        public MethodInfo ParseMethod
-        {
-            get
-            {
-                if (m_parseMethod == null)
-                {
-                    m_parseMethod = Value.GetType().GetMethod("Parse", new Type[] { typeof(string) });
-                }
-                return m_parseMethod;
-            }
-        }
-
+        public MethodInfo ParseMethod => m_parseMethod ?? (m_parseMethod = Value.GetType().GetMethod("Parse", new Type[] { typeof(string) }));
         private MethodInfo m_parseMethod;
 
         public override void Init()
         {
-            if (Value == null)
+            if (ValueType == null)
             {
-                // this must mean it is a string. No other primitive type should be nullable.
-                PrimitiveType = PrimitiveTypes.String;
-                return;
+                ValueType = Value?.GetType();
+
+                // has to be a string at this point
+                if (ValueType == null)
+                {
+                    ValueType = typeof(string);
+                }
             }
 
-            m_valueToString = Value.ToString();
-            var type = Value.GetType();
-
-            if (type == typeof(bool))
+            if (ValueType == typeof(string))
             {
-                PrimitiveType = PrimitiveTypes.Bool;
+                m_isString = true;
             }
-            else if (type == typeof(double))
+            else if (ValueType == typeof(bool))
             {
-                PrimitiveType = PrimitiveTypes.Double;
-            }
-            else if (type == typeof(float))
-            {
-                PrimitiveType = PrimitiveTypes.Float;
-            }
-            else if (IsInteger(type))
-            {
-                PrimitiveType = PrimitiveTypes.Int;
-            }
-            else if (type == typeof(char))
-            {
-                PrimitiveType = PrimitiveTypes.Char;
-            }
-            else
-            {
-                PrimitiveType = PrimitiveTypes.String;
+                m_isBool = true;
             }
         }
 
-        private static bool IsInteger(Type type)
-        {
-            // For our purposes, all types of int can be treated the same, including IntPtr.
-            return _integerTypes.Contains(type);
-        }
-
-        private static readonly HashSet<Type> _integerTypes = new HashSet<Type>
-        {
-            typeof(int),
-            typeof(uint),
-            typeof(short),
-            typeof(ushort),
-            typeof(long),
-            typeof(ulong),
-            typeof(byte),
-            typeof(sbyte),
-            typeof(IntPtr)
-        };
-
         public override void UpdateValue()
         {
             base.UpdateValue();
@@ -102,11 +48,10 @@ namespace Explorer
 
         public override void DrawValue(Rect window, float width)
         {
-            if (PrimitiveType == PrimitiveTypes.Bool)
+            if (m_isBool)
             {
                 var b = (bool)Value;
-                var color = $"<color={(b ? "lime>" : "red>")}";
-                var label = $"{color}{b}</color>";
+                var label = $"<color={(b ? "lime" : "red")}>{b}</color>";
 
                 if (CanWrite)
                 {
@@ -123,7 +68,8 @@ namespace Explorer
             }
             else
             {
-                GUILayout.Label("<color=yellow><i>" + PrimitiveType + "</i></color>", new GUILayoutOption[] { GUILayout.Width(50) });
+                // using ValueType.Name instead of ValueTypeName, because we only want the short name.
+                GUILayout.Label("<color=yellow><i>" + ValueType.Name + "</i></color>", new GUILayoutOption[] { GUILayout.Width(50) });
 
                 int dynSize = 25 + (m_valueToString.Length * 15);
                 var maxwidth = window.width - 300f;
@@ -150,7 +96,7 @@ namespace Explorer
             }
         }
 
-        public void SetValueFromInput(string value)
+        public void SetValueFromInput(string valueString)
         {
             if (MemInfo == null)
             {
@@ -158,16 +104,15 @@ namespace Explorer
                 return;
             }
 
-            if (PrimitiveType == PrimitiveTypes.String)
+            if (m_isString)
             {
-                Value = value;
+                Value = valueString;
             }
             else
             {
                 try
                 {
-                    var val = ParseMethod.Invoke(null, new object[] { value });
-                    Value = val;                    
+                    Value = ParseMethod.Invoke(null, new object[] { valueString });
                 }
                 catch (Exception e)
                 {

src/CachedObjects/Struct/CacheQuaternion.cs

@@ -9,8 +9,6 @@ namespace Explorer
 {
     public class CacheQuaternion : CacheObjectBase
     {
-        private Vector3 EulerAngle = Vector3.zero;
-
         private string x = "0";
         private string y = "0";
         private string z = "0";
@@ -19,11 +17,11 @@ namespace Explorer
         {
             base.UpdateValue();
 
-            EulerAngle = ((Quaternion)Value).eulerAngles;
+            var euler = ((Quaternion)Value).eulerAngles;
 
-            x = EulerAngle.x.ToString();
-            y = EulerAngle.y.ToString();
-            z = EulerAngle.z.ToString();
+            x = euler.x.ToString();
+            y = euler.y.ToString();
+            z = euler.z.ToString();
         }
 
         public override void DrawValue(Rect window, float width)

src/CachedObjects/Struct/CacheRect.cs

@@ -5,7 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using UnityEngine;
 
-namespace Explorer.CachedObjects
+namespace Explorer
 {
     public class CacheRect : CacheObjectBase
     {

src/CppExplorer.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -12,7 +13,7 @@ namespace Explorer
     public class CppExplorer : MelonMod
     {
         public const string GUID = "com.sinai.cppexplorer";
-        public const string VERSION = "1.5.6";
+        public const string VERSION = "1.6.2";
         public const string AUTHOR = "Sinai";
 
         public const string NAME = "CppExplorer"

src/CppExplorer.csproj

@@ -120,6 +120,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Helpers\IExpandHeight.cs" />
     <Compile Include="CachedObjects\Struct\CacheColor.cs" />
     <Compile Include="CachedObjects\Object\CacheDictionary.cs" />
     <Compile Include="CachedObjects\Struct\CacheEnum.cs" />

src/Helpers/IExpandHeight.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Explorer
+{
+    interface IExpandHeight
+    {
+        bool IsExpanded { get; set; }
+
+        float WhiteSpace { get; set; }
+        float ButtonWidthOffset { get; set; }
+    }
+}

src/Helpers/PageHelper.cs

@@ -16,7 +16,18 @@ namespace Explorer
     public class PageHelper
     {
         public int PageOffset { get; set; }
-        public int ItemsPerPage { get; set; } = 20;
+
+        public int ItemsPerPage
+        {
+            get => m_itemsPerPage;
+            set
+            {
+                m_itemsPerPage = value;
+                CalculateMaxOffset();
+            }
+        }
+        private int m_itemsPerPage = 20;
+
         public int ItemCount 
         {
             get => m_count;

src/Helpers/ReflectionHelpers.cs

@@ -9,6 +9,8 @@ using UnhollowerRuntimeLib;
 using UnityEngine;
 using BF = System.Reflection.BindingFlags;
 using MelonLoader;
+using System.Collections;
+using Mono.CSharp;
 
 namespace Explorer
 {
@@ -74,45 +76,54 @@ namespace Explorer
                 return false;
         }
 
-        public static bool IsArray(Type t)
+        public static bool IsEnumerable(Type t)
         {
-            return typeof(System.Collections.IEnumerable).IsAssignableFrom(t);
+            return typeof(IEnumerable).IsAssignableFrom(t);
         }
 
-        public static bool IsList(Type t)
+        // Only Il2Cpp List needs this check. C# List is IEnumerable.
+        public static bool IsCppList(Type t)
         {
-            if (t.IsGenericType)
+            if (t.IsGenericType && t.GetGenericTypeDefinition() is Type g)
             {
-                var generic = t.GetGenericTypeDefinition();
-
-                return generic.IsAssignableFrom(typeof(Il2CppSystem.Collections.Generic.List<>))
-                    || generic.IsAssignableFrom(typeof(Il2CppSystem.Collections.Generic.IList<>));
+                return typeof(Il2CppSystem.Collections.Generic.List<>).IsAssignableFrom(g)
+                    || typeof(Il2CppSystem.Collections.Generic.IList<>).IsAssignableFrom(g);
             }
             else
             {
-                return t.IsAssignableFrom(typeof(Il2CppSystem.Collections.IList));
+                return typeof(Il2CppSystem.Collections.IList).IsAssignableFrom(t);
             }
         }
 
         public static bool IsDictionary(Type t)
         {
-            return t.IsGenericType
-                && t.GetGenericTypeDefinition() is Type typeDef
-                && typeDef.IsAssignableFrom(typeof(Il2CppSystem.Collections.Generic.Dictionary<,>));
+            if (typeof(IDictionary).IsAssignableFrom(t))
+            {
+                return true;
+            }
+
+            if (t.IsGenericType && t.GetGenericTypeDefinition() is Type g)
+            {
+                return typeof(Il2CppSystem.Collections.Generic.Dictionary<,>).IsAssignableFrom(g)
+                    || typeof(Il2CppSystem.Collections.Generic.IDictionary<,>).IsAssignableFrom(g);
+            }
+            else
+            {
+                return typeof(Il2CppSystem.Collections.IDictionary).IsAssignableFrom(t);
+            }
         }
 
         public static Type GetTypeByName(string typeName)
         {
             foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
             {
-                try
+                foreach (var type in GetTypesSafe(asm))
                 {
-                    if (asm.GetType(typeName) is Type type)
+                    if (type.FullName == typeName)
                     {
                         return type;
                     }
                 }
-                catch { }
             }
 
             return null;
@@ -137,6 +148,13 @@ namespace Explorer
             return obj.GetType();
         }
 
+        public static IEnumerable<Type> GetTypesSafe(Assembly asm)
+        {
+            try { return asm.GetTypes(); }
+            catch (ReflectionTypeLoadException e) { return e.Types.Where(x => x != null); }
+            catch { return Enumerable.Empty<Type>(); }
+        }
+
         public static Type[] GetAllBaseTypes(object obj)
         {
             var list = new List<Type>();

src/Helpers/UIStyles.cs

@@ -56,7 +56,10 @@ namespace Explorer
                 {
                     _horizBarStyle = new GUIStyle();
                     _horizBarStyle.normal.background = Texture2D.whiteTexture;
-                    _horizBarStyle.margin = new RectOffset(0, 0, 4, 4);
+                    var rectOffset = new RectOffset();
+                    rectOffset.top = 4;
+                    rectOffset.bottom = 4;
+                    _horizBarStyle.margin = rectOffset;
                     _horizBarStyle.fixedHeight = 2;
                 }
 
@@ -73,7 +76,10 @@ namespace Explorer
                 {
                     _horizBarSmallStyle = new GUIStyle();
                     _horizBarSmallStyle.normal.background = Texture2D.whiteTexture;
-                    _horizBarSmallStyle.margin = new RectOffset(0, 0, 2, 2);
+                    var rectOffset = new RectOffset();
+                    rectOffset.top = 2;
+                    rectOffset.bottom = 2;
+                    _horizBarSmallStyle.margin = rectOffset;
                     _horizBarSmallStyle.fixedHeight = 1;
                 }
 

src/MainMenu/Pages/ConsolePage.cs

@@ -14,11 +14,13 @@ namespace Explorer
 {
     public class ConsolePage : WindowPage
     {
-        public override string Name { get => "C# Console"; set => base.Name = value; }
+        public override string Name { get => "C# Console"; }
 
         private ScriptEvaluator _evaluator;
         private readonly StringBuilder _sb = new StringBuilder();
 
+        private Vector2 inputAreaScroll;
+
         private string MethodInput = "";
         private string UsingInput = "";
 
@@ -124,7 +126,12 @@ MelonLogger.Log(""hello world"");";
             GUI.skin.label.alignment = TextAnchor.UpperLeft;
 
             GUILayout.Label("Enter code here as though it is a method body:", null);
-            MethodInput = GUILayout.TextArea(MethodInput, new GUILayoutOption[] { GUILayout.Height(250) });
+
+            inputAreaScroll = GUIUnstrip.BeginScrollView(inputAreaScroll, new GUILayoutOption[] { GUILayout.Height(250) });
+
+            MethodInput = GUILayout.TextArea(MethodInput, new GUILayoutOption[] { GUILayout.ExpandHeight(true) });
+
+            GUIUnstrip.EndScrollView();
 
             if (GUILayout.Button("<color=cyan><b>Execute</b></color>", null))
             {

src/MainMenu/Pages/ScenePage.cs

@@ -12,16 +12,14 @@ namespace Explorer
     {
         public static ScenePage Instance;
 
-        public override string Name { get => "Scene Explorer"; set => base.Name = value; }
+        public override string Name { get => "Scene Explorer"; }
 
         public PageHelper Pages = new PageHelper();
 
         private float m_timeOfLastUpdate = -1f;
-        private static int PASSIVE_UPDATE_INTERVAL = 1;
+        private const int PASSIVE_UPDATE_INTERVAL = 1;
 
-        private static bool m_getRootObjectsFailed = false;
-
-        // ----- Holders for GUI elements ----- //
+        private static bool m_getRootObjectsFailed;
 
         private static string m_currentScene = "";
 
@@ -34,8 +32,6 @@ namespace Explorer
         private string m_searchInput = "";
         private List<GameObjectCache> m_searchResults = new List<GameObjectCache>();
 
-        // ------------ Init and Update ------------ //
-
         public override void Init()
         {
             Instance = this;
@@ -54,7 +50,7 @@ namespace Explorer
             if (m_searching)
                 CancelSearch();
 
-            Update_Impl();
+            Update_Impl(true);
         }
 
         public void TraverseUp()
@@ -90,11 +86,12 @@ namespace Explorer
         {
             var matches = new List<GameObjectCache>();
 
-            foreach (var obj in Resources.FindObjectsOfTypeAll<GameObject>())
+            foreach (var obj in Resources.FindObjectsOfTypeAll(ReflectionHelpers.GameObjectType))
             {
-                if (obj.name.ToLower().Contains(_search.ToLower()) && obj.scene.name == m_currentScene)
+                var go = obj.TryCast<GameObject>();
+                if (go.name.ToLower().Contains(_search.ToLower()) && go.scene.name == m_currentScene)
                 {
-                    matches.Add(new GameObjectCache(obj));
+                    matches.Add(new GameObjectCache(go));
                 }
             }
 
@@ -111,9 +108,9 @@ namespace Explorer
             Update_Impl();
         }
 
-        private void Update_Impl()
+        private void Update_Impl(bool manual = false)
         {
-            var allTransforms = new List<Transform>();
+            List<Transform> allTransforms = new List<Transform>();
 
             // get current list of all transforms (either scene root or our current transform children)
             if (m_currentTransform)
@@ -129,24 +126,27 @@ namespace Explorer
                 {
                     try
                     {
-                        var list = SceneManager.GetActiveScene().GetRootGameObjects().ToArray();
+                        var scene = SceneManager.GetSceneByName(m_currentScene);
 
-                        foreach (var obj in list)
-                        {
-                            allTransforms.Add(obj.transform);
-                        }
+                        allTransforms.AddRange(scene.GetRootGameObjects()
+                                                    .Select(it => it.transform));
                     }
                     catch
                     {
-                        m_getRootObjectsFailed = true;
-                        PASSIVE_UPDATE_INTERVAL = 2;
+                        MelonLogger.Log("Exception getting root scene objects, falling back to backup method...");
 
-                        allTransforms = GetRootObjectsManual_Impl();
+                        m_getRootObjectsFailed = true;
+                        allTransforms.AddRange(GetRootObjectsManual_Impl());
                     }
                 }
                 else
                 {
-                    allTransforms = GetRootObjectsManual_Impl();
+                    if (!manual)
+                    {
+                        return;
+                    }
+
+                    allTransforms.AddRange(GetRootObjectsManual_Impl());
                 }
             }
 
@@ -166,13 +166,30 @@ namespace Explorer
             }
         }
 
-        private List<Transform> GetRootObjectsManual_Impl()
+        private IEnumerable<Transform> GetRootObjectsManual_Impl()
         {
-            var allTransforms = Resources.FindObjectsOfTypeAll<Transform>()
-                       .Where(x => x.parent == null && x.gameObject.scene.name == m_currentScene)
-                       .ToList();
+            try
+            {
+                var array = Resources.FindObjectsOfTypeAll(ReflectionHelpers.TransformType);
 
-            return allTransforms;
+                var list = new List<Transform>();
+                foreach (var obj in array)
+                {
+                    var transform = obj.TryCast<Transform>();
+                    if (transform.parent == null && transform.gameObject.scene.name == m_currentScene)
+                    {
+                        list.Add(transform);
+                    }
+                }
+                return list;
+            }
+            catch (Exception e)
+            {
+                MelonLogger.Log("Exception getting root scene objects (manual): " 
+                    + e.GetType() + ", " + e.Message + "\r\n" 
+                    + e.StackTrace);
+                return new Transform[0];
+            }
         }
 
         // --------- GUI Draw Function --------- //        
@@ -274,7 +291,7 @@ namespace Explorer
                 {
                     Pages.TurnPage(Turn.Left, ref this.scroll);
 
-                    Update_Impl();
+                    Update_Impl(true);
                 }
 
                 Pages.CurrentPageLabel();
@@ -283,7 +300,7 @@ namespace Explorer
                 {
                     Pages.TurnPage(Turn.Right, ref this.scroll);
 
-                    Update_Impl();
+                    Update_Impl(true);
                 }
             }
 
@@ -313,6 +330,14 @@ namespace Explorer
             else
             {
                 GUILayout.Label("Scene Root GameObjects:", null);
+
+                if (m_getRootObjectsFailed)
+                {
+                    if (GUILayout.Button("Update Root Object List (auto-update failed!)", null))
+                    {
+                        Update_Impl(true);
+                    }
+                }
             }
 
             if (m_objectList.Count > 0)

src/MainMenu/Pages/SearchPage.cs

@@ -13,7 +13,7 @@ namespace Explorer
     {
         public static SearchPage Instance;
 
-        public override string Name { get => "Object Search"; set => base.Name = value; }
+        public override string Name { get => "Object Search"; }
 
         private string m_searchInput = "";
         private string m_typeInput = "";
@@ -137,14 +137,11 @@ namespace Explorer
 
                 if (m_searchResults.Count > 0)
                 {
-                    //int offset = m_pageOffset * this.m_limit;
-                    //if (offset >= count) m_pageOffset = 0;
                     int offset = Pages.CalculateOffsetIndex();
 
                     for (int i = offset; i < offset + Pages.ItemsPerPage && i < count; i++)
                     {
                         m_searchResults[i].Draw(MainMenu.MainRect, 0f);
-                        //m_searchResults[i].DrawValue(MainMenu.MainRect);
                     }
                 }
                 else
@@ -175,16 +172,6 @@ namespace Explorer
             GUILayout.Label("Name Contains:", new GUILayoutOption[] { GUILayout.Width(100) });
             m_searchInput = GUILayout.TextField(m_searchInput, new GUILayoutOption[] { GUILayout.Width(200) });
 
-            //GUI.skin.label.alignment = TextAnchor.MiddleRight;
-            //GUILayout.Label("Results per page:", new GUILayoutOption[] { GUILayout.Width(120) });
-            //var resultinput = m_limit.ToString();
-            //resultinput = GUILayout.TextField(resultinput, new GUILayoutOption[] { GUILayout.Width(55) });
-            //if (int.TryParse(resultinput, out int _i) && _i > 0)
-            //{
-            //    m_limit = _i;
-            //}
-            //GUI.skin.label.alignment = TextAnchor.UpperLeft;
-
             GUILayout.EndHorizontal();
 
             GUILayout.BeginHorizontal(null);
@@ -266,7 +253,7 @@ namespace Explorer
             CacheResults(FindAllObjectsOfType(m_searchInput, m_typeInput));
         }
 
-        private List<object> FindAllObjectsOfType(string _search, string _type)
+        private List<object> FindAllObjectsOfType(string searchQuery, string typeName)
         {
             Il2CppSystem.Type searchType = null;
 
@@ -274,13 +261,18 @@ namespace Explorer
             {
                 try
                 {
-                    var findType = ReflectionHelpers.GetTypeByName(_type);
-                    searchType = Il2CppSystem.Type.GetType(findType.AssemblyQualifiedName);
-                    //MelonLogger.Log("Search type: " + findType.AssemblyQualifiedName);
+                    if (ReflectionHelpers.GetTypeByName(typeName) is Type t)
+                    {
+                        searchType = Il2CppSystem.Type.GetType(t.AssemblyQualifiedName);
+                    }
+                    else
+                    {
+                        throw new Exception($"Could not find a Type by the name of '{typeName}'!");
+                    }
                 }
                 catch (Exception e)
                 {
-                    MelonLogger.Log("Exception: " + e.GetType() + ", " + e.Message + "\r\n" + e.StackTrace);
+                    MelonLogger.Log("Exception getting Search Type: " + e.GetType() + ", " + e.Message);
                 }
             }
             else if (TypeMode == TypeFilter.Object)
@@ -298,7 +290,10 @@ namespace Explorer
 
             if (!ReflectionHelpers.ObjectType.IsAssignableFrom(searchType))
             {
-                MelonLogger.LogError("Your Custom Class Type must inherit from UnityEngine.Object!");
+                if (searchType != null)
+                {
+                    MelonLogger.LogWarning("Your Custom Class Type must inherit from UnityEngine.Object!");
+                }
                 return new List<object>();
             }
 
@@ -313,12 +308,13 @@ namespace Explorer
             {
                 if (i >= 2000) break;
 
-                if (_search != "" && !obj.name.ToLower().Contains(_search.ToLower()))
+                if (searchQuery != "" && !obj.name.ToLower().Contains(searchQuery.ToLower()))
                 {
                     continue;
                 }
 
-                if (searchType == ReflectionHelpers.ComponentType && ReflectionHelpers.TransformType.IsAssignableFrom(obj.GetIl2CppType()))
+                if (searchType.FullName == ReflectionHelpers.ComponentType.FullName
+                    && ReflectionHelpers.TransformType.IsAssignableFrom(obj.GetIl2CppType()))
                 {
                     // Transforms shouldn't really be counted as Components, skip them.
                     // They're more akin to GameObjects.
@@ -376,43 +372,70 @@ namespace Explorer
 
         // ====== other ========
 
+        private static bool FilterName(string name)
+        {
+            // Don't really want these instances.
+            return !name.StartsWith("Mono") 
+                && !name.StartsWith("System") 
+                && !name.StartsWith("Il2CppSystem") 
+                && !name.StartsWith("Iced");
+        }
+
         // credit: ManlyMarco (RuntimeUnityEditor)
         public static IEnumerable<object> GetInstanceClassScanner()
         {
             var query = AppDomain.CurrentDomain.GetAssemblies()
-                .Where(x => !x.FullName.StartsWith("Mono"))
-                .SelectMany(GetTypesSafe)
+                .SelectMany(ReflectionHelpers.GetTypesSafe)
                 .Where(t => t.IsClass && !t.IsAbstract && !t.ContainsGenericParameters);
 
+            var flags = BindingFlags.Public | BindingFlags.Static;
+            var flatFlags = flags | BindingFlags.FlattenHierarchy;
+
             foreach (var type in query)
             {
                 object obj = null;
                 try
                 {
-                    obj = type.GetProperty("Instance", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)?.GetValue(null, null);
-                }
-                catch
-                {
-                    try
+                    var pi = type.GetProperty("Instance", flags);
+
+                    if (pi == null)
                     {
-                        obj = type.GetField("Instance", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)?.GetValue(null);
+                        pi = type.GetProperty("Instance", flatFlags);
                     }
-                    catch
+
+                    if (pi != null)
                     {
+                        obj = pi.GetValue(null);
+                    }
+                    else
+                    {
+                        var fi = type.GetField("Instance", flags);
+
+                        if (fi == null)
+                        {
+                            fi = type.GetField("Instance", flatFlags);
+                        }
+
+                        if (fi != null)
+                        {
+                            obj = fi.GetValue(null);
+                        }
                     }
                 }
-                if (obj != null && !obj.ToString().StartsWith("Mono"))
+                catch { }
+
+                if (obj != null)
                 {
+                    var t = ReflectionHelpers.GetActualType(obj);
+
+                    if (!FilterName(t.FullName) || ReflectionHelpers.IsEnumerable(t) || ReflectionHelpers.IsCppList(t))
+                    {
+                        continue;
+                    }
+
                     yield return obj;
                 }
             }
         }
-
-        public static IEnumerable<Type> GetTypesSafe(Assembly asm)
-        {
-            try { return asm.GetTypes(); }
-            catch (ReflectionTypeLoadException e) { return e.Types.Where(x => x != null); }
-            catch { return Enumerable.Empty<Type>(); }
-        }
     }
 }

src/MainMenu/Pages/WindowPage.cs

@@ -9,7 +9,7 @@ namespace Explorer
 {
     public abstract class WindowPage
     {
-        public virtual string Name { get; set; }
+        public virtual string Name { get; }
 
         public Vector2 scroll = Vector2.zero;
 

src/UnstripFixes/GUIUnstrip.cs

@@ -24,13 +24,23 @@ namespace Explorer
         {
             get
             {
-#if Release_2019
-                return GUI.scrollViewStates;
-#else 
-                return GUI.s_ScrollViewStates;
-#endif
+                if (m_scrollViewStatesInfo == null)
+                {
+                    try
+                    {
+                        m_scrollViewStatesInfo = typeof(GUI).GetProperty("scrollViewStates");
+                        if (m_scrollViewStatesInfo == null) throw new Exception();
+                    }
+                    catch
+                    {
+                        m_scrollViewStatesInfo = typeof(GUI).GetProperty("s_scrollViewStates");
+                    }
+                }
+
+                return (GenericStack)m_scrollViewStatesInfo?.GetValue(null, null);
             }
         }
+        private static PropertyInfo m_scrollViewStatesInfo;
 
         // ======= public methods ======= //   
 
@@ -49,24 +59,6 @@ namespace Explorer
             return last;
         }
 
-        public static float HorizontalScrollbar(Rect position, float value, float size, float leftValue, float rightValue, GUIStyle style)
-        {
-            return Scroller_Impl(position, value, size, leftValue, rightValue, style, 
-                GUI.skin.GetStyle(style.name + "thumb"), 
-                GUI.skin.GetStyle(style.name + "leftbutton"), 
-                GUI.skin.GetStyle(style.name + "rightbutton"), 
-                true);
-        }
-
-        public static float VerticalScrollbar(Rect position, float value, float size, float topValue, float bottomValue, GUIStyle style)
-        {
-            return Scroller_Impl(position, value, size, topValue, bottomValue, style, 
-                GUI.skin.GetStyle(style.name + "thumb"), 
-                GUI.skin.GetStyle(style.name + "upbutton"), 
-                GUI.skin.GetStyle(style.name + "downbutton"), 
-                false);
-        }
-
         // Fix for BeginScrollView.
 
         public static Vector2 BeginScrollView(Vector2 scroll, params GUILayoutOption[] options)
@@ -221,7 +213,7 @@ namespace Explorer
                     }
                     if (flag2 && horizontalScrollbar != GUIStyle.none)
                     {
-                        scrollPosition.x = HorizontalScrollbar(
+                        scrollPosition.x = HorizBar_Impl(
                             new Rect(
                                 position.x,
                                 position.yMax - horizontalScrollbar.fixedHeight,
@@ -243,7 +235,7 @@ namespace Explorer
                     }
                     if (flag && verticalScrollbar != GUIStyle.none)
                     {
-                        scrollPosition.y = VerticalScrollbar(
+                        scrollPosition.y = VertBar_Impl(
                             new Rect(
                                 screenRect.xMax + (float)verticalScrollbar.margin.left,
                                 screenRect.y,
@@ -279,6 +271,24 @@ namespace Explorer
             return scrollPosition;
         }
 
+        public static float HorizBar_Impl(Rect position, float value, float size, float leftValue, float rightValue, GUIStyle style)
+        {
+            return Scroller_Impl(position, value, size, leftValue, rightValue, style,
+                GUI.skin.GetStyle(style.name + "thumb"),
+                GUI.skin.GetStyle(style.name + "leftbutton"),
+                GUI.skin.GetStyle(style.name + "rightbutton"),
+                true);
+        }
+
+        public static float VertBar_Impl(Rect position, float value, float size, float topValue, float bottomValue, GUIStyle style)
+        {
+            return Scroller_Impl(position, value, size, topValue, bottomValue, style,
+                GUI.skin.GetStyle(style.name + "thumb"),
+                GUI.skin.GetStyle(style.name + "upbutton"),
+                GUI.skin.GetStyle(style.name + "downbutton"),
+                false);
+        }
+
         private static void EndScrollView_Impl(bool handleScrollWheel)
         {
             GUIUtility.CheckOnGUI();
@@ -337,7 +347,7 @@ namespace Explorer
                 rect2 = new Rect(position.x, position.yMax - rightButton.fixedHeight, position.width, rightButton.fixedHeight);
             }
 
-            value = Slider(position2, value, size, leftValue, rightValue, slider, thumb, horiz, controlID);
+            value = Slider_Impl(position2, value, size, leftValue, rightValue, slider, thumb, horiz, controlID);
 
             bool flag = Event.current.type == EventType.MouseUp;
             if (ScrollerRepeatButton_Impl(controlID, rect, leftButton))
@@ -363,7 +373,7 @@ namespace Explorer
             return value;
         }
 
-        public static float Slider(Rect position, float value, float size, float start, float end, GUIStyle slider, GUIStyle thumb, bool horiz, int id)
+        public static float Slider_Impl(Rect position, float value, float size, float start, float end, GUIStyle slider, GUIStyle thumb, bool horiz, int id)
         {
             if (id == 0)
             {

src/Windows/GameObjectWindow.cs

@@ -48,12 +48,6 @@ namespace Explorer
 
         public bool GetObjectAsGameObject()
         {
-            if (Target == null)
-            {
-                MelonLogger.Log("Target is null!");
-                return false;
-            }
-
             var targetType = Target.GetType();
 
             if (targetType == typeof(GameObject))
@@ -108,6 +102,22 @@ namespace Explorer
         {
             try
             {
+                if (Target == null)
+                {
+                    MelonLogger.Log("Target is null!");
+                    DestroyWindow();
+                    return;
+                }
+                else if (Target is UnityEngine.Object uObj)
+                {
+                    if (!uObj)
+                    {
+                        MelonLogger.Log("Target was destroyed!");
+                        DestroyWindow();
+                        return;
+                    }
+                }
+
                 if (!m_object && !GetObjectAsGameObject())
                 {
                     throw new Exception("Object is null!");
@@ -128,28 +138,22 @@ namespace Explorer
                     m_object.transform.localScale = m_frozenScale;
                 }
 
-                var list = new List<Transform>();
+                // update child objects
+                var childList = new List<Transform>();
                 for (int i = 0; i < m_object.transform.childCount; i++)
                 {
-                    list.Add(m_object.transform.GetChild(i));
+                    childList.Add(m_object.transform.GetChild(i));
                 }
-                list.Sort((a, b) => b.childCount.CompareTo(a.childCount));
-                m_children = list.ToArray();
+                childList.Sort((a, b) => b.childCount.CompareTo(a.childCount));
+                m_children = childList.ToArray();
 
                 ChildPages.ItemCount = m_children.Length;
 
-                var list2 = new List<Component>();
-                foreach (var comp in m_object.GetComponents(ReflectionHelpers.ComponentType))
-                {
-                    var ilType = comp.GetIl2CppType();
-                    if (ilType == ReflectionHelpers.TransformType)
-                    {
-                        continue;
-                    }
+                // update components
+                var compList = new Il2CppSystem.Collections.Generic.List<Component>();
+                m_object.GetComponentsInternal(ReflectionHelpers.ComponentType, true, false, true, false, compList);
 
-                    list2.Add(comp);
-                }
-                m_components = list2.ToArray();
+                m_components = compList.ToArray();
 
                 CompPages.ItemCount = m_components.Length;
             }

src/Windows/ReflectionWindow.cs

@@ -22,8 +22,6 @@ namespace Explorer
         private CacheObjectBase[] m_cachedMembersFiltered;
 
         public PageHelper Pages = new PageHelper();
-        //private int m_pageOffset;
-        //private int m_limitPerPage = 20;
 
         private bool m_autoUpdate = false;
         private string m_search = "";
@@ -69,6 +67,20 @@ namespace Explorer
 
         public override void Update()
         {
+            if (Target == null)
+            {
+                DestroyWindow();
+                return;
+            }
+            else if (Target is UnityEngine.Object uObj)
+            {
+                if (!uObj)
+                {
+                    DestroyWindow();
+                    return;
+                }
+            }
+
             m_cachedMembersFiltered = m_allCachedMembers.Where(x => ShouldProcessMember(x)).ToArray();
 
             if (m_autoUpdate)

src/Windows/TabViewWindow.cs

@@ -26,6 +26,7 @@ namespace Explorer
         }
 
         public override void Init() { }
+
         public override void Update() 
         {
             while (TargetTabID >= WindowManager.Windows.Count)

src/Windows/WindowManager.cs

@@ -109,7 +109,7 @@ namespace Explorer
 
                     if (!equals && iObj is Il2CppSystem.Object iCurrent && window.Target is Il2CppSystem.Object iTarget)
                     {
-                        if (iCurrent.GetIl2CppType() != iTarget.GetIl2CppType())
+                        if (iCurrent.GetIl2CppType().FullName != iTarget.GetIl2CppType().FullName)
                         {
                             if (iCurrent is Transform transform)
                             {