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
  }