Does C# allow double semicolon ; ; if so, are there any special ways?
No, a double semi-colon is never required. I'm slightly surprised that the compiler doesn't complain that it's an unreachable statement, but apparently it's legal. It won't do any harm, but equally it's not a good idea.
The empty statement is valid in all C-derived languages. The most common idiomatic use is in a for statement, e.g.:
for (; ; )
{
}
if their is a special use of it then show me where two semicolon is required to write a statement in c#
In the above example, two semicolons are required of course.
That a double ;;
is allowed, is for historical reasons. It's is a hangover from C style languages (which C# is based on).
C & C++ have the concept of pre-processor macros which are replaced in the code before the code is compiled e.g. trivial example AddAndSquare
is a macro, not a function
#define AddAndSquare(X,Y) (X+Y)*(X+Y)
int Foo() {
int a = 1, b = 2;
return AddAndSquare(a, b);
}
goes to the compiler as
int Foo() {
int a = 1, b = 2;
return (A+B)*(A+B);
}
You can redefine macros to be different to their initial definition, also you can redefine them so they don't exist at all.
Given an assertion macro #define ASSERT(c) if(!c) throw new AssertionFailedException()
you can have your coded littered with ASSERT statements.
void Foo(int x) {
int y = x + 2;
ASSERT(y != 0);
int z = x / y;
. . . .
}
Now consider that you only want the asserts in debug builds, but not in release builds, for release you redefine the macro to be empty (literally #define ASSERT
). Now when Foo goes to the compiler for a release build, it looks like this
void Foo(int x) {
int y = x + 2;
;
int z = x / y;
. . . .
}
There's now an empty statement where the ASSERT was, because there may or may not be a statement there (depending on build configuration), the compiler needs to be able to handle an empty statement.
Why this convention was kept in C# where there are nothing like C
macros, I have no idea, but possibly because it causes little or no harm.
I would guess that multiple ;
are elided by the compiler before it starts parsing code, therefore your unreachable ;
is ignored by the compiler.