CLR Types - MSDN Documentation

Understanding Types in the Common Language Runtime (CLR)

The Common Language Runtime (CLR) is the execution engine of the .NET Framework. It provides the managed execution environment and services that are essential for the operation of .NET applications. A fundamental concept within the CLR is the management and definition of data types.

Value Types vs. Reference Types

The CLR broadly categorizes types into two main groups: value types and reference types. This distinction significantly impacts how data is stored, accessed, and passed between methods.

Value Types

Value types contain their data directly. When a value type is declared, it allocates memory for the value itself. Variables of value types directly hold their values.

Examples: Primitive types like int, float, bool, char, and user-defined types declared using the struct keyword.
Storage: Typically stored on the stack.
Assignment: When assigned to another variable, the entire value is copied.
Default Value: Automatically initialized to a default value (e.g., 0 for numeric types, false for booleans) if not explicitly initialized.

Consider the following example:

int x = 10;
int y = x; // y gets a copy of x's value
y = 20;    // x remains 10, y is 20

Reference Types

Reference types do not store their data directly. Instead, they store a reference (or pointer) to the location of the data in memory (the heap).

Examples: Classes (class), interfaces (interface), delegates (delegate), arrays, and strings.
Storage: The data is stored on the managed heap, and the variable holds a reference to that data.
Assignment: When assigned to another variable, only the reference is copied, meaning both variables point to the same object on the heap.
Default Value: The default value for reference types is null, indicating that they do not currently refer to any object.

Consider the following example:

MyClass obj1 = new MyClass();
MyClass obj2 = obj1; // obj2 now points to the same object as obj1
obj2.SomeProperty = "New Value"; // This change is visible through obj1 as well

Common Type System (CTS)

The CLR defines the Common Type System (CTS), which specifies a set of types that can be defined and used by all languages targeting the .NET Framework. The CTS ensures that types defined in one .NET language can be understood and used by types defined in another .NET language.

Type Definitions

Types are defined using various keywords and constructs in .NET languages:

Classes: Define blueprints for objects, encapsulating data and behavior.
Structs: Similar to classes but are value types. They are typically used for small, data-centric types.
Interfaces: Define a contract that classes or structs must implement, specifying methods, properties, events, and indexers without providing an implementation.
Enums: Define a set of named constants.
Delegates: Type-safe function pointers, enabling event handling and callback mechanisms.
Arrays: Collections of elements of the same type.

Type Safety

The CLR enforces type safety at runtime. This means that operations on objects are checked to ensure they are valid for the object's type, preventing common programming errors and enhancing application stability.