hashset(working)

src/ObservableCollections/ObservableHashSet.Views.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+
+namespace ObservableCollections
+{
+    public sealed partial class ObservableHashSet<T> : IReadOnlyCollection<T>, IObservableCollection<T>
+    {
+        // TODO:
+        public ISynchronizedView<T, TView> CreateSortedView<TKey, TView>(Func<T, TKey> identitySelector, Func<T, TView> transform, IComparer<T> comparer) where TKey : notnull
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISynchronizedView<T, TView> CreateSortedView<TKey, TView>(Func<T, TKey> identitySelector, Func<T, TView> transform, IComparer<TView> viewComparer) where TKey : notnull
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISynchronizedView<T, TView> CreateView<TView>(Func<T, TView> transform, bool reverse = false)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/ObservableCollections/ObservableHashSet.cs

@@ -1,15 +1,112 @@
-using System.Collections.Generic;
+using ObservableCollections.Internal;
+using System.Collections;
+using System.Collections.Generic;
 
 namespace ObservableCollections
 {
-    public sealed partial class ObservableHashSet<T>
+    // can not implements ISet<T> because set operation can not get added/removed values.
+    public sealed partial class ObservableHashSet<T> : IReadOnlySet<T>, IReadOnlyCollection<T>, IObservableCollection<T>
     {
-        //// TODO:not yet
+        readonly HashSet<T> set;
-        //readonly LinkedList<T> list;
+        public readonly object SyncRoot = new object();
 
-        //public ObservableHashSet(LinkedList<T> list)
+        public ObservableHashSet()
-        //{
+        {
-        //    this.list = list;
+            this.set = new HashSet<T>();
-        //}
+        }
+
+        public ObservableHashSet(int capacity)
+        {
+            this.set = new HashSet<T>(capacity);
+        }
+
+        public ObservableHashSet(IEnumerable<T> collection)
+        {
+            this.set = new HashSet<T>(collection);
+        }
+
+        public event NotifyCollectionChangedEventHandler<T>? CollectionChanged;
+
+        public int Count
+        {
+            get
+            {
+                lock (SyncRoot)
+                {
+                    return set.Count;
+                }
+            }
+        }
+
+        public bool IsReadOnly => false;
+
+        // TODO: Add, Remove, Set operations.
+
+
+        public bool Contains(T item)
+        {
+            lock (SyncRoot)
+            {
+                return set.Contains(item);
+            }
+        }
+
+        public bool IsProperSubsetOf(IEnumerable<T> other)
+        {
+            lock (SyncRoot)
+            {
+                return set.IsProperSubsetOf(other);
+            }
+        }
+
+        public bool IsProperSupersetOf(IEnumerable<T> other)
+        {
+            lock (SyncRoot)
+            {
+                return set.IsProperSupersetOf(other);
+            }
+        }
+
+        public bool IsSubsetOf(IEnumerable<T> other)
+        {
+            lock (SyncRoot)
+            {
+                return set.IsSubsetOf(other);
+            }
+        }
+
+        public bool IsSupersetOf(IEnumerable<T> other)
+        {
+            lock (SyncRoot)
+            {
+                return set.IsSupersetOf(other);
+            }
+        }
+
+        public bool Overlaps(IEnumerable<T> other)
+        {
+            lock (SyncRoot)
+            {
+                return set.Overlaps(other);
+            }
+        }
+
+        public bool SetEquals(IEnumerable<T> other)
+        {
+            lock (SyncRoot)
+            {
+                return set.SetEquals(other);
+            }
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return new SynchronizedEnumerator<T>(SyncRoot, set.GetEnumerator());
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
     }
 }