C# Types

Types - C# language specification

The types of the C# language are divided into two main categories: value types and reference types . Both value types and reference types may be generic types , which take one or more type parameters . Type parameters can designate both value types and reference types.

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/types

type
    : value_type
    | reference_type
    | type_parameter
    | type_unsafe
    ;

Value types

value_type
    : struct_type
    | enum_type
    ;

struct_type
    : type_name
    | simple_type
    | nullable_type
    ;

simple_type
    : numeric_type
    | 'bool'
    ;

numeric_type
    : integral_type
    | floating_point_type
    | 'decimal'
    ;

integral_type
    : 'sbyte'
    | 'byte'
    | 'short'
    | 'ushort'
    | 'int'
    | 'uint'
    | 'long'
    | 'ulong'
    | 'char'
    ;

floating_point_type
    : 'float'
    | 'double'
    ;

nullable_type
    : non_nullable_value_type '?'
    ;

non_nullable_value_type
    : type
    ;

enum_type
    : type_name
    ;

The System.ValueType type

Default constructors

• For all simple_types, the default value is the value produced by a bit pattern of all zeros:
• For sbyte, byte, short, ushort, int, uint, long, and ulong, the default value is 0.
• For char, the default value is '\x0000'.
• For float, the default value is 0.0f.
• For double, the default value is 0.0d.
• For decimal, the default value is 0.0m.
• For bool, the default value is false.

• For an enum_type E, the default value is 0, converted to the type E.

• For a struct_type, the default value is the value produced by setting all value type fields to their default value and all reference type fields to null.

• For a nullable_type the default value is an instance for which the HasValue property is false and the Value property is undefined. The default value is also known as the null value of the nullable type.

class A
{
    void F() {
        int i = 0;
        int j = new int();
    }
}

Struct types

Simple types

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

• Most simple types permit values to be created by writing literals (Literals). For example, 123 is a literal of type int and 'a' is a literal of type char. C# makes no provision for literals of struct types in general, and non-default values of other struct types are ultimately always created through instance constructors of those struct types.

• When the operands of an expression are all simple type constants, it is possible for the compiler to evaluate the expression at compile-time. Such an expression is known as a constant_expression (Constant expressions). Expressions involving operators defined by other struct types are not considered to be constant expressions.

• Through const declarations it is possible to declare constants of the simple types (Constants). 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 operator (Evaluation of user-defined conversions).

Integral types

• The sbyte type represents signed 8-bit integers with values between -128 and 127.

• The byte type represents unsigned 8-bit integers with values between 0 and 255.

• The short type represents signed 16-bit integers with values between -32768 and 32767.

• The ushort type represents unsigned 16-bit integers with values between 0 and 65535.

• The int type represents signed 32-bit integers with values between -2147483648 and 2147483647.

• The uint type represents unsigned 32-bit integers with values between 0 and 4294967295.

• The long type represents signed 64-bit integers with values between -9223372036854775808 and 9223372036854775807.

• The ulong type represents unsigned 64-bit integers with values between 0 and 18446744073709551615.

• The char type represents unsigned 16-bit integers with values between 0 and 65535. The set of possible values for the char type corresponds to the Unicode character set. Although char has the same representation as ushort, not all operations permitted on one type are permitted on the other.

• For the unary + and ~ operators, the operand is converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of the operand. The operation is then performed using the precision of type T, and the type of the result is T.

• For the unary  operator, the operand is converted to type T, where T is the first of int and long that can fully represent all possible values of the operand. The operation is then performed using the precision of type T, and the type of the result is T. The unary  operator cannot be applied to operands of type ulong.

• For the binary +, , , /, %, &, ^, |, ==, !=, >, <, >=, and <= operators, the operands are converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of both operands. The operation is then performed using the precision of type T, and the type of the result is T (or bool for the relational operators). It is not permitted for one operand to be of type long and the other to be of type ulong with the binary operators.

• For the binary << and >> operators, the left operand is converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of the operand. The operation is then performed using the precision of type T, and the type of the result is T.

• There are no implicit conversions from other types to the char type. In particular, even though the sbyte, byte, and ushort types have ranges of values that are fully representable using the char type, implicit conversions from sbyte, byte, or ushort to char do not exist.

• Constants of the char type must be written as character_literals or as integer_literals in combination with a cast to type char. For example, (char)10 is the same as '\x000A'.

Floating point types

