Question

The question field is a bit too short to pose my real question. If anyone can recapitulate it better, please feel free.

My real question is this: I’m reading a lot of other people’s code in C# these days, and I have noticed that one particular form of iteration is widely spread, (see in code).
My first question is:

Are all these iterations equivalent?

And my second is: why prefer the first? Has it something to do with readibility? Now I don’t believe the first form is more readable then the for-form once you get used to it, and readibility is far too much a subjective item in these constructs, of course, what you use the most will seem more readable, but I can assure everyone that the for-form is at least as readable, since it has all in one line, and you can even read the initializing in the construct.

Thus the second question: why is the 3rd form seen much less in code?

        // the 'widespread' construct
        int nr = getNumber();
        while (NotZero(nr))
        { 
            Console.Write(1/nr);
            nr = getNumber();
        }

        // the somewhat shorter form
        int nr;
        while (NotZero(nr = getNumber()))           
            Console.Write(1 / nr);            

        // the for - form
        for (int nr = getNumber(); NotZero(nr); nr = getNumber())
            Console.Write(1 / nr);

Answer 1

The first and third forms you’ve shown repeat the call to GetNumber. I prefer the second form, although it has the disadvantage of using a side-effect within a condition of course. However I pretty much only do that with a while loop. Usually I don’t end up passing the result as an argument though – the common situations I find myself in are:

string line;
while ( (line = reader.ReadLine()) != null)
...

and

int bytesRead;
while ( (bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
...

Both of these are now so idiomatic to me that they don’t cause me any problems – and as I say, they allow me to only state each piece of logic once.

If you don’t like the variable having too much scope, you can just introduce an extra block:

{
  int bytesRead;
  while ( (bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
  {
     // Body
  }
}

Personally I don’t tend to do this – the “too-wide” scope doesn’t bother me that much.

I suspect it wouldn’t be too hard to write a method to encapsulate all of this. Something like:

ForEach(() => reader.ReadLine(), // Way to obtain a value
        line => line != null,    // Condition
        line =>
{
    // body
};

Mind you, for line reading I have a class which helps:

foreach (string line in new LineReader(file))
{
    // body
}

(It doesn’t just work with files – it’s pretty flexible.)