What is the difference between the non-generic IEnumerable and the generic IEnumerable?

后端 未结 5 1813
不思量自难忘°
不思量自难忘° 2020-12-31 15:34

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 fin

相关标签:
5条回答
  • 2020-12-31 16:11

    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.

    0 讨论(0)
  • 2020-12-31 16:12

    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

    0 讨论(0)
  • 2020-12-31 16:13

    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);
    }
    
    0 讨论(0)
  • 2020-12-31 16:15

    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.

    0 讨论(0)
  • 2020-12-31 16:30

    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?

    0 讨论(0)
自定义标题
段落格式
字体
字号
代码语言
提交回复
热议问题