source: branches/AlphaChannel/AI Template/Project/Lib/ToughSet.cs

using System;
using System.Collections.Generic;

// collection class with the following operations:
// * add object
// * iterate collection using foreach statement
// * remove current object from within iteration

// when removing objects while iterating, the following conditions are assured:
// * no elements that are still in the collection are left out
// * no elements that are no longer in the collection are iterated
// * no element is iterated twice
// * in case of nested iterations of the collection, all this is true for each of them

// calling GetEnumerator explicitely is not recommended
// never iterate from multiple threads at the same time

namespace Common
{
        /// <summary>
        /// Simple collection class which can be changed from within iteration.
        /// </summary>
        /// <typeparam name="T">type of collected objects</typeparam>
        class ToughSet<T> : IEnumerable<T>
        {
                List<T> list = new List<T>();
                List<Enumerator<T>> enumerators = new List<Enumerator<T>>(4); // list will rarely have more than 1 element

                /// <summary>
                /// Creates an empty collection.
                /// </summary>
                public ToughSet() { }

                /// <summary>
                /// Number of elements contained in the collection.
                /// </summary>
                public int Count { get { return list.Count; } }

                /// <summary>
                /// Adds an object to the collection.
                /// </summary>
                /// <param name="item">The object to be added.</param>
                public void Add(T item) { list.Add(item); }

                /// <summary>
                /// Removes the current object of an iteration from the collection. Can only be called from within foreach loop.
                /// </summary>
                public void RemoveCurrent()
                {
                        if (enumerators.Count == 0)
                                throw new Exception("ToughSet.Remove() can only be called from within foreach loop!");
                        Enumerator<T> innerEnumerator = enumerators[enumerators.Count - 1];
                        if (!innerEnumerator.currentWasRemoved)
                        {
                                int removeIndex = innerEnumerator.index;
                                if (removeIndex >= 0 && removeIndex < list.Count)
                                {
                                        list.RemoveAt(removeIndex);
                                        foreach (Enumerator<T> enumerator in enumerators)
                                                enumerator.RemoveAt(removeIndex);
                                }
                        }
                }

                void EnumerationEnded(Enumerator<T> enumerator) // parameter is only for proof of correctness
                {
                        if (enumerators.Count == 0)
                                throw new Exception("Error in ToughSet: Only started foreach loop can end!");
                        Enumerator<T> innerEnumerator = enumerators[enumerators.Count - 1];
                        if (enumerator != innerEnumerator)
                                throw new Exception("Error in ToughSet: Only most inner foreach loop can end!");
                        enumerator.DisposeEvent -= EnumerationEnded;
                        enumerators.RemoveAt(enumerators.Count - 1);
                }

                #region IEnumerable members
                class Enumerator<TEn> : IEnumerator<TEn>
                {
                        ToughSet<TEn> parent;
                        public int index;
                        public bool currentWasRemoved = false;
                        TEn current;

                        public Enumerator(ToughSet<TEn> parent)
                        {
                                this.parent = parent;
                                index = -1;
                        }

                        public void RemoveAt(int removeIndex)
                        {
                                if (removeIndex == index)
                                        currentWasRemoved = true;
                                if (removeIndex <= index)
                                        index--;
                        }

                        public delegate void DisposeEventHandler(Enumerator<TEn> enumerator);
                        public event DisposeEventHandler DisposeEvent;

                        #region IEnumerator Members
                        public void Reset() { index = -1; }
                        public TEn Current { get { return current; } }
                        object System.Collections.IEnumerator.Current { get { return current; } }
                        public void Dispose() { DisposeEvent(this); }

                        public bool MoveNext()
                        {
                                index++;
                                if (index < parent.list.Count)
                                {
                                        current = parent.list[index];
                                        currentWasRemoved = false;
                                        return true;
                                }
                                else
                                        return false;
                        }
                        #endregion
                }

                public IEnumerator<T> GetEnumerator()
                {
                        Enumerator<T> enumerator = new Enumerator<T>(this);
                        enumerators.Add(enumerator);
                        enumerator.DisposeEvent += EnumerationEnded;
                        return enumerator;
                }
                System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
                #endregion
        }
}

/*
class was tested with the following code:

ToughSet<int> ts = new ToughSet<int>();
for (int i = 0; i < 20; i++)
        ts.Add(i);

foreach (int i in ts)
{ // should iterate 0-1-2-3-5-6-7-8-9-11-13-14-15-16-17
        if (i == 3)
        {
                foreach (int j in ts)
                {
                        if (j == 1 || j == 4 || j ==12)
                                ts.Remove();
                        if (j == 14)
                                break;
                }
        }
        if (i == 9)
        {
                foreach (int j in ts)
                {
                        if (j == 0 || j == 9 || j == 10)
                                ts.Remove();
                        if (j == 16)
                                break;
                }
        }
        if (i == 8 || i == 9 || i == 16)
                ts.Remove();
        if (i == 17)
                break;
}
foreach (int i in ts)
{ // should iterate 2-3-5-6-7-11-13-14-15-17-18-19
}
ts.Remove(); // should throw exception
*/