Hvordan fungerer klasser, konstruktører og egenskaber?

Question

Accepted Answer

**Klasser** er grundlaget for C#'s objektorienterede model — skabeloner for objekter, med **konstruktører** (initialiserer objekter) og **egenskaber** (kontrolleret adgang til data). C#'s egenskabssyntaks er en karakteristisk, elegant funktion.

## En klasse med konstruktør og egenskaber

```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());
```

## Egenskaber — indkapsling gjort elegant

```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
```

**Egenskaber** ser ud som felter, men er faktisk metoder (`get`/`set`) — hvilket giver indkapsling (kontrolleret adgang, validering, beregnede værdier) med ren syntaks. Auto-egenskaber (`{ get; set; }`) håndterer det almindelige tilfælde uden boilerplate.

## Objektinitialiserere og moderne funktioner

```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;
}
```

## Hvorfor det betyder noget

Klasser, konstruktører og egenskaber er grundlaget for objektorienteret C# — praktisk talt al C#-kode er organiseret i klasser, så det er afgørende at forstå dem for al C#-udvikling.

At vide, hvordan man definerer klasser med konstruktører (initialisering af objekter) og metoder, er grundlæggende, men C#'s **egenskaber** er en særligt vigtig og karakteristisk funktion, som det er værd at forstå godt.

Egenskaber giver **indkapsling** på elegant vis — de ser ud som felter, men er faktisk `get`/`set`-metoder, der muliggør kontrolleret adgang, validering, beregnede værdier og adgangsmodifikatorer (som `private set` eller `init`-kun) samtidig med at syntaksen forbliver ren. **Auto-egenskaber** (`{ get; set; }`) håndterer det almindelige tilfælde helt uden boilerplate, hvilket gør indkapsling ubesværet (i modsætning til sprog, hvor du skriver eksplicitte getter-/setter-metoder).

At forstå egenskaber (auto-egenskaber, brugerdefineret logik, beregnede/skrivebeskyttede, `init`-kun for uforanderlighed), konstruktører, objektinitialiserere og moderne bekvemmeligheder (primære konstruktører) er grundlæggende, daglig viden for at skrive velindkapslet C#-klasser.

Da klasser er hvordan du modellerer data og adfærd i hele C#-applikationer, og da egenskaber er den idiomatiske, elegante måde, C# håndterer indkapsling på (en karakteristisk sprogfunktion, der bruges konstant), er det at mestre disse — især egenskabssystemet — grundlæggende, uundværligt materiale for effektiv objektorienteret C#-udvikling.