Pastable version of Cached IEnumerable<T>

<pre class='prettyprint' language='cs'>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    /// &lt;summary&gt;
    /// Wraps an IEnumerable&amp;lt;T&amp;gt; and provides a thread-safe means of caching the values.&quot;/&gt;
    /// &lt;/summary&gt;
    /// &lt;typeparam name=&quot;T&quot;&gt;&lt;/typeparam&gt;
    class ThreadSafeCachedEnumerable&lt;T&gt; : IEnumerable&lt;T&gt;
    {
        // An enumerator from the original IEnumerable&lt;T&gt;
        private IEnumerator&lt;T&gt; enumerator;

// The items we have already cached (from this.enumerator)
        private IList&lt;T&gt; cachedItems = new List&lt;T&gt;();

public ThreadSafeCachedEnumerable(IEnumerable&lt;T&gt; enumerable)
        {
            this.enumerator = enumerable.GetEnumerator();
        }

#region IEnumerable&lt;T&gt; Members

public IEnumerator&lt;T&gt; GetEnumerator()
        {
            // The index into the sequence
            int currentIndex = 0;

// We will break with yield break 
            while (true)
            {
                // The currentIndex will never be decremented,
                // so we can check without locking first
                if (currentIndex &lt; this.cachedItems.Count)
                {
                    var current = this.cachedItems[currentIndex];
                    currentIndex += 1;
                    yield return current;
                }
                else
                {
                    // If !(currentIndex &lt; this.cachedItems.Count),
                    // we need to synchronize access to this.enumerator
                    lock (enumerator)
                    {
                        // See if we have more cached items ...
                        if (currentIndex &lt; this.cachedItems.Count)
                        {
                            var current = this.cachedItems[currentIndex];
                            currentIndex += 1;
                            yield return current;
                        }
                        else
                        {
                            // ... otherwise, we'll need to get the next item from this.enumerator.MoveNext()
                            if (this.enumerator.MoveNext())
                            {
                                // capture the current item and cache it, then increment the currentIndex
                                var current = this.enumerator.Current;
                                this.cachedItems.Add(current);
                                currentIndex += 1;
                                yield return current;
                            }
                            else
                            {
                                // We reached the end of the enumerator - we're done
                                yield break;
                            }
                        }
                    }
                }
            }
        }

#endregion

#region IEnumerable Members

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

#endregion
    }
}</pre>
<a href="http://www.refactormycode.com/codes/945-cached-ienumerable-t" style="color:#fff" title="As seen on RefactorMyCode.com"><img alt="Small_logo" src="http://www.refactormycode.com/images/small_logo.gif" style="border:0" /></a>

Refactor :my => 'code'

Recent

Popular

Pastable version of Cached IEnumerable<T>