C# Types and Type Safety

• C# is a strongly typed language meaning every variable, constant, and expression has a specific type
• Method declarations include the name, type, and kind (value, reference, or output) for each input parameter and the return value
• The .NET class library offers built-in numeric and complex types representing various constructs like file systems, network connections, collections, arrays, objects, and dates
• C# programs use types from the class library, and user-defined types specific to the program's problem domain

Type Information

The information stored in a type includes:

• Storage space required
• Maximum and minimum representable values
• Members (methods, fields, events, etc.)
• Base type inheritance
• Implemented interfaces
• Permitted operations

Type Safety

• The compiler uses type information to ensure type safety
• Declaring a variable as int allows addition and subtraction
• Performing those operations on a bool variable results in a compiler error
• bool is not convertible to int in C#

Variable Declarations

• Specify the type of a variable/constant or use the var keyword for compiler inference
• Method parameters and return values are specified in the method declaration
• Redeclaring with a new type or assigning incompatible values is prohibited, though conversion to other types is possible

Metadata and Type Safety

• The compiler embeds type information into the executable file as metadata for the common language runtime (CLR) guarantees type safety during memory allocation and reclamation

Built-In Types

• C# offers a standard set of built-in types, including integers, floating-point values, Booleans, text characters, decimal values, strings, and object types

Custom Types

• Custom types are created using struct, class, interface, enum, and record constructs
• The .NET class library offers custom types for applications
• Most frequently used types are available by default, others require a project reference to their defining assembly
• After a project reference you can declare variables and constants from the types declared

Choosing a Construct

The decision on which construct to use depends on:

• Small data storage size (under 64 bytes): use a struct or record struct
• Immutability or nondestructive mutation: use a struct or record struct
• Value semantics for equality: use a record class or record struct
• Primary use for data storage (not behavior): use a record class or record struct
• Part of an inheritance hierarchy: use a record class or a class
• Use of polymorphism: use a class
• Primary purpose is behavior: use a class

Common Type System (CTS)

• Two fundamental points: inheritance and type definition (value or reference)
• Types inherit from other types, called base types, inheriting methods, properties, and members
• Base types can derive from other types, forming an inheritance hierarchy

Inheritance and CTS

• All types, including built-in numeric types like System.Int32 (C# keyword: int), derive from System.Object (C# keyword: object)
• This unified hierarchy is the Common Type System (CTS)

Value Types vs. Reference Types:

• Value types are defined using the struct keyword (built-in numeric types)
• Reference types are defined using the class or record keyword
• They have different compile-time rules and run-time behavior

Namespace Organization

• Commonly used types are organized in the System namespace
• Namespace containment doesn't imply value or reference type

Classes and Structs

• Classes and structs are basic constructs that encapsulate data and behaviors as a logical unit, including methods, properties, and events
• Declarations of class, struct, or record serve as a blueprint for objects at run time

Class Instances

• If you define a class, struct, or record named Person, Person is the name of the type
• Declaring and initializing variable p of type Person creates an object or instance of Person.
• Multiple instances can be created with different values in their properties and fields

Class as Reference Type

• Classes are reference types: the variable holds a reference to memory
• Assigning the object reference to a new variable means both variables refer to the original object, so changes through one affect the other

Struct as Value Type

• Structs are value types: the variable stores the actual data
• Assigning a struct to a new variable copies the data so, changes to one copy do not affect the other

Record Type

• Record can be a reference or value type
• Record supports equality

Classes vs Structs vs Records

• Classes model complex behavior and store data intended for modification
• Structs suit small data structures not intended for modification
• Records are data structures with compiler-synthesized members, also for data not post-creation modification

Value Type Characteristics

• Value types derive from System.ValueType, which derives from System.Object, with special CLR behavior
• Value type variables directly contain their values
• Memory for a struct is allocated inline; no separate heap allocation or garbage collection overhead, can include synthesized members for records

Value Type Categories

• The two categories of value types are struct and enum
• Built-in numeric types are structs with accessible fields and methods
• You cannot derive from a value type, such as System.Int32, or inherit from user-defined classes or structs
• A struct can only inherit from System.ValueType

Struct Usage

• Structs can implement interfaces, which causes a boxing operation when casting to an interface type
• Boxing wraps the struct inside a reference type object on the managed heap

Struct as Container

• A struct serves as a container for related variables

Enums

• Enums define a set of named integral constants; for example, System.IO.FileMode
• Using enumerations is better than using constant literal numbers for readability

Enum Inheritance

• All enums inherit from System.Enum, inheriting from System.ValueType
• All struct rules apply to enums

Reference Type Details

• A type defined as a class, record, delegate, array, or interface is a reference type

Null Values

• Reference type variables contain null until assigned an instance using the new operator

Memory Management

• Objects are created allocating memory on a managed heap
• Variables only hold memory location references
• Types on the managed heap require resources for both allocation and later reclamation
• Garbage collection is automatic memory reclamation

Arrays

• Arrays are reference types even if their elements are value types
• Arrays derive from the System.Array class
• Elements are accessed using a simplified syntax in C#

Inheritance

• Reference types fully support inheritance. Classes can inherit from other classes or interfaces that aren't sealed
• Overriding virtual methods is possible
• Types can be declared with one or more type parameters that act as placeholders for the actual type, these are called generic types

Generic Types

• Code provides the concrete type on creating an existing type
• When the type is created you specify what objects the list contains for strings
• This is possible because the parameters allows the same class to hold any time of element without having to convert each element to object

Literal Value Typing

• Literal values in C# receive a type from the compiler automatically
• Numeric literals can be typed by appending a letter (e.g., "f" or "F" for float)
• Literals are typed and derive from System.Object

Implicit Typing

• Local variables can be implicitly typed using the var keyword, with the type determined by the compiler

Anonymous Types

• Anonymous types are used for simple sets of related values that won't leave method boundaries

Nullable Value Types

• Ordinary value types can't be null
• They can append a ? after the type (e.g., int?) can be assigned null
• They help when passing to and from datebases in which numeric values might be null

Compile-Time vs. Run-Time Types

• A variable can have different compile-time and run-time types
• The compile-time type, declared, or inferred is in the source code
• The action applies to which type, recognizing how types interact with your code

Overview of types and type safety in C#. This includes a discussion of method declarations and .NET class library types. Also covers information stored in a type and how the compiler ensures type safety.