What is the difference between Ienumerable<T> and Ienumerable?

Question

I tried to see the code of both interfaces, but the only difference I see is the IEnumerable<T> has the method IEnumerator<T> GetEnumerator();, and that at the interface IEnumerator<T> the Current returns the "T" instead of an Object... Would that be just to prevent the foreach from making a Unboxing after? or not? And another question, usually you do another class even to implement the interface IEnumerator and implements all methods Movenext, Reset, Current, etc... or just implement the IEnumerable<T> and return a Getenumerator() from the List is enough? Example:

public IEnumerator<Error> GetEnumerator()
{
    return this._errors.GetEnumerator();
}

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

GetEnumerator() is an array class method that returns to us a class that implements the IEnumerator<T> even?

Answer 1

What’s the difference between IEnumerable<T> and IEnumerable?

In theory there should be no such distinction. The problem is that in . NET 1.0 was implemented first IEnumerable. Generic types only came from . NET 2.0.

Without delay, IEnumerable basically returns type iterators Object, and IEnumerable<T> returns typed iterators.

...on the interface IEnumerator<T> the Current returns the "T" instead of the one object... That would be just to prevent the foreach from making one Unboxing after? or not?

No, actually the distinction is purely and simply for type security. Conversions that could arise midway could cause problems if the programmer tried conversions using different types.

And another question, usually you do another class even to implement the interface IEnumerator and implements all methods MoveNext, Reset, Current, etc... or just implement the IEnumerable<T> and return a GetEnumerator() of the List?

If you just implement both GetEnumerator() already works. The method implementation the method is required if you want a behavior different from the known implementation standard.