Wat is het verschil tussen een enum, een struct en een class?

Question

IT Interview Practice · Accepted Answer

Dit zijn drie verschillende soorten types in C#: **enum** (een benoemde set van constant waarden), **struct** (een value type voor kleine gegevens), en **class** (een reference type voor objecten). Het kiezen van de juiste optie hangt af van de gegevens en het gedrag dat je modelleert.

## enum — een benoemde set van constanten

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

Een **enum** definieert een vaste set benoemde waarden — type-veilige constanten voor dingen zoals toestanden, rollen of opties (ter vervanging van magische nummers/strings). Het is een value type ondersteund door een integer.

## struct — een value type voor kleine gegevens

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

Een **struct** is een value type — opgeslagen inline (vaak op de stack), gekopieerd per waarde, geen heap-toewijzing. Het beste voor **kleine, onveranderbare, data-achtige** waarden (coördinaten, geld, een datum) waar value semantiek en het voorkomen van heap-toewijzing de prestaties helpen.

## class — een reference type voor objecten

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

Een **class** is een reference type — op de heap, gekopieerd per referentie (gedeeld), ondersteunt overerving en rijk gedrag. De standaardkeuze voor de meeste objecten met identiteit, gedrag en veranderlijke toestand.

## Wanneer welke gebruiken

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

## Waarom het belangrijk is

Het kiezen van het juiste soort type — enum, struct of class — is een fundamentele C# designbeslissing die correctheid, semantiek en prestaties beïnvloedt, dus het begrijpen van de verschillen is belangrijk. **Enums** bieden type-veilige benoemde constanten (voor toestanden, rollen, opties), veel beter dan foutgevoelige magische nummers of strings — een veel gebruikte, waardevolle modelleringstool.

Het onderscheid **struct versus class** is vooral significant omdat het bepaalt **value versus reference semantiek**: structs zijn value types (gekopieerd per waarde, opgeslagen inline, geen heap-toewijzing) geschikt voor kleine onveranderbare gegevenswaarden waar value semantiek en verminderde toewijzing de prestaties helpen, terwijl classes reference types zijn (gedeeld per referentie, heap-toegewezen, ondersteunt overerving en rijk gedrag) — de standaard voor de meeste objecten met identiteit en gedrag.

Verkeerd kiezen heeft echte gevolgen: een grote struct is duur om te kopiëren, en het gebruik van een struct waar reference semantiek wordt verwacht (of vice versa) veroorzaakt subtiele bugs.

Begrijpen wanneer je elk soort gebruikt — enum voor vaste constantensets, struct voor kleine data-achtige waarden (klein gehouden), class voor de meeste objecten (de standaard) — en de value-versus-reference implicaties is belangrijke kennis voor het correct en efficiënt modelleren van gegevens in C#.

Omdat deze keuze verschijnt telkens wanneer je een type definieert, en omdat het value/reference onderscheid zoveel C# gedrag ten grondslag ligt, is het kennen van de verschillen en passend gebruik van enums, structs en classes kernkennis die relevant is en veel voorkomt in interviews, wat het begrip van C#'s type system weerspiegelt.

enum — een benoemde set van constanten

struct — een value type voor kleine gegevens

class — een reference type voor objecten

Wanneer welke gebruiken

Waarom het belangrijk is

Gerelateerde vragen