Hva er forskjellen mellom en enum, en struct og en class?

Question

Accepted Answer

Disse er tre distinkte typer i C#: **enum** (et navngitt sett med konstante verdier), **struct** (en verditype for små data), og **class** (en referansetype for objekter). Riktig valg avhenger av dataene og oppførselen du modellerer.

## enum — et navngitt sett med 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 sett med navngitte verdier — typesikre konstanter for ting som tilstander, roller eller alternativer (som erstatter magiske tall/strenger). Det er en verditype støttet av et heltall.

## struct — en verditype 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 verditype — lagret inline (ofte på stakken), kopiert etter verdi, ingen heap-allokering. Best for **små, uforanderlige, dataliknende** verdier (koordinater, penger, en dato) der verdiSemantics og unngåelse av heap-allokering hjelper ytelsen.

## class — en referansetype 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 referansetype — på heapen, kopiert etter referanse (delt), støtter arv og rik oppførsel. Standardvalget for de fleste objekter med identitet, oppførsel og foranderlig tilstand.

## Når du skal bruke 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 er viktig

Å velge riktig type — enum, struct eller class — er en fundamental C#-designbeslutning som påvirker korrekthet, semantikk og ytelse, så det er viktig å forstå forskjellene. **Enums** gir typesikre navngitte konstanter (for tilstander, roller, alternativer), langt bedre enn feilutsatte magiske tall eller strenger — et vanlig, verdifullt modelleringsverktøy.

Forskjellen **struct vs class** er spesielt betydningsfull fordi den bestemmer **verdi- vs referansesemantics**: structs er verdityper (kopiert etter verdi, lagret inline, ingen heap-allokering) egnet for små uforanderlige dataverdier der verdiSemantics og redusert allokering hjelper ytelsen, mens classes er referansetyper (delt etter referanse, heap-allokert, støtter arv og rik oppførsel) — standarden for de fleste objekter med identitet og oppførsel.

Å velge feil har reelle konsekvenser: en stor struct er kostbar å kopiere, og å bruke en struct hvor referansesemantics forventes (eller omvendt) forårsaker subtile bugs.

Å forstå når du skal bruke hver — enum for faste konstante sett, struct for små dataliknende verdier (holdt små), class for de fleste objekter (standarden) — og implikasjonene for verdi-vs-referanse er viktig kunnskap for å modellere data korrekt og effektivt i C#.

Siden dette valget dukker opp når du definerer en type, og siden verdi/referanse-distinksjonen ligger til grunn for så mye C#-oppførsel, er det å kjenne forskjellene og passende bruk av enums, structs og classes kjernekunnskap som er hyppig relevant og et vanlig intervjuemne som gjenspeiler forståelse av C#s typesystem.