IEnumerable的替代实现GetEnumerator（） <T> 包装纸

Question

I was implementing a wrapper class for an IEnumerable<T> the same way I usually do and I noticed that ReSharper suggested that I convert the foreach loop in my GetEnumerator method to a LINQ-expression.

Out of curiosity, I clicked "Convert into LINQ-expression" which then changed my method from:

public IEnumerator<T> GetEnumerator()
{
    foreach (var item in _someList)
    {
        yield return item;
    }
}

into ReSharper's "LINQ-expression" result:

public IEnumerator<T> GetEnumerator()
{
    return ((IEnumerable<T>) _someList).GetEnumerator();
}

The code is pretty straight forward: rather than looping through _someList there, it is casting _someList as an IEnumerable<T> and then using whatever existing GetEnumerator() method their is to return the same result.

I haven't seen this implementation before, and I'm wondering if there are any dangers to using it in situations where you really don't have anything custom to put in the Enumerator. I'm also wondering if there are any benefits to using one implementation over the other.

Answer 1

If your non-generic GetEnumerator already works perfectly (except for being non-generic), then there is no reason not to use it. In this case, you would want to simply cast to IEnumerable<T> .

If it does not, then you will need to roll your own with the yield statements, as you already know how to.