Create AsyncCursor wrapper Is this good OOP style? Do I need to split this class into two classes? If so, how do I do this? What methods should I need to add to the interfaces?

public sealed class DeferredResultCollection&lt;TResult&gt; : IEnumerable&lt;TResult&gt;, IDisposable
{
    private readonly IAsyncCursor&lt;TResult&gt; _asyncCursor;
    private readonly IList&lt;TResult&gt; _list;

    public DeferredResultCollection(IAsyncCursor&lt;TResult&gt; asyncCursor)
    {
        _asyncCursor = asyncCursor;
    }

    public DeferredResultCollection(IList&lt;TResult&gt; list)
    {
        _list = list;
    }

    public IEnumerator&lt;TResult&gt; GetEnumerator()
    {
        if (_list != null)
        {
            foreach (var item in _list)
            {
                yield return item;
            }
        }

        if (_asyncCursor != null)
        {
            for (; _asyncCursor.MoveNextAsync().Result;)
            {
                foreach (var result in _asyncCursor.Current)
                {
                    yield return result;
                }
            }
        }
    }

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

    public void Dispose()
    {
        if (_asyncCursor != null)
        {
            _asyncCursor.Dispose();
        }
    }
}
Is it good OOP style? 


No. The class contains a IAsyncCursor&lt;TResult&gt; field and a IList&lt;TResult&gt; field,
but depending on how it's constructed,
only one of these will be actually used.
This is a pretty clear indication that we have two classes masquerading as one.


  Maybe I need to split this class into two classes? 


You hit the nail on the head!


  How to do this? What methods should I need to take out to the interfaces?


The interface should contain GetEnumerator and that's it.
That's the common functionality.
Let's call the interface DeferredResultCollection&lt;TResult&gt;.

Next, add two classes that implement this interface,
one using a IAsyncCursor&lt;TResult&gt; and the other a IList&lt;TResult&gt;,
let's call these CursorBasedDeferredResultCollection&lt;TResult&gt; and ListBasedDeferredResultCollection&lt;TResult&gt;.

Optionally, you could add a factory,
let's call it DeferredResultCollections,
with two methods, such that both return objects of the interface type DeferredResultCollection&lt;TResult&gt;,
but one of them takes a IAsyncCursor&lt;TResult&gt; and the other a IList&lt;TResult&gt; as parameter,
and create and return objects with the appropriate implementations.
This has the benefit that users don't need to learn the names of the implementation classes.
In fact they don't even need to know them at all (they can be private).