• Positive zero and negative zero. In most situations, positive zero and negative zero behave identically as the simple value zero, but certain operations distinguish between the two (Division operator).

• Positive infinity and negative infinity. Infinities are produced by such operations as dividing a non-zero number by zero. For example, 1.0 / 0.0 yields positive infinity, and 1.0 / 0.0 yields negative infinity.

• The Not-a-Number value, often abbreviated NaN. NaNs are produced by invalid floating-point operations, such as dividing zero by zero.

• The finite set of non-zero values of the form s * m * 2^e, where s is 1 or -1, and m and e are determined by the particular floating-point type: For float, 0 < m < 2^24 and 149 <= e <= 104, and for double, 0 < m < 2^53 and 1075 <= e <= 970. Denormalized floating-point numbers are considered valid non-zero values.

• If one of the operands is of an integral type, then that operand is converted to the floating-point type of the other operand.

• Then, if either of the operands is of type double, the other operand is converted to double, the operation is performed using at least double range and precision, and the type of the result is double (or bool for the relational operators).

• Otherwise, the operation is performed using at least float range and precision, and the type of the result is float (or bool for the relational operators).

• If the result of a floating-point operation is too small for the destination format, the result of the operation becomes positive zero or negative zero.

• If the result of a floating-point operation is too large for the destination format, the result of the operation becomes positive infinity or negative infinity.

• If a floating-point operation is invalid, the result of the operation becomes NaN.

• If one or both operands of a floating-point operation is NaN, the result of the operation becomes NaN.

The decimal type

The bool type

Enumeration types

Nullable types

• A HasValue property of type bool

• A Value property of type T

new T?(x)

Reference types

reference_type
    : class_type
    | interface_type
    | array_type
    | delegate_type
    ;

class_type
    : type_name
    | 'object'
    | 'dynamic'
    | 'string'
    ;

interface_type
    : type_name
    ;

array_type
    : non_array_type rank_specifier+
    ;

non_array_type
    : type
    ;

rank_specifier
    : '[' dim_separator* ']'
    ;

dim_separator
    : ','
    ;

delegate_type
    : type_name
    ;

Class types

The object type

The dynamic type

• Operations on expressions of type dynamic can be dynamically bound (Dynamic binding).

• Type inference (Type inference) will prefer dynamic over object if both are candidates.

• There is an implicit identity conversion between object and dynamic, and between constructed types that are the same when replacing dynamic with object

• Implicit and explicit conversions to and from object also apply to and from dynamic.

• Method signatures that are the same when replacing dynamic with object are considered the same signature

• The type dynamic is indistinguishable from object at run-time.

• An expression of the type dynamic is referred to as a dynamic expression.

The string type

Interface types

Array types

Delegate types

Boxing and unboxing

Boxing conversions

• From any value_type to the type object.

• From any value_type to the type System.ValueType.

• From any non_nullable_value_type to any interface_type implemented by the value_type.

• From any nullable_type to any interface_type implemented by the underlying type of the nullable_type.

• From any enum_type to the type System.Enum.

• From any nullable_type with an underlying enum_type to the type System.Enum.

• Note that an implicit conversion from a type parameter will be executed as a boxing conversion if at run-time it ends up converting from a value type to a reference type (Implicit conversions involving type parameters).

sealed class Box<T>: System.ValueType
{
    T value;

    public Box(T t) {
        value = t;
    }
}

int i = 123;
object box = i;

int i = 123;
object box = new Box<int>(i);

int i = 123;
object box = i;
if (box is int) {
    Console.Write("Box contains an int");
}

struct Point
{
    public int x, y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

Point p = new Point(10, 10);
object box = p;
p.x = 20;
Console.Write(((Point)box).x);

Unboxing conversions

• From the type object to any value_type.

• From the type System.ValueType to any value_type.

• From any interface_type to any non_nullable_value_type that implements the interface_type.

• From any interface_type to any nullable_type whose underlying type implements the interface_type.

• From the type System.Enum to any enum_type.

• From the type System.Enum to any nullable_type with an underlying enum_type.

• Note that an explicit conversion to a type parameter will be executed as an unboxing conversion if at run-time it ends up converting from a reference type to a value type (Explicit dynamic conversions).

object box = 123;
int i = (int)box;

object box = new Box<int>(123);
int i = ((Box<int>)box).value;

Constructed types

namespace Widgets
{
    class Queue {...}
    class Queue<TElement> {...}
}

namespace MyApplication
{
    using Widgets;

