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)

Numeric suffixes explicitly define the type of a literal (suffixes can be either lower- or uppercase):

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 lossless conversion from
	               // int literal 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:

	double x = 4.0;

The F and M suffixes are the most useful and should always be applied when specifying float or decimal literals. Without the F suffix, the following line would not compile because 4.5 would be inferred to be of type double, which has no implicit conversion to float:

	float f = 4.5F;

The same principle is true for a decimal literal:

	decimal x = -1.23M;   // Will not compile without
	                      // the M suffix.

The semantics of numeric conversions are described in detail in the following section.

Integral conversions are implicit when the destination type can represent every possible value of the source type. Other-wise, an explicit conversion is required.

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

All integral types may be implicitly converted to all floating point numbers:

	int i = 1;
	float f = i;

The reverse conversion must be explicit:

	int i2 = (int)f;

Implicitly converting a large integral type to a floating-point type preserves magnitude but may occasionally lose precision. This is because floating-point types always have more magnitude than integral types, but they may have less precision. Rewriting our example with a larger number demonstrates:

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

All integral types can be implicitly converted to the decimal type because a decimal can represent every possible C# integral value. All other numeric conversions to and from a decimal type must be explicit.

Division operations on integral types always truncate remainders. Dividing by a variable whose value is 0 generates a runtime error (a DivisionByZeroException). Dividing by the literal 0 generates a compile-time error.

At runtime, arithmetic operations on integral types can overflow. By default, this happens silently—no exception is thrown. While the C# specification is agnostic as to the result of an overflow, the CLR always causes wraparound behavior. 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 failing 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.

checked can be used 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.

Regardless of the /checked compiler switch, expressions evaluated at compile time are always overflow-checked—unless you apply the unchecked operator:

	int x = int.MaxValue + 1;         // Compile-time error
	int y = unchecked (int.MaxValue + 1);      // No errors

C# supports these standard C-style bitwise operations.