The authors of The C# Programming Language discuss value types, reference types, and pointers.



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.

type: value-type reference-type type-parameter

A third category of types, pointers, is available only in unsafe code. This issue is 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 thus possible for operations on one variable to affect the object referenced by the other variable. With value types, the variables each have their own copy of the data, so it is not possible for operations on one 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).

Eric Lippert We normally do not think of interface types or the types associated with type parameters as having a “base class” per se. What this discussion is getting at is that every concrete object—no matter how you are treating it at compile time—may be treated as an instance of object at runtime.

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 the 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, and value types are thus 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.

Eric Lippert This point is frequently confusing to novices. I am often asked, “But how is it possible that a value type derives from a reference type?” I think the confusion arises as a result of a misunderstanding of what “derives from” means. Derivation does not imply that the layout of the bits in memory of the base type is somewhere found in the layout of bits in the derived type. Rather, it simply implies that some mechanism exists whereby members of the base type may be accessed from the derived type.

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 .

, the default value is , converted to the type . For a struct-type, the default value is the value produced by setting all value type fields to their default values and all reference type fields to null . Vladimir Reshetnikov Obviously, the wording “all fields” here means only instance fields (not static fields). It also includes field-like instance events, if any exist.

. 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 example below, 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).

Eric Lippert Another good way to obtain the default value of a type is to use the default(type) expression.

Jon Skeet This is one example of where the C# language and the underlying platform may have different ideas. If you ask the .NET platform for the constructors of a value type, you usually won’t find a parameterless one. Instead, .NET has a specific instruction for initializing the default value for a value type. Usually these small impedence mismatches have no effect on developers, but it’s good to know that they’re possible—and that they don’t represent a fault in either specification.

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 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. 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. Eric Lippert The “most” in the phrase “most simple types” refers to the fact that some simple types, such as short , have no literal form. In reality, any integer literal small enough to fit into a short is implicitly converted to a short when used as one, so in that sense there are literal values for all simple types. There are a handful of possible values for simple types that have no literal forms. The NaN (Not-a-Number) values for floating point types, for example, have no literal form.

is a literal of type and is a literal of type . 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.19). Expressions involving operators defined by other struct types are not considered to be constant expressions. Vladimir Reshetnikov It is not just “possible”: The compiler always does fully evaluate constant-expressions at compile time.

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.

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

Joseph Albahari The simple types also provide a means by which the compiler can leverage direct support within the IL (and ultimately the processor) for computations on integer and floating point values. This scheme allows arithmetic on simple types that have processor support (typically float , double , and the integral types) to run at native speed.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Jesse Liberty I have to confess that with the power of modern PCs, and the greater cost of programmer time relative to the cost of memory, I tend to use int for just about any integral (nonfractional) value and double for any fractional value. All the rest, I pretty much ignore.

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 .

and ~ operators, the operand is converted to type , where is the first of , , , and that can fully represent all possible values of the operand. The operation is then performed using the precision of type , and the type of the result is . 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 .

operator, the operand is converted to type , where is the first of and that can fully represent all possible values of the operand. The operation is then performed using the precision of type , and the type of the result is . The unary operator cannot be applied to operands of type . 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.

, , , , , , , , , , , , , and operators, the operands are converted to type , where is the first of , , , and that can fully represent all possible values of both operands. The operation is then performed using the precision of type , and the type of the result is (or for the relational operators). It is not permitted for one operand to be of type and the other to be of type 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.