    class X
    {
        Queue q1;            // Non-generic Widgets.Queue
        Queue<int> q2;       // Generic Widgets.Queue
    }
}

class Outer<T>
{
    public class Inner {...}

    public Inner i;                // Type of i is Outer<T>.Inner
}

Type arguments

type_argument_list
    : '<' type_arguments '>'
    ;

type_arguments
    : type_argument (',' type_argument)*
    ;

type_argument
    : type
    ;

Open and closed types

• A type parameter defines an open type.

• An array type is an open type if and only if its element type is an open type.

• A constructed type is an open type if and only if one or more of its type arguments is an open type. A constructed nested type is an open type if and only if one or more of its type arguments or the type arguments of its containing type(s) is an open type.

Bound and unbound types

Satisfying constraints

• If the constraint is a class type, an interface type, or a type parameter, let C represent that constraint with the supplied type arguments substituted for any type parameters that appear in the constraint. To satisfy the constraint, it must be the case that type A is convertible to type C by one of the following:
• An identity conversion (Identity conversion)
• An implicit reference conversion (Implicit reference conversions)
• A boxing conversion (Boxing conversions), provided that type A is a non-nullable value type.
• An implicit reference, boxing or type parameter conversion from a type parameter A to C.

• If the constraint is the reference type constraint (class), the type A must satisfy one of the following:
• A is an interface type, class type, delegate type or array type. Note that System.ValueType and System.Enum are reference types that satisfy this constraint.
• A is a type parameter that is known to be a reference type (Type parameter constraints).

• If the constraint is the value type constraint (struct), the type A must satisfy one of the following:
• A is a struct type or enum type, but not a nullable type. Note that System.ValueType and System.Enum are reference types that do not satisfy this constraint.
• A is a type parameter having the value type constraint (Type parameter constraints).

• If the constraint is the constructor constraint new(), the type A must not be abstract and must have a public parameterless constructor. This is satisfied if one of the following is true:
• A is a value type, since all value types have a public default constructor (Default constructors).
• A is a type parameter having the constructor constraint (Type parameter constraints).
• A is a type parameter having the value type constraint (Type parameter constraints).
• A is a class that is not abstract and contains an explicitly declared public constructor with no parameters.
• A is not abstract and has a default constructor (Default constructors).

class B<T> where T: IEnumerable {...}

class D<T>: B<T> where T: IEnumerable {...}

class E<T>: B<List<T>> {...}

Type parameters

type_parameter
    : identifier
    ;

• A type parameter cannot be used directly to declare a base class (Base class) or interface (Variant type parameter lists).

• The rules for member lookup on type parameters depend on the constraints, if any, applied to the type parameter. They are detailed in Member lookup.

• The available conversions for a type parameter depend on the constraints, if any, applied to the type parameter. They are detailed in Implicit conversions involving type parameters and Explicit dynamic conversions.

• The literal null cannot be converted to a type given by a type parameter, except if the type parameter is known to be a reference type (Implicit conversions involving type parameters). However, a default expression (Default value expressions) can be used instead. In addition, a value with a type given by a type parameter can be compared with null using == and != (Reference type equality operators) unless the type parameter has the value type constraint.

• A new expression (Object creation expressions) can only be used with a type parameter if the type parameter is constrained by a constructor_constraint or the value type constraint (Type parameter constraints).

• A type parameter cannot be used anywhere within an attribute.

• A type parameter cannot be used in a member access (Member access) or type name (Namespace and type names) to identify a static member or a nested type.

• In unsafe code, a type parameter cannot be used as an unmanaged_type (Pointer types).

Expression tree types

Func<int,int> del = x => x + 1;                    // Code

Expression<Func<int,int>> exp = x => x + 1;        // Data

• Not all lambda expressions can be converted to expression trees. For instance, lambda expressions with statement bodies, and lambda expressions containing assignment expressions cannot be represented. In these cases, a conversion still exists, but will fail at compile-time. These exceptions are detailed in Anonymous function conversions.

• Expression<D> offers an instance method Compile which produces a delegate of type D:

Func<int,int> del2 = exp.Compile();

Invoking this delegate causes the code represented by the expression tree to be executed. Thus, given the definitions above, del and del2 are equivalent, and the following two statements will have the same effect:

int i1 = del(1);

int i2 = del2(1);

After executing this code, i1 and i2 will both have the value 2.