4. Types

The types of the C# language are classified 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 themselves can designate both value types and reference types.

      type:
            value-type
            reference-type
            type-parameter

A third category of types, pointers, is available only in unsafe code. Pointers are discussed further in §18.2.

Value types differ from reference types in that variables of the value types directly contain their data, whereas variables of the reference types store references to their data, the latter being known as objects. With reference types, it is possible for two variables to reference the same object, and, therefore, possible for operations on one variable to affect the object referenced by the other variable. With value types, each variable has its own copy of the data, and it is not possible for operations on one variable to affect the other.

C#’s type system is unified such that a value of any type can be treated as an object. Every type in C# directly or indirectly derives from the object class type, and object is the ultimate base class of all types. Values of reference types are treated as objects simply by viewing the values as type object. Values of value types are treated as objects by performing boxing and unboxing operations (§4.3).

4.1 Value Types

A value type is either a struct type or an enumeration type. C# provides a set of predefined struct types called simple types. The simple types are identified through reserved words.

      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

Unlike a variable of a reference type, a variable of a value type can contain the value null only if the value type is a nullable type. For every non-nullable value type, there is a corresponding nullable value type denoting the same set of values plus the value null.

Assignment to a variable of a value type creates a copy of the value being assigned. This differs from assignment to a variable of a reference type, which copies the reference but not the object identified by the reference.

4.1.1 The System.ValueType Type

All value types implicitly inherit from the class System.ValueType, which in turn inherits from class object. It is not possible for any type to derive from a value type, so value types are implicitly sealed (§10.1.1.2).

Note that System.ValueType is not itself a value-type. Rather, it is a class-type from which all value-types are automatically derived.

4.1.2 Default Constructors

All value types implicitly declare a public parameterless instance constructor called the default constructor. The default constructor returns a zero-initialized instance known as the default value for the value type:

•  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.

Like any other instance constructor, the default constructor of a value type is invoked using the new operator. For efficiency reasons, this requirement is not intended to actually have the implementation generate a constructor call. In the following example, variables i and j are both initialized to zero.

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

Because every value type implicitly has a public parameterless instance constructor, it is not possible for a struct type to contain an explicit declaration of a parameterless constructor. A struct type is, however, permitted to declare parameterized instance constructors (§11.3.8).

4.1.3 Struct Types

A struct type is a value type that can declare constants, fields, methods, properties, indexers, operators, instance constructors, static constructors, and nested types. The declaration of struct types is described in §11.1.

4.1.4 Simple Types

C# provides a set of predefined struct types called 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.

Because a simple type aliases a struct type, every simple type has members. For 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

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 (§2.4.4). 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 nondefault 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 (§7.18). 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 (§10.4). 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 (§6.4.3).

4.1.5 Integral Types

C# supports nine integral types: sbyte, byte, short, ushort, int, uint, long, ulong, and char. The integral types have the following sizes and ranges of values:

•  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.

The integral-type unary and binary operators always operate with signed 32-bit precision, unsigned 32-bit precision, signed 64-bit precision, or unsigned 64-bit precision:

•  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.

The char type is classified as an integral type, but it differs from the other integral types in two ways:

•  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'.

The checked and unchecked operators and statements are used to control overflow checking for integral-type arithmetic operations and conversions (§7.5.12). In a checked context, an overflow produces a compile-time error or causes a System.OverflowException to be thrown. In an unchecked context, overflows are ignored and any high-order bits that do not fit in the destination type are discarded.

4.1.6 Floating Point Types

C# supports two floating point types: float and double. The float and double types are represented using the 32-bit single-precision and 64-bit double-precision IEEE 754 formats, which provide the following sets of values:

•  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 (§7.7.2).

•  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²⁴ and −149 ≤ e ≤ 104; for double, 0 < m < 2⁵³ and −1075 ≤ e ≤ 970. Denormalized floating point numbers are considered valid non-zero values.

The float type can represent values ranging from approximately 1.5 × 10⁻⁴⁵ to 3.4 × 10³⁸ with a precision of 7 digits.

The double type can represent values ranging from approximately 5.0 × 10⁻³²⁴ to 1.7 × 10³⁰⁸ with a precision of 15 or 16 digits.

If one of the operands of a binary operator is of a floating point type, then the other operand must be of an integral type or a floating point type, and the operation is evaluated as follows:

•  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).

The floating point operators, including the assignment operators, never produce exceptions. Instead, in exceptional situations, floating point operations produce zero, infinity, or NaN, as described here:

•  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.