type. In particular, even though the , , and types have ranges of values that are fully representable using the type, implicit conversions from , , or to 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.6.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.8.2). Vladimir Reshetnikov Be aware that the default implementation of the Equals method in value types can use bitwise comparison in some cases to speed up performance. If two instances of your value type contain in their fields positive and negative zero, respectively, they can compare as not equal. You can override the Equals method to change the default behavior. using System; struct S { double X; static void Main() { var a = new S {X = 0.0}; var b = new S {X = -0.0}; Console.WriteLine(a.X.Equals(b.X)); // True Console.WriteLine(a.Equals(b)); // False } } Peter Sestoft Some of the confusion over negative zero may stem from the fact that the current implementations of C# print positive and negative zero in the same way, as 0.0 , and no combination of formatting parameters seems to affect that display. Although this is probably done with the best of intentions, it is unfortunate. To reveal a negative zero, you must resort to strange-looking code like this, which works because 1/(-0.0) = -Infinity < 0 : public static string DoubleToString(double d) { if (d == 0.0 && 1/d < 0) return "-0.0"; else return d.ToString(); }

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.

yields positive infinity, and 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. Peter Sestoft A large number of distinct NaNs exist, each of which has a different “payload.” See the annotations on §7.8.1.

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 × 2e, where s is 1 or –1, and m and e are determined by the particular floating point type: For float , 0 < m < 224 and –149 ≤ e ≤ 104; for double , 0 < m < 253 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–45 to 3.4 × 1038 with a precision of 7 digits.

The double type can represent values ranging from approximately 5.0 × 10–324 to 1.7 × 10308 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).

, the other operand is converted to , the operation is performed using at least range and precision, and the type of the result is (or 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 below:

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

Joseph Albahari NaNs are sometimes used to represent special values. In Microsoft’s Windows Presentation Foundation, double.NaN represents a measurement whose value is “automatic.” Another way to represent such a value is with a nullable type; yet another is with a custom struct that wraps a numeric type and adds another field.

4.1.7 The decimal Type

The decimal type is a 128-bit data type suitable for financial and monetary calculations. The decimal type can represent values ranging from 1.0 × 10–28 to approximately 7.9 × 1028 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 < 296, 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 decimal s with an absolute value less than 1.0m , the value is exact to the 28th decimal place, but no further. For decimal s with an absolute value greater than or equal to 1.0m , the value is exact to 28 or 29 digits. Unlike with the float and double data types, decimal fractional numbers such as 0.1 can be represented exactly in the decimal representation. In the float and double representations, such numbers are often infinite fractions, making those representations more prone to round-off errors.

Peter Sestoft The IEEE 754-2008 standard describes a decimal floating point type called decimal128 . It is similar to the type decimal described here, but packs a lot more punch within the same 128 bits. It has 34 significant decimal digits, a range from 10-6134 to 106144, and supports NaNs. It was designed by Mike Cowlishaw at IBM UK. Since it extends the current decimal in all respects, it would seem feasible for C# to switch to IEEE decimal128 in some future version.

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.

Bill Wagner You cannot mix decimal and the floating point types ( float , double ). This rule exists because you would lose precision mixing computations between those types. You must apply an explicit conversion when mixing decimal and floating point types.

The result of an operation on values of type decimal is what 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 and, when a result is equally close to two representable values, to the value that has an even number in the least significant digit position (this is known as “banker’s rounding”). A zero result always has a sign of 0 and a scale of 0.

Eric Lippert This method has the attractive property that it typically introduces less bias than methods that always round down or up when there is a “tie” between two possibilities. Oddly enough, despite the nickname, there is little evidence that this method of rounding was ever in widespread use in banking.

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 , and without explicit casts, it is not possible to mix floating point and decimal operands in the same expression.

Eric Lippert C# does not support the Currency data type familiar to users of Visual Basic 6 and other OLE Automation-based programming languages. Because decimal has both more range and precision than Currency , anything that you could have done with a Currency can be done just as well with a decimal .

4.1.8 The bool Type

The bool type represents boolean logical quantities. The 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; 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 , and 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 .

Chris Sells The inability of a non- bool to be converted to a bool most often bites me when comparing for null . For example: object obj = null; if( obj ) { ... } // Okay in C/C++, error in C# if( obj != null ) { ... } // Okay in C/C++/C#

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

Eric Lippert This is an important point: Nothing stops you from putting a value that is not in the enumerated type into a variable of that type. Do not rely on the language or the runtime environment to verify that instances of enumerated types are within the bounds you expect.

Vladimir Reshetnikov The CLR also supports char as an underlying type of an enumeration. If you happen to reference an assembly containing such a type in your application, the C# compiler will not recognize this type as an enumeration and will not allow you, for example, to convert it to or from an integral type.

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, conversely, 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

property of type 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.