在 Unity C# 中序列化 ObservableCollection 类 ObservableList

Question

由于目前尚不支持在 Unity 中序列化 C# 的 ObservableCollection，因此我正在使用扩展 List<> 的脚本并创建一个名为 ObservableList 的可序列化类，如本统一论坛答案 ObservableList 中所述.以下是相同的代码：

[Serializable]
 public class ObservedList<T> : List<T>
 {
     public event Action<int> Changed = delegate { };
     public event Action Updated = delegate { };
     public new void Add(T item)
     {
         base.Add(item);
         Updated();
     }
     public new void Remove(T item)
     {
         base.Remove(item);
         Updated();
     }
     public new void AddRange(IEnumerable<T> collection)
     {
         base.AddRange(collection);
         Updated();
     }
     public new void RemoveRange(int index, int count)
     {
         base.RemoveRange(index, count);
         Updated();
     }
     public new void Clear()
     {
         base.Clear();
         Updated();
     }
     public new void Insert(int index, T item)
     {
         base.Insert(index, item);
         Updated();
     }
     public new void InsertRange(int index, IEnumerable<T> collection)
     {
         base.InsertRange(index, collection);
         Updated();
     }
     public new void RemoveAll(Predicate<T> match)
     {
         base.RemoveAll(match);
         Updated();
     }


     public new T this[int index]
     {
         get
         {
             return base[index];
         }
         set
         {
             base[index] = value;
             Changed(index);
         }
     }
 }

它仍然没有被序列化，我在 Unity 编辑器中看不到它。任何帮助将不胜感激！

编辑#1

预期用例：

public class Initialize : MonoBehaviour
{
    public ObservedList<int> percentageSlider = new ObservedList<int>();
    
    void Start()
    {
        percentageSlider.Changed += ValueUpdateHandler;
    }
    
    void Update()
    {
    }
    
    private void ValueUpdateHandler(int index)
    {
        // Some index specific action
        Debug.Log($"{index} was updated");
    }
}

我将此脚本作为组件附加到游戏对象，以便我可以输入此列表的 size，使用这些值（就像我可以使用 List 一样）并执行一些只能获取的操作当ObservableList 中的某些值更新时触发。

我想看什么

我所看到的

Answer 1

So here is what I did

与其继承 List<T> 并尝试使用编辑器脚本以某种方式修复 Inspector，您可以简单地使用“后端”List<T>，Unity 已经为其提供了序列化并让您的类实现IList<T>，例如

[Serializable]
public class ObservedList<T> : IList<T>
{
    public delegate void ChangedDelegate(int index, T oldValue, T newValue);

    [SerializeField] private List<T> _list = new List<T>();

    // NOTE: I changed the signature to provide a bit more information
    // now it returns index, oldValue, newValue
    public event ChangedDelegate Changed;

    public event Action Updated;

    public IEnumerator<T> GetEnumerator()
    {
        return _list.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public void Add(T item)
    {
        _list.Add(item);
        Updated?.Invoke();
    }

    public void Clear()
    {
        _list.Clear();
        Updated?.Invoke();
    }

    public bool Contains(T item)
    {
        return _list.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        _list.CopyTo(array, arrayIndex);
    }

    public bool Remove(T item)
    {
        var output = _list.Remove(item);
        Updated?.Invoke();

        return output;
    }

    public int Count => _list.Count;
    public bool IsReadOnly => false;

    public int IndexOf(T item)
    {
        return _list.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        _list.Insert(index, item);
        Updated?.Invoke();
    }

    public void RemoveAt(int index)
    {
        _list.RemoveAt(index);
        Updated?.Invoke();
    }

    public void AddRange(IEnumerable<T> collection)
    {
        _list.AddRange( collection);
        Updated?.Invoke();
    }

    public void RemoveAll(Predicate<T> predicate)
    {
        _list.RemoveAll(predicate);
        Updated?.Invoke();
    }

    public void InsertRange(int index, IEnumerable<T> collection)
    {
        _list.InsertRange(index, collection);
        Updated?.Invoke();
    }

    public void RemoveRange(int index, int count)
    {
        _list.RemoveRange(index, count);
        Updated?.Invoke();
    }

    public T this[int index]
    {
        get { return _list[index]; }
        set
        {
            var oldValue = _list[index];
            _list[index] = value;
            Changed?.Invoke(index, oldValue, value);
            // I would also call the generic one here
            Updated?.Invoke();
        }
    }
}

在代码的使用中绝对没有任何变化（除了提到的事件的一个签名）：

public class Example : MonoBehaviour
{
    public ObservedList<int> percentageSlider = new ObservedList<int>();