Floating point operations may be performed with higher precision than the result type of the operation. For example, some hardware architectures support an “extended” or “long double” floating point type with greater range and precision than the double type, and implicitly perform all floating point operations using this higher precision type. Only at excessive cost in performance can such hardware architectures be made to perform floating point operations with less precision. Rather than require an implementation to forfeit both performance and precision, C# allows a higher precision type to be used for all floating point operations. Other than delivering more precise results, this difference rarely has any measurable effects. However, in expressions of the form x * y / z, where the multiplication produces a result that is outside the double range, but the subsequent division brings the temporary result back into the double range, the fact that the expression is evaluated in a higher range format may cause a finite result to be produced instead of an infinity.

4.1.7 The decimal Type

The decimal type is a 128-bit data type suitable for financial and monetary calculations. This type can represent values ranging from 1.0 × 10⁻²⁸ to approximately 7.9 × 10²⁸ with 28 or 29 significant digits.

The finite set of values of type decimal are of the form (–1)^s × c × 10^-e, where the sign s is 0 or 1, the coefficient c is given by 0 ≤ c < 2⁹⁶, and the scale e is such that 0 ≤ e ≤ 28. The decimal type does not support signed zeros, infinities, or NaNs. A decimal is represented as a 96-bit integer scaled by a power of 10. For decimals with an absolute value less than 1.0m, the value is exact to the 28th decimal place, but no further. For decimals with an absolute value greater than or equal to 1.0m, the value is exact to 28 or 29 digits. In contrast, to the float and double data types, the decimal type is able to represent decimal fractional numbers such as 0.1 exactly. In the float and double representations, such numbers are often infinite fractions, making those representations more prone to round-off errors.

If one of the operands of a binary operator is of type decimal, then the other operand must be of an integral type or of type decimal. If an integral type operand is present, it is converted to decimal before the operation is performed.

The result of an operation on values of type decimal is that which would result from calculating an exact result (preserving scale, as defined for each operator) and then rounding to fit the representation. Results are rounded to the nearest representable value. When a result is equally close to two representable values, it is rounded to the value that has an even number in the least significant digit position (an approach known as “banker’s rounding”). A zero result always has a sign of 0 and a scale of 0.

If a decimal arithmetic operation produces a value less than or equal to 5 × 10^-29 in absolute value, the result of the operation becomes zero. If a decimal arithmetic operation produces a result that is too large for the decimal format, a System.OverflowException is thrown.

The decimal type has greater precision but smaller range than the floating point types. Thus conversions from the floating point types to decimal might produce overflow exceptions, and conversions from decimal to the floating point types might cause loss of precision. For these reasons, no implicit conversions exist between the floating point types and decimal. Without explicit casts, it is not possible to mix floating point and decimal operands in the same expression.

4.1.8 The bool Type

The bool type represents boolean logical quantities. The two possible values of type bool are true and false.

No standard conversions exist between bool and other types. In particular, the bool type is distinct and separate from the integral types, and a bool value cannot be used in place of an integral value, and vice versa.

In the C and C++ languages, a zero integral or floating point value, or a null pointer, can be converted to the boolean value false; a non-zero integral or floating point value, or a non-null pointer, can be converted to the boolean value true. In C#, such conversions are accomplished by explicitly comparing an integral or floating point value to zero, or by explicitly comparing an object reference to null.

4.1.9 Enumeration Types

An enumeration type is a distinct type with named constants. Every enumeration type has an underlying type, which must be byte, sbyte, short, ushort, int, uint, long, or ulong. The set of values of the enumeration type is the same as the set of values of the underlying type. Values of the enumeration type are not restricted to the values of the named constants. Enumeration types are defined through enumeration declarations (§14.1).

4.1.10 Nullable Types

A nullable type can represent all values of its underlying type plus an additional null value. A nullable type is written T?, where T is the underlying type. This syntax is shorthand for System.Nullable<T>, and the two forms can be used interchangeably.

A non-nullable value type is any value type other than System.Nullable<T> and its shorthand T? (for any T), plus any type parameter that is constrained to be a non-nullable value type (that is, any type parameter with a struct constraint). The System.Nullable<T> type specifies the value type constraint for T (§10.1.5), which means that the underlying type of a nullable type can be any non-nullable value type. The underlying type of a nullable type cannot be a nullable type or a reference type. For example, int?? and string? are invalid types.

An instance of a nullable type T? has two public read-only properties:

•  A HasValue property of type bool

•  A Value property of type T

An instance for which HasValue is true is said to be non-null. A non-null instance contains a known value, and Value returns that value.

