class MySet
{
private HashSet<SomeObject> _items;

public HashSet<SomeObject> Items {get{return _items;}}

public void Add(item);
public void Remove(item);
}

K>class MySet
K>{
K>private HashSet<SomeObject> _items;

K>public HashSet<SomeObject> Items {get{return _items;}}

K>public void Add(item);
K>public void Remove(item);
K>}

K>

K>Делать правильно (реализовывать IEnumerable) привлекает, но — лень

 public IEnumerable<SomeObject> Items {get {return _items.AsEnumerable(); } }

 public IEnumerable<SomeObject> Items {get {return _items; } }

 
public IEnumerable<SomeType> Items
{
  get
  {
    foreach (var item in _items) yield return item;
  }
}

foreach (var item in _items) yield return item;

_items.AsEnumerable()

 
S>public IEnumerable<SomeType> Items
S>{
S>  get
S>  {
S>    foreach (var item in _items) yield return item;
S>  }
S>}

var x = o.Items;
…
var y = o.Items;
…
if(x == y) {
  // сюда не попадём.
}//if

public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source)
{
    return source;
}

LF>foreach (var item in _items) yield return item;
LF>

LF>_items.AsEnumerable()
LF>

public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source)
{
    return source;
}

LF>foreach (var item in _items) yield return item;
LF>

LF>_items.AsEnumerable()
LF>

Remarks

The Enumerable.AsEnumerable<TSource> method has no effect other than to change the compile-time type of source from a type that implements IEnumerable<(Of <(T>)>) to IEnumerable<(Of <(T>)>) itself.

_FR>Это решение для лентяев, которые не могут написать нормальную, удобную обёртку а делов-то на десять минут.

            private EnumeratorAdapter<SomeType> _itemsWrapper;
            private IEnumerable<SomeType> Items
            {
                get
                {
                    return _itemsWrapper ?? (_itemsWrapper = new EnumeratorAdapter<SomeType>(GetItemsEnumerator));
                }
            }

            private IEnumerator<SomeType> GetItemsEnumerator()
            {
                foreach (var b in _items)
                {
                    yield return b;
                }
            }

        public class EnumeratorAdapter<T> : IEnumerable<T>
        {
            private Func<IEnumerator<T>> _getEnumerator;
            public EnumeratorAdapter(Func<IEnumerator<T>> getEnumerator)
            {
                if (getEnumerator == null)
                    throw new ArgumentNullException("getEnumerator");

                _getEnumerator = getEnumerator;
            }

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

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

        }

_FR>>Это решение для лентяев, которые не могут написать нормальную, удобную обёртку а делов-то на десять минут.

  #region Using's

  using System;
  using System.Collections;
  using System.Collections.Generic;
  using System.Diagnostics;

  #endregion Using's

  [Serializable]
  [DebuggerDisplay("Count = {Count}")]
  public class ReadOnlyCollection2<TItem> : ICollection<TItem>, IEnumerable<TItem>, IEnumerable
  {
    #region Fields

    private readonly ICollection<TItem> items;

    #endregion Fields

    #region Constructor(s)

    public ReadOnlyCollection2(ICollection<TItem> items) {
      if(items == null) {
        throw new ArgumentNullException("items");
      }//if

      this.items = items;
    }

    #endregion Constructor(s)

    #region Properties

    protected ICollection<TItem> Items {
      [DebuggerStepThrough]
      get { return items; }
    }

    #endregion Properties

    #region Methods

    private Exception CreateReadOnlyException() {
      return new NotSupportedException("Collection is read-only!");
    }

    #endregion Methods

    #region ICollection<TItem> Members

    void ICollection<TItem>.Add(TItem item) {
      throw CreateReadOnlyException();
    }

    void ICollection<TItem>.Clear() {
      throw CreateReadOnlyException();
    }

    public bool Contains(TItem item) {
      return Items.Contains(item);
    }

    public void CopyTo(TItem[] array, int arrayIndex) {
      Items.CopyTo(array, arrayIndex);
    }

    public int Count {
      [DebuggerStepThrough]
      get { return Items.Count; }
    }

    bool ICollection<TItem>.IsReadOnly {
      [DebuggerStepThrough]
      get { return true; }
    }

    bool ICollection<TItem>.Remove(TItem item) {
      throw CreateReadOnlyException();
    }

    #endregion ICollection<TItem> Members

    #region IEnumerable<TItem> Members

    public IEnumerator<TItem> GetEnumerator() {
      return Items.GetEnumerator();
    }

    #endregion IEnumerable<TItem> Members

    #region IEnumerable Members

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

    #endregion IEnumerable Members
  }

