By default, the compiler infers a numeric literal to be either double or an integral type:

For example:

Console.Write (       1.0.GetType());  // Double (double)
Console.Write (      1E06.GetType());  // Double (double)
Console.Write (         1.GetType());  // Int32  (int)
Console.Write (0xF0000000.GetType());  // UInt32 (uint)

The numeric suffixes listed in the preceding table explicitly define the type of a literal:

decimal d = 3.5M;   // M = decimal (case-insensitive)

The suffixes U and L are rarely necessary, because the uint, long, and ulong types can nearly always be either inferred or implicitly converted from int:

long i = 5;     // Implicit conversion from int to long

The D suffix is technically redundant, in that all literals with a decimal point are inferred to be double (and you can always add a decimal point to a numeric literal). The F and M suffixes are the most useful and are mandatory when specifying fractional float or decimal literals. Without suffixes, the following would not compile, because 4.5 would be inferred to be of type double, which has no implicit conversion to float or decimal:

float f = 4.5F;       // Won't compile without suffix
decimal d = -1.23M;   // Won't compile without suffix

Integral conversions are implicit when the destination type can represent every possible value of the source type. Otherwise, an explicit conversion is required. For example:

int x = 12345;       // int is a 32-bit integral
long y = x;          // Implicit conversion to 64-bit int
short z = (short)x;  // Explicit conversion to 16-bit int

A float can be implicitly converted to a double, because a double can represent every possible float value. The reverse conversion must be explicit.

Conversions between decimal and other real types must be explicit.

Conversions from integral types to real types are implicit, whereas the reverse must be explicit. Converting from a floating-point to an integral truncates any fractional portion; to perform rounding conversions, use the static System.Convert class.

A caveat is that implicitly converting a large integral type to a floating-point type preserves magnitude but may occasionally lose precision:

int i1 = 100000001;
float f = i1;      // Magnitude preserved, precision lost
int i2 = (int)f;   // 100000000

Division operations on integral types always truncate remainders (round toward zero). Dividing by a variable whose value is zero generates a runtime error (a DivideByZeroException). Dividing by the literal or constant 0 generates a compile-time error.

At runtime, arithmetic operations on integral types can overflow. By default, this happens silently—no exception is thrown and the result exhibits wraparound behavior, as though the computation was done on a larger integer type and the extra significant bits discarded. For example, decrementing the minimum possible int value results in the maximum possible int value:

int a = int.MinValue; a--;
Console.WriteLine (a == int.MaxValue); // True

The checked operator tells the runtime to generate an OverflowException rather than overflowing silently when an integral expression or statement exceeds the arithmetic limits of that type. The checked operator affects expressions with the ++, ––, (unary) –, +, –, *, /, and explicit conversion operators between integral types.

You can use checked around either an expression or a statement block. For example:

int a = 1000000, b = 1000000;

int c = checked (a * b);   // Checks just the expression

checked                    // Checks all expressions
{                          // in statement block.
   c = a * b;
   ...
}

You can make arithmetic overflow checking the default for all expressions in a program by compiling with the /checked+ command-line switch (in Visual Studio, go to Advanced Build Settings). If you then need to disable overflow checking just for specific expressions or statements, you can do so with the unchecked operator.

C# supports the following bitwise operators: