C# Empty Statement

Question

The C# language specification defines the empty-statement grammar production, which allows me to do something like this:

static void Main(string[] args)
{
    ; ; ;
}

Why would Microsoft include this grammar production in the C# language? Does it have a useful purpose?

Answer 1

while (GetWhitespace(textStream))
    ;

Answer 2

I personally would never use an empty statement. If I for some bizarre reason wanted to play code golf and write something like

while(Foo(x++)) ;

I'd be more inclined to use {} instead of ; as the "do nothing statement". I think that is more clear.

Pretty much it's there for historic reasons. There's nothing there that you cannot also do with {}.

UPDATE: I just thought of one possible usage case. In a debug build it allows you to put a breakpoint somewhere that you are guaranteed that you can break at which is not going to have any side effect when you step. If the code surrounding the breakpoint is particularly complicated it might be useful.

UPDATE UPDATE: I am WRONG WRONG WRONG. That doesn't work. It just moves the breakpoint to the next statement. How irksome.

Answer 3

C# inherits a lot from the C family, where you can do things like

for (i = 0; i < n; v[i++] = 1);

or

while (testSomeCondition());

That is, run a loop with an empty body where the "meat" is inside the brackets.

While one can debate about their merits and dangers, these are pretty common programming idioms in the C programming world, so this backward compatibility makes it easier for C/C++/Java programmers to learn C#.

Answer 4

Here are two uses:

while(DoSomething()) ;

and

void M() {
    if(someCondition) goto exit;
    // ...
    exit: ;
}

There are many others. It's a useful device anytime there is nothing to do but a statement is required.

Answer 5

It allows have blocks of code IFDEF'd out, and the surrounding code still build. eg

if(true){
#if(DEBUG)
System.Console.WriteLine("Debug comment");
#endif
}

which could be written as an empty block, if you dislike brackets:

if(true)
#if(DEBUG)
   System.Console.WriteLine("Debug comment")
#endif
;

Answer 6

Good practice or not, some people use this:

while (!SomeCondition)
    ; // <-- body of the while loop is an empty statement

Answer 7

Why would Microsoft include this grammar production in the C# language?

the main answer to this question is: C# is C-like language and to make life of different developers easier MS decided to make most basic syntax elements compatible with other c-like languages. and it is good.

Answer 8

This is an assumption but I would assume it goes to the base grammar for the compiler. Relating it to set theory the "empty set" is inside every single set. That the ; really is to define a set of lexical operations which always must define the ; which also would accept the base case which is empty statement.

Answer 9

if (b1)
   if (b2) else;
else
   //code

withoud this ; this will be painful. but this is not best way to write ifs also. but acceptable.

Answer 10

Eric Lippert's a good person to ask.

Mostly, I suppose it's because it wouldn't cause any harm and it simplified their handling of the grammar. Also, why restrict people when you don't have to?

Answer 11

For what it's worth, a good rule of thumb is that you should have stepped through in the debugger every line of code you write, at least once for each possible execution path

ref: Possible mistaken empty statement

Answer 12

So some genius could write for(;;) instead of while(true). Like for an interview test.

Answer 13

Imagine you have some code that you want to extend by a new feature:

void DoSomething()
{
    // ...
    NewMethod();
}

Now you introduce a new member called NewMethod. However you don´t have the time to implement it appropriately and leave it empty:

public void NewMethod() { }

Some time later you can finally implement the code of that member without having to bother where and how to call it, because that was already done before.

You can also create an interface which you don´t implement. This way you only define what to do, but not how.

Another possible scenario is to have a virtual member that usually does nothing, but in a few cases (some specific implementation) you want the method to return a specific value. See this post for example: Virtual methods without body