Hvordan fungerer klasser, konstruktører og egenskaper?

Question

Accepted Answer

**Klasser** er grunnlaget for C#s objektorienterte modell — skjemaer for objekter, med **konstruktører** (initialiserer objekter) og **egenskaper** (kontrollert tilgang til data). C#s egenskapssyntaks er en karakteristisk, elegant funksjonalitet.

## En klasse med konstruktør og egenskaper

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

## Egenskaper — innkapsling 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
```

**Egenskaper** ser ut som felt, men er faktisk metoder (`get`/`set`) — som gir innkapsling (kontrollert tilgang, validering, beregnede verdier) med ren syntaks. Auto-egenskaper (`{ get; set; }`) håndterer det vanlige tilfellet uten boilerplate.

## Objektinitialisatorer og moderne funksjoner

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

Klasser, konstruktører og egenskaper er grunnlaget for objektorientert C# — praktisk talt all C#-kode er organisert i klasser, så å forstå dem er essensielt for enhver C#-utvikling.

Å vite hvordan man definerer klasser med konstruktører (initialiserer objekter) og metoder er grunnleggende, men C#s **egenskaper** er en særlig viktig og karakteristisk funksjonalitet som er verdt å forstå godt.

Egenskaper gir **innkapsling** elegant — de ser ut som felt, men er faktisk `get`/`set`-metoder, som tillater kontrollert tilgang, validering, beregnede verdier og tilgangsmodifikatorer (som `private set` eller `init`-bare) mens de opprettholder ren syntaks. **Auto-egenskaper** (`{ get; set; }`) håndterer det vanlige tilfellet med null boilerplate, noe som gjør innkapsling uanstrengt (ulikt språk hvor du skriver eksplisitte getter/setter-metoder).

Å forstå egenskaper (auto-egenskaper, egendefinert logikk, beregnede/skrivebeskyttede, `init`-bare for uforanderlighet), konstruktører, objektinitialisatorer og moderne bekvemmigheter (primære konstruktører) er kjernekunnskap som brukes daglig når man skriver godt innkapslet C#-klasser.

Siden klasser er hvordan du modellerer data og atferd gjennom C#-applikasjoner, og siden egenskaper er den idiomatiske, elegante måten C# håndterer innkapsling på (en karakteristisk språkfunksjonalitet som brukes hele tiden), er det å mestre disse — spesielt egenkapssystemet — grunnleggende, must-know-materiale for effektiv objektorientert C#-utvikling.