5

When I tried a sample expression in C# in Visual Studio

public int Test()
{
    if (10/2 == 5)
        throw new Exception();
    return 0;
}

When I keep the expression 10/2 == 5, the vs.net automatically throws a warning "Unreachable Code Detected".

If I change the expression 10/2 == 6, the IDE is happy? How does it happen?

Edited: Sorry for the incomplete question. It happens so instantly and happens even before compiling the code?

I have upvoted each of the replies and accepted the first answer on FIFO basis

NSN
  • 740
  • 3
  • 9
  • 26

7 Answers7

9
if (10/2 == 5)

Will always return true, which means

throw new Exception();

Will always be executed, and 

return 0;

Will never be reached

Thomas
  • 1,281
  • 8
  • 22
4

If you decompile this code, you will end up with:

public int Test()
{
     throw new Exception();
}

I believe that since these are constant values, that the math is done at compile time, so 10/2 is not really 10/2, but 5...so it becomes trivial for the compiler to realize that 5==5 is always going to be true. In fact, I believe these constants will then automatically be translated into true. The compiler's goal is to optimize out code that is ALWAYS going to repeat and run the processing of it at compile time, rather than running the same processing over and over.

So, basically, the compiler realizes that since the if is always true and the if results in a return (via a throw), so it optimizes out the code that it knows will never be executed. Thus, the decompiled code results in the above.

In fact, the opposite happens if you do the 10/2 == 6, which is "constantized" into 5 == 6, which is turned into false. Since the if will always be false, it optimizes out the if:

public int Test()
{
    int num = 0;
    return num;
}
Justin Pihony
  • 66,056
  • 18
  • 147
  • 180
4

As others have said, the compiler can evaluate the expression 10 / 2 == 5 compile-time because it's a constant expression. It evaluates to true, therefore any code after the if scope is unreacable. If changed to false, the code inside the if is unreachable.

So now consider this code:

public int TestA() 
{ 
    if (10 / 2 == 5) 
        return 1; 
    return 0; 
} 

public int TestB() 
{ 
    if (10 / 2 == 6) 
        return 1; 
    return 0; 
}

Both methods generate a warning about unreachable code!

The strange thing about the C# compiler is that if the unreachable code consists entirely of throw statements, then no warning will be issued about the unreachabiliy.

ADDITION: This Stack Overflow question is related

Community
  • 1
  • 1
Jeppe Stig Nielsen
  • 60,409
  • 11
  • 110
  • 181
3

It is complaining that the line

return 0;

can never be reached. 10/2 is always equal to 5.

Eamonn McEvoy
  • 8,876
  • 14
  • 53
  • 83
2

In the first case, the compiler processes the expression 10/2 == 5, which evaluates to true, so the exception is thrown and the return 0 statement is unreachable.

In the second case, 10/2 == 6 evaluates to false, so the return 0 statement is reachable as the exception is not thrown.

In response to your edit: Your code does not have to actually compile for the compiler to know that the line of code is unreachable. It is smart enough to know that 10/2 == 5 is ALWAYS true, regardless of any user input, meaning the exception will always be thrown.

Daniel
  • 2,944
  • 3
  • 22
  • 40
1

The compiler is smart enough (this is a very simple check) and determines that return 0 will never be reached. This is because 10/2 == 5 will always be true. According to the compiler, the following expressions evaluate equally

if (10/2 == 5)

or

if true

The reason the compiler is able to determine this is because the numbers are not variable.

contactmatt
  • 18,116
  • 40
  • 128
  • 186
1

In fact he knows he will never come in return 0

He just warns that the entire code below the 10/2 == 5 will never be interpreted as 10/2 will always be 5.

In the same way:

if (true)
{
     ......
}
else 
{
  .....
}
Roger Medeiros
  • 783
  • 7
  • 9