I don’t believe there’s anything in the framework, but you could easily write one: IEnumerator<T> Cast<T>(IEnumerator iterator) { while (iterator.MoveNext()) { yield return (T) iterator.Current; } } It’s tempting to just call Enumerable.Cast<T> from LINQ and then call GetEnumerator() on the result – but if your class already implements IEnumerable<T> and T is a value … Read more
Yes, it is. You can find out a lot more about it in chapter 6 of my book, C# in Depth. Fortunately chapter 6 is available for free from Manning’s web site. I also have two other articles on the book’s web site. Feedback welcome.
never; ultimately this was a mistake. The correct way to iterate a sequence more than once is to call .GetEnumerator() again – i.e. use foreach again. If your data is non-repeatable (or expensive to repeat), buffer it via .ToList() or similar. It is a formal requirement in the language spec that iterator blocks throw exceptions … Read more
Arrays do implement IEnumerable<T>, but it is done as part of the special knowledge the CLI has for arrays. This works as if it were an explicit implementation (but isn’t: it is done at runtime). Many tools will not show this implementation, this is described in the Remarks section of the Array class overview. You … Read more
Indeed, it is for performance reasons. The BCL team did a lot of research on this point before deciding to go with what you rightly call out as a suspicious and dangerous practice: the use of a mutable value type. You ask why this doesn’t cause boxing. It’s because the C# compiler does not generate … Read more
This is simple in C# 2: public IEnumerator GetEnumerator() { yield break; } You need the yield break statement to force the compiler to treat it as an iterator block. This will be less efficient than a “custom” empty iterator, but it’s simpler code…
Basically it was an oversight. In C# 1.0, foreach never called Dispose 1. With C# 1.2 (introduced in VS2003 – there’s no 1.1, bizarrely) foreach began to check in the finally block whether or not the iterator implemented IDisposable – they had to do it that way, because retrospectively making IEnumerator extend IDisposable would have … Read more
Here is the documentation on IEnumerator. They are used to get the values of lists, where the length is not necessarily known ahead of time (even though it could be). The word comes from enumerate, which means “to count off or name one by one”. IEnumerator and IEnumerator<T> is provided by all IEnumerable and IEnumerable<T> … Read more
Works on 2.0+: ((IEnumerable<MyType>)myArray).GetEnumerator() Works on 3.5+ (fancy LINQy, a bit less efficient): myArray.Cast<MyType>().GetEnumerator() // returns IEnumerator<MyType>
IEnumerable is an interface that defines one method GetEnumerator which returns an IEnumerator interface, this in turn allows readonly access to a collection. A collection that implements IEnumerable can be used with a foreach statement. Definition IEnumerable public IEnumerator GetEnumerator(); IEnumerator public object Current; public void Reset(); public bool MoveNext(); example code from codebetter.com