10

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 easy 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?

idiot
  • 103
  • 1
  • 7

5 Answers5

13

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?

Community
  • 1
  • 1
smartcaveman
  • 41,281
  • 29
  • 127
  • 212
  • Ok, I think I understand now, I didn't realise it could be a collection and I just didn't understand how it worked. Is there a good resource you can show that shows the benefits/pitfalls comparing IEnumerable/list/arrays as I really want to learn more. +1 (when I can!) – idiot Apr 03 '11 at 10:53
  • Lists and arrays both implement `IEnumerable`. All the generic collections in `System.Collections.Generic` implement `IEnumerable`. You may be interested in this post: http://stackoverflow.com/questions/764748/whats-the-difference-between-ienumerable-and-array-ilist-and-list – smartcaveman Apr 03 '11 at 11:00
  • Thanks... and marking as answer... You may want to edit/put that link in your main answer as well because that really has made me completely understand now. – idiot Apr 03 '11 at 11:11
2

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

kenwarner
  • 28,650
  • 28
  • 130
  • 173
  • 4
    I don't really like this analogy. A list assumes that the all the items are in one place. Where as an `IEnumerable` just says that you can get all of the items in some sequence. It's like the difference between a phone book and the internet. I can get all the numbers for plumbers in Chicago from either place, but in the Phone Book, they are already in a list - whereas in an `IEnumerable` or on the internet, they can be whatever, I just need to know how to find them - I didn't downvote you though, I just think your answer could use a little more clarity. – smartcaveman Apr 03 '11 at 03:28
  • user689466 is looking for a way to understand IEnumerable. Clearly there are differences - it's just a starting point with an easily understandable concept and once he groks that he can move on to understanding the subtleties between the two – kenwarner Apr 05 '11 at 23:17
2

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.

KP Taylor
  • 2,100
  • 1
  • 17
  • 15
2

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.

Micha Wiedenmann
  • 19,979
  • 21
  • 92
  • 137
supercat
  • 77,689
  • 9
  • 166
  • 211
-1

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);
}
David Bond
  • 149
  • 1
  • 9
mikek3332002
  • 3,546
  • 4
  • 37
  • 47