Jaký je rozdíl mezi enum, struct a class?

Question

Accepted Answer

Jedná se o tři odlišné druhy typů v C#: **enum** (pojmenovaná sada konstantních hodnot), **struct** (hodnotový typ pro malá data) a **class** (referenční typ pro objekty). Správná volba závisí na datech a chování, která modelujete.

## enum — pojmenovaná sada konstant

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

**Enum** definuje pevnou sadu pojmenovaných hodnot — typově bezpečné konstanty pro věci jako stavy, role nebo možnosti (nahrazující kouzelná čísla/řetězce). Je to hodnotový typ podporovaný celým číslem.

## struct — hodnotový typ pro malá 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)
```

**Struct** je hodnotový typ — uložený inline (často na zásobníku), kopírovaný hodnotou, bez alokace na hromadě. Nejlepší pro **malé, neměnné, datům podobné** hodnoty (souřadnice, peníze, datum), kde sémantika hodnoty a vyhnutí se alokaci na hromadě pomáhají výkonu.

## class — referenční typ pro objekty

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

**Class** je referenční typ — na hromadě, kopírovaný odkazem (sdílený), podporuje dědičnost a bohaté chování. Výchozí volba pro většinu objektů s identitou, chováním a měnitelným stavem.

## Kdy použít co

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

## Proč na tom záleží

Volba správného druhu typu — enum, struct nebo class — je zásadní rozhodnutí v návrhu C# ovlivňující správnost, sémantiku a výkon, takže pochopení rozdílů je důležité. **Enums** poskytují typově bezpečné pojmenované konstanty (pro stavy, role, možnosti), o mnoho lepší než náchylná kouzelná čísla nebo řetězce — běžný a cenný modelovací nástroj.

Rozdíl **struct vs class** je obzvláště významný, protože určuje **sémantiku hodnoty vs reference**: structs jsou hodnotové typy (kopírované hodnotou, uložené inline, bez alokace na hromadě) vhodné pro malé neměnné datové hodnoty, kde sémantika hodnoty a snížená alokace pomáhají výkonu, zatímco classes jsou referenční typy (sdílené odkazem, alokovány na hromadě, podporující dědičnost a bohaté chování) — výchozí volba pro většinu objektů s identitou a chováním.

Nesprávná volba má reálné důsledky: velký struct je nákladný na kopírování a použití structu tam, kde se očekává sémantika reference (nebo naopak), způsobuje jemné chyby.

Pochopení kdy použít každý z nich — enum pro pevné sady konstant, struct pro malé datům podobné hodnoty (udržované v malé velikosti), class pro většinu objektů (výchozí volba) — a důsledky hodnoty vs reference je důležité vědění pro správné a efektivní modelování dat v C#.

Požívaje této volby se objevuje pokaždé, když definujete typ, a jelikož rozdíl hodnota/reference je základem tolik chování v C#, znalost rozdílů a vhodného použití enums, structs a classes je základní, často relevantní vědění a běžné téma rozhovoru odrážející pochopení systému typů C#.