An instance for which HasValue is false is said to be null. A null instance has an undefined value. Attempting to read the Value of a null instance causes a System. InvalidOperationException to be thrown. The process of accessing the Value property of a nullable instance is referred to as unwrapping.

In addition to the default constructor, every nullable type T? has a public constructor that takes a single argument of type T. Given a value x of type T, a constructor invocation of the form

        new T?(x)

creates a non-null instance of T? for which the Value property is x. The process of creating a non-null instance of a nullable type for a given value is referred to as wrapping.

Implicit conversions are available from the null literal to T? (§6.1.5) and from T to T? (§6.1.4).

4.2 Reference Types

A reference type is a class type, an interface type, an array type, or a delegate type.

      reference-type:
            class-type
            interface-type
            array-type
            delegate-type

      class-type:
            type-name
            object
            string

      interface-type:
            type-name

      array-type:
            non-array-type   rank-specifiers

      non-array-type:
            type

      rank-specifiers:
            rank-specifier
            rank-specifiers   rank-specifier

      rank-specifier:
            [   dim-separators_opt   ]

      dim-separators:
            ,
            dim-separators   ,

      delegate-type:
            type-name

A reference type value is a reference to an instance of the type, with the latter being known as an object. The special value null is compatible with all reference types and indicates the absence of an instance.

4.2.1 Class Types

A class type defines a data structure that contains data members (constants and fields), function members (methods, properties, events, indexers, operators, instance constructors, destructors, and static constructors), and nested types. Class types support inheritance, a mechanism whereby derived classes can extend and specialize base classes. Instances of class types are created using object-creation-expressions (§7.5.10.1).

Class types are described in §10.

Certain predefined class types have special meaning in the C# language, as described in the table.

4.2.2 The object Type

The object class type is the ultimate base class of all other types. Every type in C# directly or indirectly derives from the object class type.

The keyword object is simply an alias for the predefined class System.Object.

4.2.3 The string Type

The string type is a sealed class type that inherits directly from object. Instances of the string class represent Unicode character strings.

Values of the string type can be written as string literals (§2.4.4.5).

The keyword string is simply an alias for the predefined class System.String.

4.2.4 Interface Types

An interface defines a contract. A class or struct that implements an interface must adhere to its contract. An interface may inherit from multiple base interfaces, and a class or struct may implement multiple interfaces.

Interface types are described in §13.

4.2.5 Array Types

An array is a data structure that contains zero or more variables, which are accessed through computed indices. The variables contained in an array, also called the elements of the array, are all of the same type, and this type is called the element type of the array.

Array types are described in §12.

4.2.6 Delegate Types

A delegate is a data structure that refers to one or more methods. For instance methods, it also refers to their corresponding object instances.

The closest equivalent of a delegate in C or C++ is a function pointer. Whereas a function pointer can reference only static functions, however, a delegate can reference both static and instance methods. In the latter case, the delegate stores not only a reference to the method’s entry point, but also a reference to the object instance on which to invoke the method.

Delegate types are described in §15.

4.3 Boxing and Unboxing

The concept of boxing and unboxing is central to C#’s type system. It provides a bridge between value-types and reference-types by permitting any value of a value-type to be converted to and from type object. Boxing and unboxing enables a unified view of the type system wherein a value of any type can ultimately be treated as an object.

4.3.1 Boxing Conversions

A boxing conversion permits a value-type to be implicitly converted to a reference-type. The following boxing conversions exist:

•  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 runtime it ends up converting from a value type to a reference type (§6.1.9).

Boxing a value of a non-nullable-value-type consists of allocating an object instance and copying the non-nullable-value-type value into that instance.

Boxing a value of a nullable-type produces a null reference if it is the null value (HasValue is false), or the result of unwrapping and boxing the underlying value otherwise.

The actual process of boxing a value of a non-nullable-value-type is best explained by imagining the existence of a generic boxing class, which behaves as if it were declared as follows:

        sealed class Box<T>: System.ValueType
        {
                T value;
                public Box(T t) {
                       value = t;
                }
        }

Boxing of a value v of type T now consists of executing the expression new Box<T>(v), and returning the resulting instance as a value of type object. Thus, the statements

        int i = 123;
        object box = i;

conceptually correspond to

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

A boxing class such as Box<T> doesn’t actually exist, and the dynamic type of a boxed value isn’t actually a class type. Instead, a boxed value of type T has the dynamic type T, and a dynamic type check using the is operator can simply reference type T. For example,

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

will output the string “Box contains an int” on the console.

