Common Type System


In Microsoft's.NET Framework, the Common Type System is a standard that specifies how type definitions and specific values of types are represented in
computer memory. It is intended to allow programs written in different programming languages to easily share information. As used in programming languages, a type can be described as a definition of a set of values, and the allowable operations on those values.
The specification for the CTS is contained in Ecma standard 335, "Common Language Infrastructure Partitions I to VI." The CLI and the CTS were created by Microsoft, and the Microsoft.NET framework is an implementation of the standard.

Functions of the Common Type System

When rounding fractional values, the halfway-to-even method is used by default, throughout the Framework. Since version 2, "Symmetric Arithmetic Rounding" is also available by programmer's option.
The common type system supports two general categories of types:
;Value types : Value types directly contain their data, and instances of value types are either allocated on the stack or allocated inline in a structure. Value types can be built-in, user-defined, or enumerations.
;Reference types : Reference types store a reference to the value's memory address, and are allocated on the heap. Reference types can be self-describing types, pointer types, or interface types. The type of a reference type can be determined from values of self-describing types. Self-describing types are further split into arrays and class types. The class types are user-defined classes, boxed value types, and delegates.
The following example written in Visual Basic.NET shows the difference between reference types and value types:

Imports System
Class Class1
Public Value As Integer = 0
End Class 'Class1
Class Test
Shared Sub Main
Dim val1 As Integer = 0
Dim val2 As Integer = val1
'Coded By
val2 = 123
Dim ref1 As New Class1
Dim ref2 As Class1 = ref1
ref2.Value = 123
Console.WriteLine
Console.WriteLine
End Sub 'Main
End Class 'Test

The output of the above example
Values: 0, 123
Refs: 123, 123

Boxing and unboxing

Boxing

Converting value types to reference types is also known as boxing. As can be seen in the example below, it is not necessary to tell the compiler an Int32 is boxed to an object, because it takes care of this itself.

Int32 x = 10;
object o = x ; // Implicit boxing
Console.WriteLine; // prints out "The Object o = 10"

However, an Int32 can always be explicitly boxed like this:

Int32 x = 10;
object o = x; // Explicit boxing
Console.WriteLine; // prints out "The object o = 10"

Unboxing

The following example intends to show how to unbox a reference type back to a value type. First an Int32 is boxed to an object, and then it is unboxed again. Note that unboxing requires explicit cast.

Int32 x = 5;
object o1 = x; // Implicit Boxing
x = o1; // Explicit Unboxing