4
public class Program
{
     public static void main(String[] args)
     {
         string message = "This is a message";
         int number = 6;
         object obj = null;
         int? nullable = (int?)12;
     }
}

The first three variable declarations on this program throw the following warning:

The variable 'X' is assigned but its value is never used

Yet, the last statement:

int? nullable = (int?)12;

doesn't throw anything. Why is that?

enter image description here

Matias Cicero
  • 25,439
  • 13
  • 82
  • 154
  • 2
    I'm using VS2015 and I get 4 warnings. – Jeroen Vannevel Sep 11 '15 at 19:53
  • 1
    @JeroenVannevel I'm using VS2012 and I got three. Will post a screenshot. – Matias Cicero Sep 11 '15 at 19:54
  • 1
    Then I assume it was bugged at one point and is no longer. I can't immediately find anything about a bugfix though. – Jeroen Vannevel Sep 11 '15 at 20:00
  • look at : http://stackoverflow.com/questions/2740885/c-sharp-compiler-should-give-warning-but-doesnt/2741281#2741281 – Avitus Sep 11 '15 at 20:03
  • why not declare the variable at the class level and then assign it and you will see that it gets resolved or declare `public string message = "This is a message"` at the class level. – MethodMan Sep 11 '15 at 20:07
  • @MethodMan We're talking about local variables here, not properties. I understand if the warning does not show up on unused properties. Anyway, I'm not trying to find any workaround, I just want to know why is the last statement not throwing any warning – Matias Cicero Sep 11 '15 at 20:10
  • @Avitus Will read it when I get home, thank you! – Matias Cicero Sep 11 '15 at 20:11
  • does the warning show however the values still persist..? if so why not ignore the warning. I get the same warning and I still think that if you initialize it and assign it then that will take care of the issue.. sounds like an undocumented bug in VS – MethodMan Sep 11 '15 at 20:12
  • declare the message as an `object` and I bet that will take care of it.. for example `object message = "This is a Message";` – MethodMan Sep 11 '15 at 20:15
  • I think it's because the `int?` line is invoking the constructor of `System.Nullable` -- so in theory it is "doing work". The other lines are doing no work, and in fact, the compiler simply optimizes them out by _removing_ them from the IL. Changing any of the lines to instead call a method (e.g., `string message = GetMessage();`) the compiler warning is removed and the lines are included in the IL. So yes, while the `int? nullable = (int?)12;` is kinda technically assigned a value and never used, it is doing work. Perhaps this is just an oversight in the warning gen in older VS versions. – Chris Sinclair Sep 11 '15 at 20:15
  • @MatiCicero: Also, I can confirm with VS2013 it produces the same 3 warnings. – Chris Sinclair Sep 11 '15 at 20:18

3 Answers3

4

The warning that you're seeing is only shown in cases where the compiler can prove that the expression used to initialize the variable can't possibly cause any side effects. When you're just assigning a literal string, integer, or null value to a variable, the compiler knows that none of those things can possibly cause side effects. For your last value you're not just assigning a literal value though; you're using the explicit operator of a type as well, and as far as the compiler is concerned, that operator is just some code that could do anything. It could, for example, cause relevant side effects (it doesn't, but the compiler doesn't know that) that would make the line not superfluous.

Servy
  • 202,030
  • 26
  • 332
  • 449
  • This makes a lot of sense, but why would they change this behaviour on VS2015 as @JeroenVannevel commented? – Matias Cicero Sep 11 '15 at 21:07
  • @MatiCicero The operation doesn't *actually* cause any side effects, so the reason that it didn't provide a warning in earlier versions is that it's algorithm simply wasn't sophisticated enough to realize that the code is redundant. Apparently they improved the algorithm such that there are additional cases where it can actually show that the code can't cause side effects. – Servy Sep 11 '15 at 21:09
0

Warnings are best practice suggestions, they are not true errors. Visual studio is smart enough to see you created the variables but never used them so they are useless. It is recommending that you get rid of them since you don't use them.

If you actually do something with them then the errors will go away. For example if you said:

number += nullable;

Would get rid of 1 of the errors. If you did something like:

message = message + " and this is more message";

It would get rid of the other error.

I believe it sees the int? as an object and since you are casting it to the nullable variable, it can't figure out if it had been used before hand. I think it has something more to do with the casting just isn't caught as an error because it can't tell if you referenced that variable somewhere else.

I think it would be the equivalent of something like this:

var a = new SomeClass();
var b = a;

Since it can't tell if a has really been used, then it doesn't show an error. If you put that in with a real class it will not show the error also.

Jonathan
  • 1,725
  • 3
  • 19
  • 45
0

It seems like the Warning doesn't show because the line with the nullable actually do an operation before the assignation. As for exemple the following code only generate a warning on the variable named number. This seems to be logical in the meaning that the line with warning are truely useless in the current code. The other lines might do something during the execution and will not be "optimized out". To test it run your code in release mode with the debugger ad you will see that all lines that have a warning are skipped ("optimized")

class Program
{
    static void Main(string[] args)
    {
        string message = ';'.ToString();
        int number = 6;
        object obj = (object)(new t());
        int? nullable = (int?)12;
    }
    class t
    { }
}

With this being said. The nullable it not optimized because there is a cast from a int '12' to a int?. Since it is a real cast and not a "useless cast" an operation is needed during the run time.

Daneau
  • 1,085
  • 9
  • 15