Why is "while" so popular in C#?

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.)

Answer 2

Are all this iterations equivalents?

yes

why prefer the first? Has it sth. to do with readibility?

because you may want to extend the scope of the nr var beyond the while loop?

why is the 3th form seen much less in code?

it is equivalent, same statements! You may prefer the latter because you don't want to extend the scope of the nr variable