_FR>В принциме, ИМХО, самым правильным и непротиворечивым было бы написать ReadOnlyHashSet<> — тогда и с именем не надо мучаться

  #region Using's

  using System;
  using System.Collections;
  using System.Collections.Generic;
  using System.Diagnostics;

  #endregion Using's

  [Serializable]
  [DebuggerDisplay("Count = {Count}")]
  public class ReadOnlyHashSet<TItem> : ReadOnlyCollection2<TItem>
  {
    #region Constructor(s)

    public ReadOnlyHashSet(HashSet<TItem> items) : base(items) {
    }

    #endregion Constructor(s)

    #region Properties

    protected new HashSet<TItem> Items {
      [DebuggerStepThrough]
      get { return (HashSet<TItem>)base.Items; }
    }

    public IEqualityComparer<TItem> Comparer {
      [DebuggerStepThrough]
      get { return Items.Comparer; }
    }

    #endregion Properties

    #region Methods

    public void CopyTo(TItem[] array) {
      Items.CopyTo(array);
    }

    public void CopyTo(TItem[] array, int arrayIndex, int count) {
      Items.CopyTo(array, arrayIndex, count);
    }

    public bool IsProperSubsetOf(IEnumerable<T> other) {
      return Items.IsProperSubsetOf(other);
    }

    public bool IsProperSupersetOf(IEnumerable<T> other) {
      return Items.IsProperSubsetOf(other);
    }

    public bool IsSubsetOf(IEnumerable<T> other) {
      return Items.IsSubsetOf(other);
    }

    public bool IsSupersetOf(IEnumerable<T> other) {
      return Items.IsSupersetOf(other);
    }

    public bool Overlaps(IEnumerable<T> other) {
      return Items.Overlaps(other);
    }

    public bool SetEquals(IEnumerable<T> other) {
      return Items.SetEquals(other);
    }

    public new HashSet<TItem>.Enumerator GetEnumerator() {
      return Items.GetEnumerator();
    }

    #endregion Methods
  }

_FR>    void ICollection<TItem>.Add(TItem item) {
_FR>      throw CreateReadOnlyException();
_FR>    }

_FR>    void ICollection<TItem>.Clear() {
_FR>      throw CreateReadOnlyException();
_FR>    }

An enumerator remains valid as long as the collection remains unchanged. If changes are made to the collection, such as adding, modifying, or deleting elements, the enumerator is irrecoverably invalidated and the next call to MoveNext or Reset throws an InvalidOperationException. If the collection is modified between MoveNext and Current, Current returns the element that it is set to, even if the enumerator is already invalidated.

    /// <summary>
    /// A readonly version of BindingList(Of T)
    /// </summary>
    /// <typeparam name="T">Type of item contained in the list.</typeparam>
    /// <remarks>
    /// This is a subclass of BindingList(Of T) that implements
    /// a readonly list, preventing changing, adding and removing of items
    /// from the list.
    /// </remarks>
    public class ReadOnlyBindingList<T> : BindingList<T>
    {
        private const string MSG_NOT_ALLOWED_IN_READONLY_COLLECTION = "Not allowed in read-only collection";

        /// <summary>
        /// Creates an instance of the object.
        /// </summary>
        public ReadOnlyBindingList(BindingList<T> list) : base(list)
        {
            this.RaiseListChangedEvents = false;
            base.AllowEdit = false;
            base.AllowRemove = false;
            base.AllowNew = false;
            this.RaiseListChangedEvents = true;

            list.ListChanged += new ListChangedEventHandler(ReadOnlyBindingList_ListChanged);
        }

        private void ReadOnlyBindingList_ListChanged(object sender, ListChangedEventArgs e)
        {
            OnListChanged(e);
        }

        /// <summary>
        /// Prevents clearing the collection.
        /// </summary>
        protected override void ClearItems()
        {
            throw new InvalidOperationException(MSG_NOT_ALLOWED_IN_READONLY_COLLECTION);
        }

        /// <summary>
        /// Prevents insertion of items into the collection.
        /// </summary>
        protected override object AddNewCore()
        {
            throw new InvalidOperationException(MSG_NOT_ALLOWED_IN_READONLY_COLLECTION);
        }

        /// <summary>
        /// Prevents insertion of items into the collection.
        /// </summary>
        /// <param name="index">Index at which to insert the item.</param>
        /// <param name="item">Item to insert.</param>
        protected override void InsertItem(int index, T item)
        {
            throw new InvalidOperationException(MSG_NOT_ALLOWED_IN_READONLY_COLLECTION);
        }

        /// <summary>
        /// Prevents removing of items into the collection
        /// </summary>
        /// <param name="index">Index of the item to remove.</param>
        protected override void RemoveItem(int index)
        {
            throw new InvalidOperationException(MSG_NOT_ALLOWED_IN_READONLY_COLLECTION);
        }

        /// <summary>
        /// Prevents replacing the item at the specified index with the 
        /// specified item
        /// </summary>
        /// <param name="index">Index of the item to replace.</param>
        /// <param name="item">New item for the list.</param>
        protected override void SetItem(int index, T item)
        {
            throw new InvalidOperationException(MSG_NOT_ALLOWED_IN_READONLY_COLLECTION);
        }

        /// <summary>
        /// Gets a value indicating whether items in the list can be edited.
        /// </summary>
        public new bool AllowEdit { get { return false; } }

        /// <summary>
        /// Gets a value indicating whether you can add items to the list using the AddNew method.
        /// </summary>
        public new bool AllowNew { get { return false; } }

        /// <summary>
        /// Gets a value indicating whether you can remove items from the collection. 
        /// </summary>
        public new bool AllowRemove { get { return false; } }
    }

if (collection.IsReadOnly)
{
  //get back in time and find another way to solve task
}

_FR>В ссылке, что я дал, есть объяснение, почему сделано именно так Если ты такой умный, то доказывай свою позицию авторам фреймворка (это можно сделать прям в коментарии к блогу).