Question

What I want to do is be told the type, value (if there is one at compile-time) and other information (I do not know what I need now) of a selection of an expression.

For example, if I have an expression like

int i = unchecked((short)0xFF);

selecting 0xFF will give me (Int32, 255), while selecting ((short)0xFF) will give me (Int16, 255), and selecting i will give me (Int32, 255).

Reason why I want such a feature is to be able to verify my assumptions. It’s pretty easy to assume that 0xFF is a byte but it is actually an int. I could of course refer to the C# Language Specifications all the time, but I think it’s inefficient to have to refer to it everytime I want to check something out. I could also use something like ANTLR but the learning curve is high.

I do intend to read the entire specs and learn ANTLR and about compilers, but that’s for later. Right now I wish to have tools to help me get the job done quickly and accurately.

Another case in point:

int? i = 0x10;
int? j = null;
int x;
x = (i >> 4) ?? -1;//x=1
x = (j >> 4) ?? -1;//x=-1

It may seem easy to you or even natural for the bottom two lines in the code above. (Maybe one should avoid code like these, but that’s another story) However, what msdn says about the null-coalescing operator is lacking information to tell me that the above code ((i>>4)??) is legal (yet it is, and it is). I had to dig into grammar in the specs to know what’s happening:

• null-coalescing-expression
• conditional-or-expression
• conditional-and-expression
• exclusive-or-expression
• and-expression
• equality-expression
• relational-expression
• shift-expression
• shift-expression right-shift additive-expression
  … (and more)

Only after reading so much can I get a satisfactory confirmation that it is valid code and does what I think it does. There should be a much simpler way for the average programmer to verify (not about validity, but whether it behaves as thought or not, and also to satisfy my curiosity) such code without having to dive into that canonical manual. It doesn’t necessary have to be a VS plugin. Any alternative that is intuitive to use will do just as well.

Answer 1

Well, I’m not aware of any add-ins that do what you describe – however, there is a trick you can use figure out the type of an expression (but not the compile-time value):

• Assign the expression to a var variable, and hover your mouse over the keyword var.

So for example, when you write:

var i = unchecked((short)0xFF); 

and then hover your mouse over the keyword var, you get a tooltip that says something like:

Struct System.Int16

Represents a 16-bit signed integer.

This is definitely a bit awkward – since you have to potentially change code to make it work. But in a pinch, it let’s you get the compiler to figure out the type of an expression for you.

Keep in mind, this approach doesn’t really help you once you start throwing casts into the picture. For instance:

object a = 0xFF;
var z = (string)a;  // compiles but fails at runtime!

In the example above, the IDE will dutifully report that the type of var z is System.String – but this is, of course, entirely wrong.