using System.Collections;
using System.Collections.Generic;
 
namespace RandomEnumerable
{
    public class Series : IEnumerable<int>
    {
        private readonly int begin, end;
 
        public Series(int end)
            : this(0, end)
        {
        }
 
        public Series(int begin, int end)
        {
            this.begin = begin;
            this.end = end;
        }
 
        #region IEnumerable<int> Members
 
        public IEnumerator<int> GetEnumerator()
        {
            return new Enumerator(begin, end);
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return new Enumerator(begin, end);
        }
 
        #endregion
 
        #region Nested type: Enumerator
 
        private class Enumerator : IEnumerator<int>
        {
            private readonly int begin, end;
            private bool counting = false;
            private int current;
 
            public Enumerator(int begin, int end)
            {
                this.begin = begin;
                this.end = end;
            }
 
            #region IEnumerator<int> Members
 
            public int Current
            {
                get { return current; }
            }
 
            public void Dispose()
            {
            }
 
            object IEnumerator.Current
            {
                get { return Current; }
            }
 
            public bool MoveNext()
            {
                if (!counting)
                {
                    current = begin;
                    counting = true;
                }
                else
                {
                    counting = ++current < end;
                }
                return counting;
            }
 
            public void Reset()
            {
                counting = false;
            }
 
            #endregion
        }
 
        #endregion
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
 
namespace RandomEnumerable
{
    public class RandomEnumerable<T> : IEnumerable<T>
    {
        private readonly IEnumerable<T> enumerable;
        private readonly Random random;
 
        public RandomEnumerable(Random random, IEnumerable<T> enumerable)
        {
            this.random = random;
            this.enumerable = enumerable;
        }
 
        #region IEnumerable<T> Members
 
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return new Enumerator<T>(random, enumerable);
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return new Enumerator<T>(random, enumerable);
        }
 
        #endregion
 
        #region Nested type: Enumerator
 
        private class Enumerator<T> : IEnumerator<T>
        {
            private readonly IEnumerable<T> enumerable;
            private readonly Random random;
            private int current;
            private List<T> list;
 
            public Enumerator(Random random, IEnumerable<T> enumerable)
            {
                this.random = random;
                this.enumerable = enumerable;
            }
 
            #region IEnumerator<T> Members
 
            T IEnumerator<T>.Current
            {
                get { return list[current]; }
            }
 
            void IDisposable.Dispose()
            {
            }
 
            object IEnumerator.Current
            {
                get { return list[current]; }
            }
 
            bool IEnumerator.MoveNext()
            {
                if (list == null)
                {
                    list = new List<T>();
                    list.AddRange(enumerable);
                }
                else
                {
                    list.RemoveAt(current);
                }
                current = random.Next(0, list.Count);
                return list.Count > 0;
            }
 
            void IEnumerator.Reset()
            {
                list = null;
            }
 
            #endregion
        }
 
        #endregion
    }
}