A boxing conversion implies making a copy of the value being boxed. This effect is different from a conversion of a reference-type to type object, in which the value continues to reference the same instance and simply is regarded as the less derived type object. For example, given the declaration

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

the statements

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

will output the value 10 on the console because the implicit boxing operation that occurs in the assignment of p to box causes the value of p to be copied. Had Point been declared a class instead, the value 20 would be output because p and box would reference the same instance.

4.3.2 Unboxing Conversions

An unboxing conversion permits a reference-type to be explicitly converted to a value-type. The following unboxing conversions exist:

•  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

An explicit conversion to a type parameter will be executed as an unboxing conversion if at runtime it ends up converting from a reference type to a value type (§6.2.6).

An unboxing operation to a non-nullable-value-type consists of first checking that the object instance is a boxed value of the given non-nullable-value-type, and then copying the value out of the instance.

Unboxing to a nullable-type produces the null value of the nullable-type if the source operand is null, or the wrapped result of unboxing the object instance to the underlying type of the nullable-type otherwise.

Referring to the imaginary boxing class described in the previous section, an unboxing conversion of an object box to a value-type T consists of executing the expression ((Box<T>) box).value. Thus the statements

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

conceptually correspond to

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

For an unboxing conversion to a given non-nullable-value-type to succeed at runtime, the value of the source operand must be a reference to a boxed value of that non-nullable-value-type. If the source operand is null, a System.NullReferenceException is thrown. If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

For an unboxing conversion to a given nullable-type to succeed at runtime, the value of the source operand must be either null or a reference to a boxed value of the underlying non-nullable-value-type of the nullable-type. If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

4.4 Constructed Types

A generic type declaration, by itself, denotes an unbound generic type that is used as a “blueprint” to form many different types, by way of applying type arguments. The type arguments are written within angle brackets (< and >) immediately following the name of the generic type. A type that includes at least one type argument is called a constructed type. A constructed type can be used in most places in the language in which a type name can appear. By contrast, an unbound generic type can be used only within a typeof-expression (§7.5.11).

Constructed types can also be used in expressions as simple names (§7.5.2) or when accessing a member (§7.5.4).

When a namespace-or-type-name is evaluated, only generic types with the correct number of type parameters are considered. Thus, it is possible to use the same identifier to identify different types, as long as those types have different numbers of type parameters. This capability is useful when you are mixing generic and nongeneric classes in the same program:

        namespace Widgets
        {
                class Queue {…}
                class Queue<TElement> {…}
        }
        namespace MyApplication
        {
                using Widgets;
                class X
                {
                       Queue q1;             // Nongeneric Widgets.Queue
                       Queue<int> q2;    // Generic Widgets.Queue
                }
        }

A type-name might identify a constructed type even though it doesn’t specify type parameters directly. This can occur where a type is nested within a generic class declaration, and the instance type of the containing declaration is implicitly used for name lookup (§10.3.8.6):

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

In unsafe code, a constructed type cannot be used as an unmanaged-type (§18.2).

4.4.1 Type Arguments

Each argument in a type argument list is simply a type.

      type-argument-list:
            <   type-arguments   >

      type-arguments:
            type-argument
            type-arguments   ,   type-argument

      type-argument:
            type

In unsafe code (§18), a type-argument may not be a pointer type. Each type argument must satisfy any constraints on the corresponding type parameter (§10.1.5).

4.4.2 Open and Closed Types

All types can be classified as either open types or closed types. An open type is a type that involves type parameters. More specifically:

•  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.

A closed type is a type that is not an open type.

At runtime, all of the code within a generic type declaration is executed in the context of a closed constructed type that was created by applying type arguments to the generic declaration. Each type parameter within the generic type is bound to a particular runtime type. The runtime processing of all statements and expressions always occurs with closed types, and open types occur only during compile-time processing.

Each closed constructed type has its own set of static variables, which are not shared with any other closed constructed types. Because an open type does not exist at runtime, there are no static variables associated with an open type. Two closed constructed types are the same type if they are constructed from the same unbound generic type and if their corresponding type arguments are the same type.

4.4.3 Bound and Unbound Types

The term unbound type refers to a nongeneric type or an unbound generic type. The term bound type refers to a nongeneric type or a constructed type.

An unbound type refers to the entity declared by a type declaration. An unbound generic type is not itself a type, and it cannot be used as the type of a variable, argument, or return value, or as a base type. The only construct in which an unbound generic type can be referenced is the typeof expression (§7.5.11).

4.4.4 Satisfying Constraints

Whenever a constructed type or generic method is referenced, the supplied type arguments are checked against the type parameter constraints declared on the generic type or method (§10.1.5). For each where clause, the type argument A that corresponds to the named type parameter is checked against each constraint as follows:

