Buffered I(Async)Enumerable

[TonyValenti]

Are there any wrapper classes that allow to to concurrently enumerate over an enumerable from multiple threads but In such a way that the enumerable is only ever enumerated once?

[stephentoub]

Parallel.ForEach{Async}?

Otherwise, the I{Async}Enumerator<T> interfaces are inherently not thread-safe and can't be made thread-safe without higher-level orchestration like a lock, as two separate operations (MoveNext{Async}/Current) need to be invoked individually to get the next item. If that's all you're looking for and you want to hand out an instance that will be consumed by only a single thread/consumer but that coordinates access to another instance that's shared, you can do something like:

static IEnumerable<int> LockAndEnumerate<T>(object syncObj, IEnumerator<T> e)
{
    while (true)
    {
        T current;
        lock (syncObj)
        {
            if (!e.MoveNext()) break;
            current = e.Current;
        }
        yield return current;
    }
}

[TonyValenti]

Thanks @stephentoub . I don't think that Parallel.ForEach is what I'm looking for. I essentially want an async/lazy enumable. Something I can use like this like this.:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

var Buffered = FibString().Buffer();

var Values1 = Buffered.Take(3).ToList();
var Values2 = Buffered.Take(10).ToList();
var Values3 = Buffered.Take(5).ToList();

//Do an object.ReferenceEquals on each item to ensure they return the exact same instance of the string.
Assert.SequenceReferenceEquals(Values1, Values2.Take(3));
Assert.SequenceReferenceEquals(Values2.Take(5), Values3);



IEnumerable<string> FibString() {

    yield return "0";
    yield return "1";

    var x = 0L;
    var y = 1L;

    while (true) {
        var next = x + y;
        x = y;
        y = next;

        yield return $@"{next}";
    }

}

[TonyValenti]

Oh, and for clarity, in the example above:

1. The FibString enumerable should only ever be instantiated once (by .Buffer())
2. Any items it returns get cached
3. Any requests to enumerate it again, will immediately return the cached values first and then pick up enumerating and caching from whereever it had advanced the furthest.