Simple wrapper to use IEnumerable as a producer in a producer-consumer pattern
I think the implementation is too leaky - it should not expose how the blocking internals are achieved since if if decide do change this you might have to change a whole lot of application code which violates the open-closed-principle (the O part of SOLID). This can be easily fixed by making the class IEnumerable&lt;T&gt; and using GetConsumingEnumerable of the BlockingCollection.
I think the more idiomatic way to start a new task is to use Task.Factory.StartNew.
I would rename it into BlockingEnumerable since that what it is.
Since you're talking about long running operations you may want to add a method of canceling the task.
It might be useful to add a capacity for the intermediate blocking collection as well to provide better control of how much data is cached.


Slightly refactored code:

class BlockingEnumerable&lt;T&gt; : IEnumerable&lt;T&gt;
{
    private readonly BlockingCollection&lt;T&gt; _ProducerCollection;

    public BlockingEnumerable(IEnumerable&lt;T&gt; source)
    {
        _ProducerCollection = new BlockingCollection&lt;T&gt;();
        AddItemsToBlockingCollection(source);
    }

    public IEnumerator&lt;T&gt; GetEnumerator()
    {
        return _ProducerCollection.GetConsumingEnumerable().GetEnumerator();
    }

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

    private void AddItemsToBlockingCollection(IEnumerable&lt;T&gt; source)
    {
        Task.Factory.StartNew(() =&gt;
        {
            foreach (var item in source)
            {
                _ProducerCollection.Add(item);
            }
            _ProducerCollection.CompleteAdding();
        });
    }
}