•  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, type A must be convertible to type C by one of the following means:

-  An identity conversion (§6.1.1)

-  An implicit reference conversion (§6.1.6)

-  A boxing conversion (§6.1.7), 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 criteria:

-  A is an interface type, class type, delegate type, or array type. Note that both 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 (§10.1.5).

•  If the constraint is the value type constraint (struct), the type A must satisfy one of the following criteria:

-  A is a struct type or enum type, but not a nullable type. Note that both System.ValueType and System.Enum are reference types that do not satisfy this constraint.

A is a type parameter having the value type constraint (§10.1.5).

•  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, because all value types have a public default constructor (§4.1.2).

-  A is a type parameter having the constructor constraint (§10.1.5).

-  A is a type parameter having the value type constraint (§10.1.5).

-  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 (§10.11.4).

A compile-time error will occur if one or more of a type parameter’s constraints are not satisfied by the given type arguments.

Because type parameters are not inherited, constraints are never inherited either. In the following example, D needs to specify the constraint on its type parameter T so that T satisfies the constraint imposed by the base class B<T>. In contrast, class E need not specify a constraint, because List<T> implements IEnumerable for any T.

        class B<T> where T: IEnumerable {…}
        class D<T>: B<T> where T: IEnumerable {…}
        class E<T>: B<List<T>> {…}

4.5 Type Parameters

A type parameter is an identifier designating a value type or reference type that the parameter is bound to at runtime.

      type-parameter:
            identifier

Because a type parameter can be instantiated with many different type arguments, type parameters have slightly different operations and restrictions than other types. These include the following criteria:

•  A type parameter cannot be used directly to declare a base class (§10.2.4) or interface (§13.1.3).

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

•  The available conversions for a type parameter depend on the constraints, if any, applied to the type parameter. They are detailed in §6.1.9 and §6.2.6.

•  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 (§6.1.9). However, a default expression (§7.5.13) can be used instead. In addition, a value with a type given by a type parameter can be compared with null using == and != (§7.9.6) unless the type parameter has the value type constraint.

•  A new expression (§7.5.10.1) can be used with a type parameter only if the type parameter is constrained by a constructor-constraint or the value type constraint (§10.1.5).

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

•  A type parameter cannot be used in a member access (§7.5.4) or type name (§3.8) to identify a static member or a nested type.

•  In unsafe code, a type parameter cannot be used as an unmanaged-type (§18.2).

As a type, type parameters are purely a compile-time construct. At runtime, each type parameter is bound to a runtime type that was specified by supplying a type argument to the generic type declaration. Thus, the type of a variable declared with a type parameter will, at runtime, be a closed constructed type (§4.4.2). The runtime execution of all statements and expressions involving type parameters uses the actual type that was supplied as the type argument for that parameter.

4.6 Expression Tree Types

Expression trees permit anonymous functions to be represented as data structures instead of executable code. Expression trees are values of expression tree types of the form System.Linq.Expressions.Expression<D>, where D is any delegate type. For the remainder of this specification, we will refer to these types using the shorthand Expression<D>.

If a conversion exists from an anonymous function to a delegate type D, a conversion also exists to the expression tree type Expression<D>. Whereas the conversion of an anonymous function to a delegate type generates a delegate that references executable code for the anonymous function, conversion to an expression tree type creates an expression tree representation of the anonymous function.

Expression trees are efficient in-memory data representations of anonymous functions. They make the structure of the anonymous function transparent and explicit.

Just like a delegate type D, Expression<D> is said to have parameter and return types, which are the same as those of D.

The following example represents an anonymous function both as executable code and as an expression tree. Because a conversion exists to Func<int,int>, a conversion also exists to Expression<Func<int,int>>.

        Func<int,int> d = x => x + 1;                                  // Code
        Expression<Func<int,int>> e = x => x + 1;          // Data

Following these assignments, the delegate d references a method that returns x + 1, and the expression tree e references a data structure that describes the expression x => x + 1.

The exact definition of the generic type Expression<D> as well as the precise rules for constructing an expression tree when an anonymous function is converted to an expression tree type are both outside the scope of this specification.

Two things are important to make explicit:

•  Not all anonymous functions can be represented as expression trees. For instance, anonymous functions with statement bodies and anonymous functions containing assignment expressions cannot be represented. In these cases, a conversion still exists, but it will fail at compile time.

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

        Func<int,int> f = e.Compile();

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

        int i1 = d(1);
        int i2 = f(1);

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