ECMA-334: 11.1.4 Simple types

Microsoft .NET Framework, ASP.NET, Visual C# (CSharp, C Sharp, C-Sharp) Developer Training, Visual Studio

C# Language Specification

11. Types 11.1 Value types 11.1.1 System.ValueType type 11.1.2 Default constructors 11.1.3 Struct types 11.1.4 Simple types 11.1.5 Integral types 11.1.6 Floating point types 11.1.7 decimal type 11.1.8 bool type 11.1.9 Enumeration types

© 2006 ECMA International

11.1.4 Simple types

C# provides a set of predefined struct types called the simple types. The simple types are identified through reserved words, but these reserved words are simply aliases for predefined struct types in the System namespace, as described in the table below.

Reserved word	Aliased type
sbyte	System.SByte
byte	System.Byte
short	System.Int16
ushort	System.UInt16
int	System.Int32
uint	System.UInt32
long	System.Int64
ulong	System.UInt64
char	System.Char
float	System.Single
double	System.Double
bool	System.Boolean
decimal	System.Decimal

Because a simple type aliases a struct type, every simple type has members. [Example: int has the members declared in System.Int32 and the members inherited from System.Object, and the following statements are permitted:

int i = int.MaxValue;      // System.Int32.MaxValue constant
string s = i.ToString();   // System.Int32.ToString() instance method
string t = 123.ToString(); // System.Int32.ToString() instance method 

end example] The simple types differ from other struct types in that they permit certain additional operations:

• Most simple types permit values to be created by writing literals (§9.4.4). [Example: 123 is a literal of type int and 'a' is a literal of type char. end example] C# makes no provision for literals of struct types in general.

• When the operands of an expression are all simple type constants, the compiler evaluates the expression at compile-time. Such an expression is known as a constant-expression (§14.16). Expressions involving operators defined by other struct types are not considered constant expressions.

• Through const declarations, it is possible to declare constants of the simple types (§17.3). It is not possible to have constants of other struct types, but a similar effect is provided by static readonly fields.

• Conversions involving simple types can participate in evaluation of conversion operators defined by other struct types, but a user-defined conversion operator can never participate in evaluation of another user-defined conversion operator (§13.4.2).