public class Set<T> : ICollection<T>
    {
        Dictionary<T, bool> _dictionary;
        List<T> _list = new List<T>();

        #region Construct

        public Set()
        {
            _dictionary = new Dictionary<T, bool>();
        }

        public Set(IEqualityComparer<T> comparer)
        {
            _dictionary = new Dictionary<T, bool>(comparer);
        }

        public Set(params T[] items)
            : this()
        {
            AddRange(items);
        }

        public Set(IEqualityComparer<T> comparer, params T[] items)
            : this(comparer)
        {
            AddRange(items);
        }

        public Set(IEnumerable<T> items)
            : this()
        {
            AddRange(items);
        }

        public Set(IEqualityComparer<T> comparer, IEnumerable<T> items)
            : this(comparer)
        {
            AddRange(items);
        }

        #endregion
        
        #region ICollection<T> Members

        public void Add(T item)
        {
            _dictionary.Add(item, false);
            _list.Add(item);
        }

        public void Clear()
        {
            _dictionary.Clear();
            _list.Clear();
        }

        public bool Contains(T item)
        {
            return _dictionary.ContainsKey(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            _list.CopyTo(array, arrayIndex);
        }

        public int Count
        {
            get { return _list.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(T item)
        {
            bool result = _dictionary.Remove(item);
            if (result)
            {
                int ind = _list.FindIndex(v => _dictionary.Comparer.Equals(item, v));
                _list.RemoveAt(ind);
            }
            return result;
        }

        #endregion

        #region IEnumerable<T> Members

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

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

        #endregion      
  
        #region Mix

        public void AddRange(params T[] items)
        {
            AddRange((IEnumerable<T>)items);
        }

        public void AddRange(IEnumerable<T> items)
        {
            foreach (T item in items)
                Add(item);
        }

        public void AddIfNotContains(T item)
        {
            if (Contains(item) == false)
                Add(item);
        }

        public T[] ToArray()
        {
            T[] result = new T[Count];
            CopyTo(result, 0);
            return result;
        }

        #endregion
    }