What is the precise implementation of Enumerable.Range in .Net; preferable .Net 4? Is it a yielded for-loop? A custom implementation (IEnumerable, IEnumerator) or?
+1
A:
You can use Reflector to see the implementation for yourself. It checks arguments and throws exception at the time of calling, so the Range method itself is not an iterator method. It calls another method which is an iterator method. It's not OK to post the exact code due to license restrictions.
Mehrdad Afshari
2009-10-05 13:45:35
+1
A:
The accepted answer on this question should give you the answer:
public static class Enumerable {
public static IEnumerable<int> Range(int start, int count) {
var end = start + count;
for(var current = start; current < end; ++current) {
yield return current;
}
}
}
This isn't the exact code, as there is a lot of error checking etc. going on within the Range method, and internally, it calls other methods, however, the quoted code above is the "essence" of the Range routine.
Examining the code in Reflector should provide you with far more information.
CraigTP
2009-10-05 13:57:44
I didn't want the essence, I wanted the precise answer - but I appreciate that this is not possible due to license restrictions. Thanks for the input, I've now used reflector and found the answer.
Bent Rasmussen
2009-10-05 15:08:17
It's more like: `if (!valid) throw exception; else return RangeInternal(...);` in which `RangeInternal` is an iterator. This is an important distinction, since if you call `Range` with invalid arguments, you'll get the exception immediately. If the `Range` method used `yield` directly, you didn't get an exception until you `foreach`ed the collection.
Mehrdad Afshari
2009-10-05 19:02:25
@Mehrdad - That's a very good point that the exception is (potentially) thrown immediately rather than deferred, like the iteration itself. It's what I was alluding to when I mentioned about error checking, but you have described it more clearly.
CraigTP
2009-10-05 19:17:58
A:
A slight but significant difference in the Reflector output (as well as the argument check and extra level of internalisation mentioned in CraigTP's answer and its comments):
public static IEnumerable<int> Range(int start, int count) {
for(int current = 0; current < count; ++current) {
yield return start + current;
}
}
That is, instead of another local variable, they apply an extra addition for every yield.
Mark Hurd
2010-05-28 14:59:15