Wie funktionieren Klassen, Konstruktoren und Properties?

Question

Accepted Answer

**Klassen** sind die Grundlage von C#'s objektorientiertem Modell — Blueprints für Objekte mit **Konstruktoren** (initialisieren Objekte) und **Properties** (kontrollierter Zugriff auf Daten). C#'s Property-Syntax ist ein charakteristisches, elegantes Feature.

## Eine Klasse mit Konstruktor und Properties

```csharp
public class Person
{
    // auto-implemented PROPERTY — encapsulated access with get/set
    public string Name { get; set; }
    public int Age { get; private set; }      // settable only within the class
    public string Email { get; init; }          // set only during initialization (C# 9)

// CONSTRUCTOR
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

public string Greet() => $"Hi, I'm {Name}";   // a method
}

var person = new Person("Ann", 30);    // create an instance
person.Name = "Bob";                     // set a property
Console.WriteLine(person.Greet());
```

## Properties — Encapsulation elegant gemacht

```csharp
// auto-property (the common case) — compiler generates the backing field
public string Name { get; set; }

// property with custom logic
private decimal _balance;
public decimal Balance
{
    get => _balance;
    set => _balance = value >= 0 ? value : throw new ArgumentException();   // validation
}

// expression-bodied / computed property
public string FullName => $"{First} {Last}";   // read-only, computed
```

**Properties** sehen wie Felder aus, sind aber eigentlich Methoden (`get`/`set`) — die Encapsulation (kontrollierter Zugriff, Validierung, berechnete Werte) mit sauberer Syntax ermöglichen. Auto-Properties (`{ get; set; }`) behandeln den häufigen Fall ohne Boilerplate.

## Object Initializers und moderne Features

```csharp
var p = new Person("Ann", 30) { Email = "a@x.com" };   // object initializer

// primary constructor (C# 12) — concise constructor parameters
public class Point(int x, int y)
{
    public int X { get; } = x;
}
```

## Warum es wichtig ist

Klassen, Konstruktoren und Properties sind die Grundlage von objektorientiertem C# — praktisch aller C#-Code ist in Klassen organisiert, daher ist das Verständnis dafür essentiell für jede C#-Entwicklung.

Zu wissen, wie man Klassen mit Konstruktoren (Initialisierung von Objekten) und Methoden definiert, ist grundlegend, aber C#'s **Properties** sind ein besonders wichtiges und charakteristisches Feature, das es lohnt sich gut zu verstehen.

Properties bieten **Encapsulation** elegant — sie sehen wie Felder aus, sind aber eigentlich `get`/`set`-Methoden, die kontrollierten Zugriff, Validierung, berechnete Werte und Zugriffmodifizierer (wie `private set` oder `init`-only) ermöglichen, während sie die saubere Syntax bewahren. **Auto-Properties** (`{ get; set; }`) behandeln den häufigen Fall ohne jeglichen Boilerplate, wodurch Encapsulation mühelos wird (anders als in Sprachen, wo Sie explizite Getter-/Setter-Methoden schreiben).

Das Verständnis von Properties (Auto-Properties, benutzerdefinierte Logik, berechnete/Read-Only-Properties, `init`-only für Immutability), Konstruktoren, Object Initializern und modernen Funktionen (Primary Constructors) ist Basis-, alltägliches Wissen zum Schreiben von gut gekapselten C#-Klassen.

Da Klassen die Art sind, wie Sie Daten und Verhalten in C#-Anwendungen modellieren, und da Properties der idiomatische, elegante Weg sind, auf dem C# Encapsulation handhabt (ein charakteristisches Sprach-Feature, das ständig verwendet wird), ist die Beherrschung dieser Konzepte — besonders des Property-Systems — grundlegend notwendiges Wissen für effektive objektorientierte C#-Entwicklung.