Thoughts on foreach with Enumerable.Range vs traditional for loop

In C# 3.0, I'm liking this style:

// Write the numbers 1 thru 7
foreach (int index in Enumerable.Range( 1, 7 ))
{
	Console.WriteLine(index);
}

over the traditional for loop:

// Write the numbers 1 thru 7
for (int index = 1; index <= 7; index++)
{
	Console.WriteLine( index );
}

Assuming 'n' is small so performance is not an issue, does anyone object to the new style over the traditional style?

I find the latter's "minimum-to-maximum" format a lot clearer than Range's "minimum-count" style for this purpose. Also, I don't think it's really a good practice to make a change like this from the norm that is not faster, not shorter, not more familiar, and not obviously clearer.

That said, I'm not against the idea in general. If you came up to me with syntax that looked something like foreach (int x from 1 to 8) then I'd probably agree that that would be an improvement over a for loop. However, Enumerable.Range is pretty clunky.

This is just for fun. (I'd just use the standard "for (int i = 1; i <= 10; i++)" loop format myself.)

foreach (int i in 1.To(10))
{
    Console.WriteLine(i);    // 1,2,3,4,5,6,7,8,9,10
}

// ...

public static IEnumerable<int> To(this int from, int to)
{
    if (from < to)
    {
        while (from <= to)
        {
            yield return from++;
        }
    }
    else
    {
        while (from >= to)
        {
            yield return from--;
        }
    }
}

You could also add a Step extension method too:

foreach (int i in 5.To(-9).Step(2))
{
    Console.WriteLine(i);    // 5,3,1,-1,-3,-5,-7,-9
}

// ...

public static IEnumerable<T> Step<T>(this IEnumerable<T> source, int step)
{
    if (step == 0)
    {
        throw new ArgumentOutOfRangeException("step", "Param cannot be zero.");
    }

    return source.Where((x, i) => (i % step) == 0);
}

In C# 6.0 with the use of

using static System.Linq.Enumerable;

you can simplify it to

foreach (var index in Range(1, 7))
{
    Console.WriteLine(index);
}

You can actually do this in C# (by providing To and Do as extension methods on int and IEnumerable<T> respectively):

1.To(7).Do(Console.WriteLine);

SmallTalk forever!

I kind of like the idea. It's very much like Python. Here's my version in a few lines:

static class Extensions
{
    public static IEnumerable<int> To(this int from, int to, int step = 1) {
        if (step == 0)
            throw new ArgumentOutOfRangeException("step", "step cannot be zero");
        // stop if next `step` reaches or oversteps `to`, in either +/- direction
        while (!(step > 0 ^ from < to) && from != to) {
            yield return from;
            from += step;
        }
    }
}

It works like Python's:

• 0.To(4) → [ 0, 1, 2, 3 ]
• 4.To(0) → [ 4, 3, 2, 1 ]
• 4.To(4) → [ ]
• 7.To(-3, -3) → [ 7, 4, 1, -2 ]

It seems like quite a long winded approach to a problem that's already solved. There's a whole state machine behind the Enumerable.Range that isn't really needed.

The traditional format is fundamental to development and familiar to all. I don't really see any advantage to your new style.

I think the foreach + Enumerable.Range is less error prone (you have less control and less ways to do it wrong, like decreasing the index inside the body so the loop would never end, etc.)

The readability problem is about the Range function semantics, that can change from one language to another (e.g if given just one parameter will it begin from 0 or 1, or is the end included or excluded or is the second parameter a count instead a end value).

About the performance, I think the compiler should be smart enough to optimize both loops so they execute at a similar speed, even with large ranges (I suppose that Range does not create a collection, but of course an iterator).

I think Range is useful for working with some range inline:

var squares = Enumerable.Range(1, 7).Select(i => i * i);

You can each over. Requires converting to list but keeps things compact when that's what you want.

Enumerable.Range(1, 7).ToList().ForEach(i => Console.WriteLine(i));

But other than for something like this, I'd use traditional for loop.

I'd like to have the syntax of some other languages like Python, Haskell, etc.

// Write the numbers 1 thru 7
foreach (int index in [1..7])
{
    Console.WriteLine(index);
}

Fortunatly, we got F# now :)

As for C#, I'll have to stick with the Enumerable.Range method.

@Luke: I reimplemented your To() extension method and used the Enumerable.Range() method to do it. This way it comes out a little shorter and uses as much infrastructure given to us by .NET as possible:

public static IEnumerable<int> To(this int from, int to)
{ 
    return from < to 
            ? Enumerable.Range(from, to - from + 1) 
            : Enumerable.Range(to, from - to + 1).Reverse();
}

How to use a new syntax today

Because of this question I tried out some things to come up with a nice syntax without waiting for first-class language support. Here's what I have:

using static Enumerizer;

// prints: 0 1 2 3 4 5 6 7 8 9
foreach (int i in 0 <= i < 10)
    Console.Write(i + " ");

Not the difference between <= and <.

I also created a proof of concept repository on GitHub with even more functionality (reversed iteration, custom step size).

A minimal and very limited implementation of the above loop would look something like like this:

public readonly struct Enumerizer
{
    public static readonly Enumerizer i = default;

    public Enumerizer(int start) =>
        Start = start;

    public readonly int Start;

    public static Enumerizer operator <(int start, Enumerizer _) =>
        new Enumerizer(start);

    public static Enumerizer operator >(int _, Enumerizer __) =>
        throw new NotImplementedException();

    public static IEnumerable<int> operator <=(Enumerizer start, int end)
    {
        for (int i = start.Start; i < end; i++)
            yield return i;
    }

    public static IEnumerable<int> operator >=(Enumerizer _, int __) =>
        throw new NotImplementedException();
}

I'm sure everybody has their personal preferences (many would prefer the later just because it is familiar over almost all programming languages), but I am like you and starting to like the foreach more and more, especially now that you can define a range.

In my opinion the Enumerable.Range() way is more declarative. New and unfamiliar to people? Certainly. But I think this declarative approach yields the same benefits as most other LINQ-related language features.

I imagine there could be scenarios where Enumerable.Range(index, count) is clearer when dealing with expressions for the parameters, especially if some of the values in that expression are altered within the loop. In the case of for the expression would be evaluated based on the state after the current iteration, whereas Enumerable.Range() is evaluated up-front.

Other than that, I'd agree that sticking with for would normally be better (more familiar/readable to more people... readable is a very important value in code that needs to be maintained).

I agree that in many (or even most cases) foreach is much more readable than a standard for-loop when simply iterating over a collection. However, your choice of using Enumerable.Range(index, count) isn't a strong example of the value of foreach over for.

For a simple range starting from 1, Enumerable.Range(index, count) looks quite readable. However, if the range starts with a different index, it becomes less readable because you have to properly perform index + count - 1 to determine what the last element will be. For example…

// Write the numbers 2 thru 8
foreach (var index in Enumerable.Range( 2, 7 ))
{
    Console.WriteLine(index);
}

In this case, I much prefer the second example.

// Write the numbers 2 thru 8
for (int index = 2; index <= 8; index++)
{
    Console.WriteLine(index);
}

I do like the foreach + Enumerable.Range approach and use it sometimes.

// does anyone object to the new style over the traditional style?
foreach (var index in Enumerable.Range(1, 7))

I object to the var abuse in your proposal. I appreciate var, but, damn, just write int in this case! ;-)

