Better way to handle objects instantiation when using the ReferencePicker attribute; possibility to force uninitialized object creation

Author: arimger

Assets/Editor Toolbox/Editor/Drawers/Toolbox/PropertySelf/ReferencePickerAttributeDrawer.cs

@@ -1,6 +1,5 @@
 #if UNITY_2019_3_OR_NEWER
 using System;
-using System.Runtime.Serialization;
 
 using UnityEditor;
 using UnityEngine;
@@ -17,13 +16,12 @@ public class ReferencePickerAttributeDrawer : ToolboxSelfPropertyDrawer<Referenc
         private static readonly TypeAppearanceContext sharedAppearance = new TypeAppearanceContext(sharedConstraint, TypeGrouping.None, true);
         private static readonly TypeField typeField = new TypeField(sharedConstraint, sharedAppearance);
 
-
         private void UpdateContexts(ReferencePickerAttribute attribute)
         {
             sharedAppearance.TypeGrouping = attribute.TypeGrouping;
         }
 
-        private Type GetParentType(SerializedProperty property, ReferencePickerAttribute attribute)
+        private Type GetParentType(ReferencePickerAttribute attribute, SerializedProperty property)
         {
             var fieldInfo = property.GetFieldInfo(out _);
             var fieldType = property.GetProperType(fieldInfo);
@@ -42,7 +40,7 @@ private Type GetParentType(SerializedProperty property, ReferencePickerAttribute
             return fieldType;
         }
 
-        private void CreateTypeProperty(Rect position, SerializedProperty property, Type parentType)
+        private void CreateTypeProperty(SerializedProperty property, Type parentType, ReferencePickerAttribute attribute, Rect position)
         {
             TypeUtilities.TryGetTypeFromManagedReferenceFullTypeName(property.managedReferenceFullTypename, out var currentType);
             typeField.OnGui(position, true, (type) =>
@@ -51,7 +49,7 @@ private void CreateTypeProperty(Rect position, SerializedProperty property, Type
                 {
                     if (!property.serializedObject.isEditingMultipleObjects)
                     {
-                        UpdateTypeProperty(property, type);
+                        UpdateTypeProperty(property, type, attribute);
                     }
                     else
                     {
@@ -61,7 +59,7 @@ private void CreateTypeProperty(Rect position, SerializedProperty property, Type
                             using (var so = new SerializedObject(target))
                             {
                                 SerializedProperty sp = so.FindProperty(property.propertyPath);
-                                UpdateTypeProperty(sp, type);
+                                UpdateTypeProperty(sp, type, attribute);
                             }
                         }
                     }
@@ -73,9 +71,10 @@ private void CreateTypeProperty(Rect position, SerializedProperty property, Type
             }, currentType, parentType);
         }
 
-        private void UpdateTypeProperty(SerializedProperty property, Type referenceType)
+        private void UpdateTypeProperty(SerializedProperty property, Type targetType, ReferencePickerAttribute attribute)
         {
-            var obj = referenceType != null ? FormatterServices.GetUninitializedObject(referenceType) : null;
+            var forceUninitializedInstance = attribute.ForceUninitializedInstance;
+            var obj = ReflectionUtility.CreateInstance(targetType, forceUninitializedInstance);
             property.serializedObject.Update();
             property.managedReferenceValue = obj;
             property.serializedObject.ApplyModifiedProperties();
@@ -106,7 +105,6 @@ private Rect PrepareTypePropertyPosition(bool hasLabel, in Rect labelPosition, i
             return position;
         }
 
-
         protected override void OnGuiSafe(SerializedProperty property, GUIContent label, ReferencePickerAttribute attribute)
         {
             //NOTE: we want to close scope manually because ExitGUIException can interrupt drawing and SerializedProperties stack
@@ -122,8 +120,8 @@ protected override void OnGuiSafe(SerializedProperty property, GUIContent label,
                 var hasLabel = !string.IsNullOrEmpty(label.text);
                 var position = PrepareTypePropertyPosition(hasLabel, in labelRect, in inputRect, isPropertyExpanded);
 
-                var parentType = GetParentType(property, attribute);
-                CreateTypeProperty(position, property, parentType);
+                var parentType = GetParentType(attribute, property);
+                CreateTypeProperty(property, parentType, attribute, position);
                 if (isPropertyExpanded)
                 {
                     ToolboxEditorGui.DrawPropertyChildren(property);
@@ -134,7 +132,6 @@ protected override void OnGuiSafe(SerializedProperty property, GUIContent label,
             }
         }
 
-
         public override bool IsPropertyValid(SerializedProperty property)
         {
             return property.propertyType == SerializedPropertyType.ManagedReference;

Assets/Editor Toolbox/Editor/Utilities/ReflectionUtility.cs

@@ -1,19 +1,18 @@
 using System;
 using System.Reflection;
-
+using System.Runtime.Serialization;
 using UnityEditor;
 using Object = UnityEngine.Object;
 
 namespace Toolbox.Editor
 {
     internal static class ReflectionUtility
     {
-        private readonly static Assembly editorAssembly = typeof(UnityEditor.Editor).Assembly;
+        private static readonly Assembly editorAssembly = typeof(UnityEditor.Editor).Assembly;
 
         public const BindingFlags allBindings = BindingFlags.Instance |
             BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public;
 
-
         /// <summary>
         /// Returns <see cref="MethodInfo"/> of the searched method within the Editor <see cref="Assembly"/>.
         /// </summary>
@@ -96,5 +95,31 @@ internal static bool TryInvokeMethod(string methodName, SerializedObject seriali
 
             return true;
         }
+
+        internal static object CreateInstance(Type targetType, bool forceUninitializedInstance)
+        {
+            if (targetType == null)
+            {
+                return null;
+            }
+
+            if (forceUninitializedInstance)
+            {
+                return FormatterServices.GetUninitializedObject(targetType);
+            }
+
+            if (targetType.IsValueType)
+            {
+                return Activator.CreateInstance(targetType);
+            }
+
+            var defaultConstructor = targetType.GetConstructor(Type.EmptyTypes);
+            if (defaultConstructor != null)
+            {
+                return Activator.CreateInstance(targetType);
+            }
+
+            return FormatterServices.GetUninitializedObject(targetType);
+        }
     }
 }

Assets/Editor Toolbox/Runtime/Attributes/Toolbox/PropertySelfAttributes/ReferencePickerAttribute.cs

@@ -31,6 +31,8 @@ public ReferencePickerAttribute(Type parentType, TypeGrouping typeGrouping)
         /// Defaults to <see cref="TypeGrouping.None"/> unless explicitly specified.
         /// </summary>
         public TypeGrouping TypeGrouping { get; set; } = TypeGrouping.None;
+
+        public bool ForceUninitializedInstance { get; set; }
     }
 }
 #endif

Assets/Examples/Scripts/SampleBehaviour6.cs

@@ -9,7 +9,7 @@ public class SampleBehaviour6 : MonoBehaviour
 #if UNITY_2019_3_OR_NEWER
     [SerializeReference, ReferencePicker(TypeGrouping = TypeGrouping.ByFlatName)]
     public Interface1 var1;
-    [SerializeReference, ReferencePicker]
+    [SerializeReference, ReferencePicker(ForceUninitializedInstance = true)]
     public ClassWithInterfaceBase var2;
     [SerializeReference, ReferencePicker(ParentType = typeof(ClassWithInterface2))]
     public ClassWithInterfaceBase var3;
@@ -25,6 +25,12 @@ public struct Struct : Interface1
     {
         public bool var1;
         public bool var2;
+
+        public Struct(bool var1, bool var2)
+        {
+            this.var1 = var1;
+            this.var2 = var2;
+        }
     }
 
     public abstract class ClassWithInterfaceBase : Interface1
@@ -54,6 +60,11 @@ public class ClassWithInterface2 : ClassWithInterfaceBase
     public class ClassWithInterface3 : ClassWithInterfaceBase
     {
         public int var1;
+
+        public ClassWithInterface3(int var1)
+        {
+            this.var1 = var1;
+        }
     }
 
     [Serializable]