如何强制 Unity 的 SerializedProperty 调用 OnValidate 回调？

Question

I am writing a extension method to simplify the use of SerializedProperty

The idea is that the user of the method should be able to set the value of a SerializedProperty without having to worry about the type. As illustrated in the example below, the correct type should be handled according the the type of serializedProperty and myValue .

Example of the regular use of SerializedProperty , the Unity way:

serializedProperty.intValue = myIntValue;
serializedProperty.floatValue = myFloatValue;
serializedProperty.boolValue = myBoolValue;
...

Intended syntax for my SerializedProperty method extension

serializedProperty.SetValue(myValue);

My current implementation of this SerializedProperty method extension

public static void SetValue<TValue>(this SerializedProperty property, TValue value)
{
    if (property.hasMultipleDifferentValues)
        throw new ArgumentOutOfRangeException();

    Type parentType = property.serializedObject.targetObject.GetType();
    FieldInfo fieldInfo = parentType.GetField(property.propertyPath);
    fieldInfo.SetValue(property.serializedObject.targetObject, value);
}

---

The Problem:

This implementation does not call the OnValidate Unity callback. The regular usage ( mySerializedProperty.intValue = myInt ) does.

MY QUESTION : Is there any way to force Unity to call the OnValidate method on the SerializedProperty ?

I have considered calling OnValidate by myself via reflection but since this is already implemented in Unity I was wondering if there was a way to mark the SerializedProperty as changed or something similar.

---

For testing this behavior, I have written the following test (NUnit):

private IntMonoBehaviourMock _mockInstance;

[SetUp]
public void CallBeforeEachTest()
{
    GameObject gameObject = new GameObject();
    this._mockInstance = gameObject.AddComponent<IntMonoBehaviourMock>();
}

[Test]
// This test fails for the current implementation
public void SetValue_ToDifferentValue_OnValidateCalledOnce()
{
    this.SetValueOfSUT(0x1CE1CE);

    int numCallsBefore = this._mockInstance.NumTimesValidateCalled;
    this.SetValueOfSUT(0xBABE);
    int numCallsAfter = this._mockInstance.NumTimesValidateCalled;

    int actualNumCalls = numCallsAfter - numCallsBefore;
    Assert.AreEqual(1, actualNumCalls); // Fails
}

private void SetValueOfSUT(int value)
{
    string fieldName = "publicSerializedField"
    SerializedObject serializedObject = new SerializedObject(this._mockInstance);
    SerializedProperty sut = this._serializedObject.FindProperty(fieldName);

    // This is the call to function being tested!
    // Swapping this for sut.intValue = value, makes the test pass.
    // (But the purpose is to write a function that handles any type correctly)
    sut.SetValue(value);

    this._serializedObject.ApplyModifiedProperties();
}

The implementation of IntMonoBehaviourMock that I am using in the test is:

public class IntMonoBehaviourMock: MonoBehaviour
{
    [SerializeField]
    public int publicSerializedField = default;

    public int NumTimesValidateCalled { get; private set; }

    protected void OnValidate()
    {
        this.NumTimesValidateCalled++;
    }
}

The result of the test is:

Expected: 1
  But was:  0

Answer 1

You could ofcourse call OnValidate also without Reflection by making it

public void OnValidate() ...

and then in the Editor call

theProperty.SetValue(5);
((IntMonoBehaviourMock)target).OnValidate();

or what I sometimes do is make the Editor a subclass of the according type so you have access to private and protected methods as well. I usually male it still in different files using

public partial class IntMonoBehaviourMock
{
    ...

#if UnityEditor
    private partial class IntMonoBehaviourMockEditor { }
#endif
}

and then in a separate file

#if UnityEditor
public partial class IntMonoBehaviourMock
{
    [CustomEditor(typeof(IntMonoBehaviourMock)]
    private partial class IntMonoBehaviourMockEditor : Editor
    {
        ...
    }
}
#endif

---

The possible types are quite limited

AnimationCurve, BoundsInt, bool, Bounds, Color, double, float, int, long, 
Quaternion, RectInt, Rect, string, Vector2, Vector2Int, Vector3, Vector3Int, Vector4

and a special one

UnityEngine.Object

which is the parent class for (almost) all Unity classes.

I can think of alternatively using something like

var type = typeof(TValue);

if(type == typeof(int))
{
    serializedProperty.intValue = value;
}
else if(type == typeof(string)
{
    serializedProperty.stringValue = value;
}

...

else if(type.IsAssignableFrom(typeof(UnityEngine.Object)))
{
    serializedProperty.objectReferenceValue = value;
}
else
{
    Debug.LogError("Unassignable type: " + type.FullName);
}

actually you would then not even require the generic but could also simply use

var type = value.GetType();