What is the difference between the non-generic IEnumerable and the generic IEnumerable<T>?

Sorry for such a vague question, but I have been searching around for the best part of a day, I have read article after article (and many questions here) but just cannot find an e开发者_运维百科asy to understand answer.

I (think I) know what IEnumerable is for, but I just can't understand what it means when it is defined with a generic type argument, for example:

IEnumerable<int> test = method();

This is just driving me mad! Please put me out of misery and explain what it means?

An IEnumerable is basically a collection of objects. It has the method GetEnumerator() which allows you to iterate through all of the objects in the enumerable.

An IEnumerable<int> is basically a collection of integers. It has the method GetEnumerator() which allows you to iterate through all of the integers in the enumerable.

IEnumerable<int> test = method(); means that method() is getting a collection if integers from somewhere. It could be a List, an array or some other data type, but it is definitely a group of them and they are all integers, and you have the ability to iterate through them.

This post may be helpful as well: What's the difference between IEnumerable and Array, IList and List?

I just think of IEnumerable<int> the same way as I'd think of a List<int>, which comes a little bit more naturally I suppose. With the caveat that an IEnumerable<int> doesn't do quite as much as a List<int>, and that essentially it's just a thing of ints that can be enumerated

The word you're looking for is "generics", and the example you give is IEnumerable being used as a generic for items of type int. What that means is that the IEnumerable collection you are using is strongly-typed to only hold int objects as opposed to any other type.

Google "C# generics IEnumerable" and you will find all of the information you want on this.

An IEnumerable has a GetEnumerator method which will return an IEnumerator, whose Current method will return an Object. An IEnumerable<T> has a GetEnumerator method which will return an IEnumerator<T>, whose Current method will return a T. If you know in advance the expected type of the object to be returned by the enumerator, it's generally better to use the generic form.

Another distinction is that IEnumerator<T> inherits IDisposable, which allows code which is done with an enumerator to call Dispose on it without having to worry about whether it is supported. By comparison, when using a non-generic IEnumerator, it's necessary to test whether it is IDisposable and call Dispose on it if so. Note that use of the non-generic form of IEnumerable/IEnumerator does not relieve one of the requirement to call Dispose. As an example, casting the vb-style Collection to IEnumerable and then calling GetEnumerator 100,000 times without calling Dispose will be extremely slow (many seconds, even on an i7) unless a garbage-collection happens to occur. Disposing the IEnumerator after each call will speed things up more than a hundredfold.

IEnumerable means it can be used in a foreach loop.

items can be used in the form of

foreach(var item in items)
{
   Console.WriteLine(item);
}