Set.cs

using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
 
namespace MPewsey.Common.Collections
{
    [DataContract(Name = "Set", Namespace = Constants.DataContractNamespace)]
    public class Set<T> : ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, ISet<T>
    {
        public HashSet<T> HashSet { get; private set; } = new HashSet<T>();
 
        [DataMember(Order = 1, Name = "Values")]
        public T[] Array { get => GetArray(); set => HashSet = new HashSet<T>(value); }
 
        public Set()
        {
 
        }
 
        public Set(IEnumerable<T> collection)
        {
            HashSet = new HashSet<T>(collection);
        }
 
        public static implicit operator Set<T>(HashSet<T> set)
        {
            return set == null ? null : new Set<T> { HashSet = set };
        }
 
        private T[] GetArray()
        {
            if (HashSet.Count == 0)
                return System.Array.Empty<T>();
 
            var array = new T[HashSet.Count];
            CopyTo(array, 0);
            return array;
        }
 
        public int Count => HashSet.Count;
 
        public bool IsReadOnly => ((ICollection<T>)HashSet).IsReadOnly;
 
        void ICollection<T>.Add(T item)
        {
            ((ICollection<T>)HashSet).Add(item);
        }
 
        public void Clear()
        {
            HashSet.Clear();
        }
 
        public bool Contains(T item)
        {
            return HashSet.Contains(item);
        }
 
        public void CopyTo(T[] array, int arrayIndex)
        {
            HashSet.CopyTo(array, arrayIndex);
        }
 
        public void ExceptWith(IEnumerable<T> other)
        {
            HashSet.ExceptWith(other);
        }
 
        public HashSet<T>.Enumerator GetEnumerator()
        {
            return HashSet.GetEnumerator();
        }
 
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return HashSet.GetEnumerator();
        }
 
        public void IntersectWith(IEnumerable<T> other)
        {
            HashSet.IntersectWith(other);
        }
 
        public bool IsProperSubsetOf(IEnumerable<T> other)
        {
            return HashSet.IsProperSubsetOf(other);
        }
 
        public bool IsProperSupersetOf(IEnumerable<T> other)
        {
            return HashSet.IsProperSupersetOf(other);
        }
 
        public bool IsSubsetOf(IEnumerable<T> other)
        {
            return HashSet.IsSubsetOf(other);
        }
 
        public bool IsSupersetOf(IEnumerable<T> other)
        {
            return HashSet.IsSupersetOf(other);
        }
 
        public bool Overlaps(IEnumerable<T> other)
        {
            return HashSet.Overlaps(other);
        }
 
        public bool Remove(T item)
        {
            return HashSet.Remove(item);
        }
 
        public bool SetEquals(IEnumerable<T> other)
        {
            return HashSet.SetEquals(other);
        }
 
        public void SymmetricExceptWith(IEnumerable<T> other)
        {
            HashSet.SymmetricExceptWith(other);
        }
 
        public void UnionWith(IEnumerable<T> other)
        {
            HashSet.UnionWith(other);
        }
 
        public bool Add(T item)
        {
            return HashSet.Add(item);
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)HashSet).GetEnumerator();
        }
    }
}