Hvad er forskellen mellem en enum, en struct og en class?

Question

Accepted Answer

Disse er tre distinkte typetyper i C#: **enum** (et navngivet sæt af konstantværdier), **struct** (en værdityp for små data), og **class** (en referencetype for objekter). At vælge korrekt afhænger af de data og adfærd, du modellerer.

## enum — et navngivet sæt af konstanter

```csharp
public enum Status { Active, Inactive, Pending }   // named constants (Active=0, ...)

Status s = Status.Active;
if (s == Status.Active) { }                         // type-safe constants

public enum Permissions { Read = 1, Write = 2, Execute = 4 }   // [Flags] for bit flags
```

En **enum** definerer et fast sæt af navngivne værdier — typesikre konstanter for ting som tilstande, roller eller muligheder (erstatter magiske numre/strenge). Det er en værdityp backet af et heltal.

## struct — en værdityp for små data

```csharp
public struct Point          // VALUE type — copied by value, no heap allocation
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}
Point p1 = new(1, 2);
Point p2 = p1;               // COPIES the whole struct (independent)
```

En **struct** er en værdityp — gemt inline (ofte på stakken), kopieret efter værdi, ingen heap-allokering. Bedst til **små, immutable, data-lignende** værdier (koordinater, penge, en dato) hvor værdi-semantik og undgåelse af heap-allokering hjælper ydeevnen.

## class — en referencetype for objekter

```csharp
public class User            // REFERENCE type — on the heap, copied by reference
{
    public string Name { get; set; }
    public void DoWork() { }   // rich behavior
}
User u1 = new() { Name = "Ann" };
User u2 = u1;                // both reference the SAME object
```

En **class** er en referencetype — på heapen, kopieret efter reference (delt), understøtter arv og avanceret adfærd. Standardvalget for de fleste objekter med identitet, adfærd og ændelig tilstand.

## Hvornår skal man bruge hvilken

```text
enum   → a fixed set of named constants (states, roles, options)
struct → small, immutable data values; value semantics; avoid heap allocation
         (keep small — large structs are costly to copy)
class  → most objects: identity, behavior, inheritance, mutable/larger state (the default)
```

## Hvorfor det betyder noget

At vælge den rigtige typekind — enum, struct eller class — er en fundamental C#-designbeslutning, der påvirker korrekthed, semantik og ydeevne, så det er vigtigt at forstå forskellene. **Enums** giver typesikre navngivne konstanter (for tilstande, roller, muligheder), langt bedre end fejlbehæftede magiske numre eller strenge — et almindeligt, værdifuldt modelleringsværktøj.

Distinktionen **struct vs class** er særlig betydningsfuld, fordi den bestemmer **værdi vs reference-semantik**: structs er værditype (kopieret efter værdi, gemt inline, ingen heap-allokering) egnet til små immutable dataværdier hvor værdi-semantik og reduceret allokering hjælper ydeevnen, mens classes er referencetyper (delt efter reference, heap-allokeret, understøtter arv og avanceret adfærd) — standarden for de fleste objekter med identitet og adfærd.

At vælge forkert har virkelige konsekvenser: en stor struct er dyr at kopiere, og at bruge en struct hvor reference-semantik forventes (eller omvendt) forårsager subtile fejl.

At forstå hvornår man skal bruge hver enkelt — enum for faste konstantsæt, struct for små data-lignende værdier (holdt små), class for de fleste objekter (standarden) — og værdi-vs-reference-implikationerne er vigtig viden for at modellere data korrekt og effektivt i C#.

Da dette valg opstår hver gang du definerer en type, og da værdi/reference-distinktionen underligger så meget C#-adfærd, er kendskab til forskellene og passende brug af enums, structs og classes kerne, hyppigt relevant viden og et almindeligt interviewemne, der afspejler forståelse af C#'s typesystem.