.NET Types

Explore the fundamental building blocks of the .NET ecosystem.

Understanding the various types of data structures and code constructs is crucial for effective .NET development. This section delves into the core type system of .NET, providing detailed information on classes, structs, enums, and more.

Classes

Classes are the fundamental building blocks of object-oriented programming in .NET. They define blueprints for objects, encapsulating data (fields) and behavior (methods).

Keywords: class, object, inheritance, polymorphism

class MyClass { public int MyProperty { get; set; } public MyClass(int value) { MyProperty = value; } public void Display() { Console.WriteLine($"Value: {MyProperty}"); } }

Key Concepts:

  • Encapsulation: Bundling data and methods that operate on that data.
  • Inheritance: Allowing new classes to inherit properties and methods from existing classes.
  • Abstraction: Hiding complex implementation details and exposing only essential features.
  • Polymorphism: The ability of an object to take on many forms.

Structs (Value Types)

Structs are lightweight types that represent single values. Unlike classes (reference types), structs are typically stored directly where they are declared (on the stack for local variables).

Keywords: struct, value type, stack allocation

struct Point { public int X; public int Y; public Point(int x, int y) { X = x; Y = y; } public override string ToString() => $"({X}, {Y})"; }

Key Concepts:

  • Value Semantics: When assigned or passed, the actual value is copied, not a reference.
  • Performance: Can offer performance benefits for small, frequently used data structures by avoiding heap allocations.
  • Immutability: Often designed to be immutable for predictable behavior.

Enums (Enumerations)

Enums provide a way to define a set of named constants, making code more readable and maintainable. They are based on an underlying integral type (defaulting to int).

Keywords: enum, named constants, integral type

enum Status { Pending = 0, Processing = 1, Completed = 2, Failed = 3 }

Key Concepts:

  • Readability: Replaces magic numbers with meaningful names.
  • Type Safety: Ensures that only valid enumerated values can be used.
  • Underlying Type: Can be specified (e.g., enum Status : byte).

Interfaces

Interfaces define a contract that classes or structs can implement. They specify a set of member signatures (methods, properties, events, indexers) without providing an implementation.

Keywords: interface, contract, abstraction, implementation

interface IAnimal { string Name { get; } void MakeSound(); } class Dog : IAnimal { public string Name { get; } = "Buddy"; public void MakeSound() => Console.WriteLine("Woof!"); }

Key Concepts:

  • Loose Coupling: Enables code to depend on abstractions rather than concrete implementations.
  • Multiple Inheritance of Type: A class can implement multiple interfaces.
  • Defining Behavior: Ensures that implementing types provide specific functionalities.

Delegates

Delegates are type-safe function pointers. They are used to define a signature for a method, allowing methods to be passed as arguments to other methods, or to be assigned to variables.

Keywords: delegate, event handler, callback, method signature

delegate void CalculationHandler(int x, int y); class Calculator { public event CalculationHandler OnCalculate; public void Add(int a, int b) { OnCalculate?.Invoke(a, b); } }

Key Concepts:

  • Event Handling: A core mechanism for implementing event-driven programming.
  • Callbacks: Passing methods to be executed later.
  • Type Safety: Ensures that only methods matching the delegate's signature can be assigned.

Other Important Types

  • Arrays: Fixed-size collections of elements of the same type.
  • Collections: Dynamic collections like List<T>, Dictionary<TKey, TValue>, etc.
  • Abstract Classes: Classes that cannot be instantiated directly and may contain abstract members.
  • Sealed Classes: Classes that cannot be inherited from.