    private void Start()
    {
        percentageSlider.Changed += ValueUpdateHandler;

        // Just as an example
        percentageSlider[3] = 42;
    }

    private void ValueUpdateHandler(int index, int oldValue, int newValue)
    {
        // Some index specific action
        Debug.Log($"Element at index {index} was updated from {oldValue} to {newValue}");
    }
}

但 Inspector 现在看起来像这样

---

如果你真的需要，因为你讨厌它在编辑器中的样子^^你可以使用一些肮脏的黑客并像这样覆盖它

有一个非泛型基类，因为自定义编辑器不适用于泛型

public abstract class ObservedList { }

然后从那个继承

[Serializable]
public class ObservedList<T> : ObservedList, IList<T>
{
   ...
}

然后我们可以实现一个自定义抽屉，实际上提供基本类型，但它将应用于继承者

[CustomPropertyDrawer(typeof(ObservedList), true)]
public class ObservedListDrawer : PropertyDrawer
{
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        // NOTE: Now here is the dirty hack
        // even though the ObservedList itself doesn't have that property
        // we can still look for the field called "_list" which only the 
        // ObservedList<T> has
        var list = property.FindPropertyRelative("_list");
        EditorGUI.PropertyField(position, list, label, true);
    }

    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
    {
        var list = property.FindPropertyRelative("_list");

        return EditorGUI.GetPropertyHeight(list, label, true);
    }
}

现在是这个样子

---

Unity 2019 及更早版本

在 Unity 2019 及更早版本中，根本不支持泛型的序列化。

在Script Serialization 2020 中添加了这个：

泛型字段类型也可以直接序列化，无需声明非泛型子类。

Script Serialization 2019 和更早版本的情况并非如此。

所以在这里你需要有明确的实现，比如

[Serializable]
public class ObservedListInt : ObservedList<int>{ }

public class Example : MonoBehaviour
{
    public ObservedListInt percentageSlider = new ObservedListInt();

    private void Start()
    {
        percentageSlider.Changed += ValueUpdateHandler;

        // Just as an example
        percentageSlider[3] = 42;
    }

    private void ValueUpdateHandler(int index, int oldValue, int newValue)
    {
        // Some index specific action
        Debug.Log($"Element at index {index} was updated from {oldValue} to {newValue}");
    }
}

没有自定义抽屉

带有自定义抽屉

Answer 2

1. 如果您希望对操作进行序列化，则必须使用 UnityEvents（它与 Unity 的序列化事件系统挂钩）。

2. 确保在所有要序列化的类型之前使用 [SerializedField] 属性。

3. 主要问题可能源于继承，它不能很好地与 Unity 的序列化系统配合使用。一般来说，我永远不会从 List 继承 (here are some reasons why) 相反，我会让你的 observable 类型成为 List 的包装器，并带有一些附加功能（List 将是 Observable 中的成员）。

编辑 1

添加了一个经过测试的代码示例。 ObservedList 不是继承，而是充当 List 的包装器。 您将能够订阅 Changed 和 Updated 事件，但它们没有被序列化。如果您想访问任何其他列表功能，您只需在 ObservedList 类中添加一个公共方法，该方法充当其 包装器。如果您有任何其他问题，请告诉我。

[Serializable]
public class ObservedList<T>
{
    public event Action<int> Changed;
    public event Action Updated;
    [SerializeField] private List<T> _value;
    
    public T this[int index]
    {
        get
        {
            return _value[index];
        }
        set
        {
            //you might want to add a check here to only call changed
            //if _value[index] != value
            _value[index] = value;
            Changed?.Invoke(index);
        }
    }
    
    public void Add(T item)
    {
        _value.Add(item);
        Updated?.Invoke();
    }
    public void Remove(T item)
    {
        _value.Remove(item);
        Updated?.Invoke();
    }
    public void AddRange(IEnumerable<T> collection)
    {
        _value.AddRange(collection);
        Updated?.Invoke();
    }
    public void RemoveRange(int index, int count)
    {
        _value.RemoveRange(index, count);
        Updated?.Invoke();
    }
    public void Clear()
    {
        _value.Clear();
        Updated?.Invoke();
    }
    public void Insert(int index, T item)
    {
        _value.Insert(index, item);
        Updated?.Invoke();
    }
    public void InsertRange(int index, IEnumerable<T> collection)
    {
        _value.InsertRange(index, collection);
        Updated?.Invoke();
    }
    public void RemoveAll(Predicate<T> match)
    {
        _value.RemoveAll(match);
        Updated?.Invoke();
    }
}