How can you add a Serializable HashSet to Unity / C#?

Question

I need a HashSet I can edit in the Inspector.

I've found this solution...

Posted here...

using System;
using System.Collections.Generic;
using UnityEngine;

[Serializable]
public class SerializableHashSet<T> : HashSet<T>, ISerializationCallbackReceiver
{
    [SerializeField] 
    private List<T> values = new List<T>();

    public SerializableHashSet() : base() {}
    
    public SerializableHashSet(IEnumerable<T> collection) : base(collection) {}

    public void OnBeforeSerialize ()
    {
        var cur = new HashSet<T> (values);
        
        foreach (var val in this) {
            if (!cur.Contains (val)) {
                values.Add (val);
            }
        }
    }
    
    public void OnAfterDeserialize ()
    {
        Clear ();

        foreach (var val in values)
        {
            if (val != null)
            Add (val);
        }
    }
}

However it throws the following 2 errors...

NullReferenceException: Object reference not set to an instance of an object
System.Collections.Generic.HashSet`1+Enumerator[T].MoveNext () (at <351e49e2a5bf4fd6beabb458ce2255f3>:0)
SerializableHashSet`1[T].OnBeforeSerialize () (at Assets/Scripts/Utilities/Collections/SerializableHashSet.cs:23)

ArgumentNullException: Value cannot be null.
Parameter name: array
System.Array.Clear (System.Array array, System.Int32 index, System.Int32 length) (at <695d1cc93cca45069c528c15c9fdd749>:0)
System.Collections.Generic.HashSet`1[T].Clear () (at <351e49e2a5bf4fd6beabb458ce2255f3>:0)
SerializableHashSet`1[T].OnAfterDeserialize () (at Assets/Scripts/Utilities/Collections/SerializableHashSet.cs:32)

I'm also not sure I need the check on line 21 - Surely duplicates just wouldn't be in the internal HashSet in the first place?

Answer 1

In general it is a little bit dangerous to simply inherit from collection types.

Honestly not even sure but I think the issue here is related to the constructor not being called correctly by the serializer.

Instead I would (even though it is more work of course) have a wrapper class containing both fields, a List<T> and a HashSet<T> parallel and then implement the same interfaces, forwarding them to the HashSet field like e.g.

[Serializable]
public class SerializableHashSet<T> :
    ISerializationCallbackReceiver,
    ISet<T>,
    IReadOnlyCollection<T>
{
    [SerializeField] private List<T> values = new List<T>();
    private HashSet<T> _hashSet = new HashSet<T>();


    #region Constructors

    // empty constructor required for Unity serialization
    public SerializableHashSet() { }

    public SerializableHashSet(IEnumerable<T> collection)
    {
        _hashSet = new HashSet<T>(collection);
    }

    #endregion Constructors


    #region Interface forwarding to the _hashset

    public int Count => _hashSet.Count;
    public bool IsReadOnly => false;
    public bool ISet<T>.Add(T item) => _hashSet.Add(item);
    public bool ICollection<T>.Remove(T item) => _hashSet.Remove(item);
    public void ExceptWith(IEnumerable<T> other) => _hashSet.ExceptWith(other);
    public void IntersectWith(IEnumerable<T> other) => _hashSet.IntersectWith(other);
    public bool IsProperSubsetOf(IEnumerable<T> other) => _hashSet.IsProperSubsetOf(other);
    public bool IsProperSupersetOf(IEnumerable<T> other) => _hashSet.IsProperSupersetOf(other);
    public bool IsSubsetOf(IEnumerable<T> other) => _hashSet.IsSubsetOf(other);
    public bool IsSupersetOf(IEnumerable<T> other) => _hashSet.IsSupersetOf(other);
    public bool Overlaps(IEnumerable<T> other) => _hashSet.Overlaps(other);
    public bool SetEquals(IEnumerable<T> other) => _hashSet.SetEquals(other);
    public void SymmetricExceptWith(IEnumerable<T> other) => _hashSet.SymmetricExceptWith(other);
    public void UnionWith(IEnumerable<T> other) => _hashSet.UnionWith(other);
    public void Clear() => _hashSet.Clear();
    public bool Contains(T item) => _hashSet.Contains(item);
    public void CopyTo(T[] array, int arrayIndex) => _hashSet.CopyTo(array, arrayIndex);
    Collection<T>.Add(T item) => _hashSet.Add(item);
    public IEnumerator<T> GetEnumerator() => _hashSet.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    #endregion Interface forwarding to the _hashset


    #region ISerializationCallbackReceiver implemenation

    public void OnBeforeSerialize()
    {
        var cur = new HashSet<T>(values);

        foreach (var val in this)
        {
            if (!cur.Contains(val))
            {
                values.Add(val);
            }
        }
    }

    public void OnAfterDeserialize()
    {
        Clear();

        foreach (var val in values)
        {
            Add(val);
        }
    }

    #endregion ISerializationCallbackReceiver implemenation
}

If this is the optimal approach I can't tell but it works without exceptions ;)

Note though

In the Inspector you still can have duplicate entries which will be simply ignored by the HashSet. Also entries that are removed in the HashSet will remain in the List!

This limitation is from your ISerializationCallbackReceiver implementation. t was done like this due to the Inspector simply copying the last entry when adding elements so otherwise it would simply not be possible at all to add elements via the Inspector. There is not really a way around this except implementing a custom drawer...