diff --git a/src/ObservableCollections/ObservableHashSet.Views.cs b/src/ObservableCollections/ObservableHashSet.Views.cs
new file mode 100644
index 0000000..04838f2
--- /dev/null
+++ b/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();
+        }
+    }
+}
diff --git a/src/ObservableCollections/ObservableHashSet.cs b/src/ObservableCollections/ObservableHashSet.cs
index 821ea3d..fced310 100644
--- a/src/ObservableCollections/ObservableHashSet.cs
+++ b/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 LinkedList<T> list;
+        readonly HashSet<T> set;
+        public readonly object SyncRoot = new object();
 
-        //public ObservableHashSet(LinkedList<T> list)
-        //{
-        //    this.list = list;
-        //}
+        public ObservableHashSet()
+        {
+            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();
+        }
     }
 }
diff --git a/src/ObservableCollections/ObservableQueue.View.cs b/src/ObservableCollections/ObservableQueue.Views.cs
similarity index 100%
rename from src/ObservableCollections/ObservableQueue.View.cs
rename to src/ObservableCollections/ObservableQueue.Views.cs
diff --git a/src/ObservableCollections/ObservableStack.View.cs b/src/ObservableCollections/ObservableStack.Views.cs
similarity index 100%
rename from src/ObservableCollections/ObservableStack.View.cs
rename to src/ObservableCollections/ObservableStack.Views.cs