使用通用 get 方法扩展 SerializedObject

Question

我想为SerializedObject 写一个通用扩展方法，可以用来代替FindProperty，然后访问whateverValue 成员，所以我可以写so.Get<Bool>("myValue") 而不是so.FindProperty("myValue").boolValue。

如果模板专业化是 C# 中的一个东西，我想如何解决这个问题：

public static T Get<T>(this SerializedObject so, string name) {
    Debug.LogError("Get called with unsuported type!");
}

public static bool Get<bool>(this SerializedObject so, string name) {
    return so.FindProperty(name).boolValue;
}

如何在适当的 C# 中实现这样的目标？我也尝试添加一个System.Type 参数而不是专门化，但是这样的函数的返回类型应该是什么？

Answer 1

我会使用一点函数式编程。通用函数的输入参数之一将是另一个函数，它将定义如何读取属性：

    public static T Get<T>(this SerializedObject so, string name, Func<SerializedProperty, T> getter) {
        var property = so.FindProperty(name);
        if (property == null) {
            ;//handle "not found"
        }
        return getter(property);
    }

我将如何使用它的几个示例：

    internal bool ExampleBoolValue(SerializedObject so) {
        return so.Get("myBoolValue", (p => p.boolValue));
    }

    internal int ExampleIntValue(SerializedObject so) {
        return so.Get("myIntValue", (p => p.intValue));
    }

我没有在这台机器上安装 Unity，所以我不确定 Unity 是否支持这些 .NET 功能。

UPDATE 用于 setter 方法：

    public static void Set(this SerializedObject so, string name, Action<SerializedProperty> setter) {
        var property = so.FindProperty(name);
        if (property == null) {
            ;//handle "not found"
        }
        setter(property);
    }

设置值示例：

    internal void SetExampleBoolValue(SerializedObject so, bool newValue) {
        so.Set("myBoolValue", (p => p.boolValue = newValue));
    }

    internal void SetExampleIntValue(SerializedObject so, int newValue) {
        so.Set("myIntValue", (p => p.intValue = newValue));
    }

Action 接受 0..n 个参数并且不返回任何内容。 Func 接受 0..n 个参数并且必须返回一些东西。

Answer 2

您可以使用通用静态的魔力来完成此操作。

第一个类GetPropertyValue<T> 将根据类型存储您的处理程序。静态处理程序最初设置为您的“不受支持”消息，但静态构造函数将调用 InitGetPropertyValue 类来初始化所有处理程序。因为这是在该类的静态构造函数中，所以只会在类第一次初始化时调用一次。

由于GetPropertyValue<int>.Get 的静态变量与静态变量GetPropertyValue<string>.Get 不同，因此您之前存储的类型的处理程序将在每次后续调用时使用。

public static class MyExtensions
{
    private static class GetPropertyValue<T>
    {
        static GetPropertyValue()
        {
            InitGetPropertyValue.Initialize();
        }

        public static Func<SerializedObject, string, T> Get = (so, name) =>
         {
             Debug.Print("Get called with unsupported type!");
             return default(T);
         };
    }

    private static class InitGetPropertyValue
    {
        static InitGetPropertyValue()
        {
            Debug.Print("Initializing property getters");
            GetPropertyValue<int>.Get = (so, name) => (int)so.FindProperty(name) ;
            GetPropertyValue<Guid>.Get = (so, name) => (Guid)so.FindProperty(name);
            GetPropertyValue<string>.Get = (so, name) => so.FindProperty(name).ToString();
        }

        public static bool Initialize()
        {
            return true;
        }
    }

    public static T Get<T>(this SerializedObject so, string name)
    {
        return GetPropertyValue<T>.Get(so, name);
    }
}

Answer 3

虽然不是一个漂亮的解决方案，但一个可行的解决方案可能是这样的：

public static T Get<T>(this SerializedObject so, string name) {
    if (typeof(T) == typeof(bool){
        return (T)(object)so.FindProperty(name).boolValue;
    }
    else if {
    ...
    }
    else {
        Debug.LogError("Get called with unsuported type!");
    }
}

我个人会喜欢这样的东西：

public static bool GetBoolean(this SerializedObject so, string name)
public static int GetInt(this SerializedObject so, string name)

语义保持不变，但实现更简洁。