C# compiler number literals

Question

Does anyone know the full list of C# compiler number literal modifiers?

By default declaring '0' makes it an Int32 and '0.0' makes it a 'Double'. I can use the literal modifier 'f' at the end to ensure something is treated as a 'Single' instead. For example like this...

var x = 0;    // x is Int32
var y = 0f;   // y is Single

What are the other modifiers I can use? Is there one for forcing to Double, Decimal, UInt32? I tried googling for this but could not find anything. Maybe my terminology is wrong and so that explains why I am coming up blank. Any help much appreciated.

History

Answer 1

var y = 0f; // y is single
var z = 0d; // z is double
var r = 0m; // r is decimal
var i = 0U; // i is unsigned int
var j = 0L; // j is long (note capital L for clarity)
var k = 0UL; // k is unsigned long (note capital L for clarity)

From the C# specification 2.4.4.2 Integer literals and 2.4.4.3 Real literals. Take note that L and UL are preferred as opposed to their lowercase variants for clarity as recommended by Jon Skeet.

Collaboration

While l is certainly valid for longs, I'd recommend using L instead - it's just as valid, and doesn't look like a "1" – Katharina

@Jon Skeet: bad habit of a C programmer, added your advice. – Collaboration

Why is 0U uppercase? I can't see any ambiguity with 0u. – Veritable

Answer 2

If you don't want to have to remember them, then the compiler also accepts a cast for the same purpose (you can check the IL that the effect is the same - i.e. the compiler, not the runtime, does the cast). To borrow the earlier example:

    var y = (float)0; // y is single
    var z = (double)0; // z is double
    var r = (decimal)0; // r is decimal
    var i = (uint)0; // i is unsigned int
    var j = (long)0; // j is long
    var k = (ulong)0; // k is unsigned long

And for the record, I agree that "var" is a bad choice here; I'll happily use var for a SortedDictionary<SomeLongType, SomeOtherLongType>, but for "int" it is just lazy...

Breakaway

@Marc Gravell: +1 good advice using the cast, but sometimes you need to use the suffix (say, bad example, 3.14159m). I personally use the cast when I'm looking to be explicit. – Collaboration

The compiler treat the following identically; do you have an example where it makes a difference? var x = 3.14159m; var y = (decimal)3.14159; – Breakaway

@Marc Gravell: hmm, not that I can think of, just the hunch of a C/C++ programmer. I guess I don't take the same things for granted! Thanks for the tip. – Collaboration

To answer the question in the comment, (decimal)1.000000000000001 evaluates to 1 whereas 1.000000000000001m evaluates to 1.000000000000001. In the former case, the computer parses the literal as a double and then casts it to a decimal. – Schlenger

Answer 3

You might want to start by looking at the C# language spec. Most of the types are listed in there, and have a suffix:

• L = long
• F = float
• U = uint
• ulong's are a little different
• m = decimal (money)
• D = double

Of course, if you stop using var then you get around the whole problem, and your code becomes more readable (ok, thats subjective, but for something like this, it's more readable by other people:

var x = 0; //whats x?
float x = 0; //oh, it's a float
byte x = 0; // or not!

Coz

@Nic Wise: +1 stop using var ;D Although it does simplify showing which suffix goes with which type. – Collaboration

yeah, very good point :) I like var in general, esp in foreach statements (foreach(var a in myList)) but other than that, I'm not a huge fan. – Coz