Strictly speaking, you misuse enumeration.

Enumerator provides the means to access all the objects in a container one-by-one, but it does not guarantee the order.

It is OK to use enumeration to find the biggest number in an array. If you are using it to find, say, first non-zero element, you are relying on the implementation detail you should not know about. In your example, the order seems to be important to you.

Edit: I am wrong. As Luke pointed out (see comments) it is safe to rely on the order when enumerating an array in C#. This is different from, for example, using "for in" for enumerating an array in Javascript .

Just throwing my hat into the ring.

I define this...

namespace CustomRanges {

	public record IntRange(int From, int Thru, int step = 1) : IEnumerable<int> {

		public IEnumerator<int> GetEnumerator() {
			for (var i = From; i <= Thru; i += step)
				yield return i;
		}

		IEnumerator IEnumerable.GetEnumerator()
			=> GetEnumerator();
	};

	public static class Definitions {

		public static IntRange FromTo(int from, int to, int step = 1)
			=> new IntRange(from, to - 1, step);

		public static IntRange FromThru(int from, int thru, int step = 1)
			=> new IntRange(from, thru, step);

		public static IntRange CountFrom(int from, int count)
			=> new IntRange(from, from + count - 1);

		public static IntRange Count(int count)
			=> new IntRange(0, count);

        // Add more to suit your needs. For instance, you could add in reversing ranges, etc.
	}
}

Then anywhere I want to use it, I add this at the top of the file...

using static CustomRanges.Definitions;

And use it like this...

foreach(var index in FromTo(1, 4))
	Debug.WriteLine(index);
// Prints 1, 2, 3

foreach(var index in FromThru(1, 4))
	Debug.WriteLine(index);
// Prints 1, 2, 3, 4

foreach(var index in FromThru(2, 10, 2))
	Debug.WriteLine(index);
// Prints 2, 4, 6, 8, 10

foreach(var index in CountFrom(7, 4))
	Debug.WriteLine(index);
// Prints 7, 8, 9, 10

foreach(var index in Count(5))
	Debug.WriteLine(index);
// Prints 0, 1, 2, 3, 4

foreach(var _ in Count(4))
	Debug.WriteLine("A");
// Prints A, A, A, A

The nice thing about this approach is by the names, you know exactly if the end is included or not.