C# provides a large set of operators, which are symbols that specify which operations to perform in an expression. C# predefines the usual arithmetic and logical operators, as well as a variety of others as shown in the following table. In addition, many operators can be overloaded by the user, thus changing their meaning when applied to a user-defined type.

The arithmetic operators (+, -, *, /) can produce results that are outside the range of possible values for the numeric type involved. You should refer to the C# Language Reference section on a particular operator for details, but in general:

• Integer arithmetic overflow either throws an OverflowException or discards the most significant bits of the result (see below). Integer division by zero always throws a DivideByZeroException.
• Floating-point arithmetic overflow or division by zero never throws an exception, because floating-point types are based on IEEE 754 and so have provisions for representing infinity and NaN (Not a Number).
• Decimal arithmetic overflow always throws an OverflowException. Decimal division by zero always throws a DivideByZeroException.

When integer overflow occurs, what happens depends on the execution context, which can be checked or unchecked. In a checked context, an OverflowException is thrown. In an unchecked context, the most significant bits of the result are discarded and execution continues. Thus, C# gives you the choice of handling or ignoring overflow.

In addition to the arithmetic operators, integral-type to integral-type casts can cause overflow (for example, casting a long to an int) and are subject to checked or unchecked execution. Also note that bitwise operators and shift operators never cause overflow.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.

The following reference tables summarize the C# types:

• Built-in types
• Integral types
• Floating-point types
• Default values
• Value types
• Implicit numeric conversions
• Explicit numeric conversions

For information on formatting the output of numeric types, see Formatting Numeric Results Table.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.

Built-in Types Table

The following table shows the keywords for built-in C# types, which are aliases of predefined types in the System namespace.

All of the types in the table, except object and string, are referred to as simple types.

The C# type keywords and their aliases are interchangeable. For example, you can declare an integer variable by using either of the following declarations:

int x = 123;
System.Int32 x = 123;

To display the actual type for any C# type use the system method GetType(). For example, the following statement displays the system alias that represents the type of myVariable:

Console.WriteLine(myVariable.GetType());

You can also use the typeof operator

The following table shows the sizes and ranges of the integral types, which constitute a subset of simple types.

If the value represented by an integer literal exceeds the range of ulong, a compilation error will occur.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.

The following table shows the precision and approximate ranges for the floating-point types.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.

The following table shows the default values of value types returned by the default constructors. Default constructors are invoked by using the new operator, for example:

int myInt = new int();

The preceding statement has the same effect as the following statement:

int myInt = 0;

Remember that using uninitialized variables in C# is not allowed.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.

The following table lists the C# value types by category.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.

The following table shows the predefined implicit numeric conversions. Implicit conversions might occur in many situations, including method invoking and assignment statements.

• The conversions from int, uint, or long to float and from long to double may cause a loss of precision, but not a loss of magnitude.
• There are no implicit conversions to the char type.
• There are no implicit conversions between floating-point types and the decimal type.
• A constant expression of type int can be converted to sbyte, byte, short, ushort, uint, or ulong, provided the value of the constant expression is within the range of the destination type.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.

Explicit numeric conversion is used to convert any numeric type to any other numeric type, for which there is no implicit conversion, by using a cast expression. The following table shows these conversions.

• The explicit numeric conversion may cause loss of precision or result in throwing exceptions.
• When you convert a float, double, or decimal value to an integral type, this value is rounded towards zero to the nearest integral value. If the resulting integral value is outside the range of the destination type, an InvalidCastException is thrown.
• When you convert double to float, the double value is rounded to the nearest float value. If the double value is too small or too large to fit into the destination type, the result will be zero or infinity.
• When you convert float or double to decimal, the source value is converted to decimal representation and rounded to the nearest number after the 28th decimal place if required. Depending on the value of the source value, one of the following results may occur:
• * If the source value is too small to be represented as a decimal, the result becomes zero.
  • If the source value is NaN (not a number), infinity, or too large to be represented as a decimal, an InvalidCastException is thrown.
• When you convert decimal to float or double, the decimal value is rounded to the nearest double or float value.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.

You can format numeric results by using the String.Format method, or through the Console.Write method, which calls String.Format. The format is specified using format strings. The following table contains the supported standard format strings. The format string takes the form Axx, where A is the format specifier and xx is the precision specifier. The format specifier controls the type of formatting applied to the numerical value, and the precision specifier controls the number of significant digits or decimal places of the formatted output.

For more information on standard and custom formatting strings, see Formatting Overview. For more information on the String.Format method, see String.Format Method.

FUENTE: © 2001 Microsoft Corporation. All rights reserved.