X'inhi d-differenza bejn enum, struct u class?

Question

Accepted Answer

Dawn huma tliet tipi distinti f'C#: **enum** (sett imsemmi ta' valuri kostanti), **struct** (tip ta' valur għal data żgħira), u **class** (tip ta' referenza għal oġġetti). Għall-għażla t-tajba, jeħtieġ li tqis id-data u l-imġieba li qed tagħmel mudell tagħha.

## enum — sett imsemmi ta' kostanti

```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 jiddefinixi sett fisso ta' valuri imsemmija — kostanti siguri għat-tip għal affarijiet bħal stati, rwoli, jew għażliet (li jissostitwixxu numri/strings magic). Hija tip ta' valur appoġġat minn integer.

## struct — tip ta' valur għal data żgħira

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

A **struct** hija tip ta' valur — maħżuna inline (ħafna drabi fuq l-iskamb), ikkupjata b'valur, ebda allokazzjoni fil-heap. Aqwa għal valuri **żgħira, immutabbli, simili għad-data** (koordinati, flus, data) fejn il-valur-semantika u l-evitar tal-allokazzjoni fil-heap jgħinu l-prestazzjoni.

## class — tip ta' referenza għal oġġetti

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

A **class** hija tip ta' referenza — fuq il-heap, ikkupjata b'referenza (qasma), tappoġġa l-eredità u imġieba riċċa. L-għażla default għal ħafna oġġetti b'identità, imġieba, u stat muttevoli.

## Meta tuża liema

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

## Għaliex hu importanti

L-għażla ta' tip korrett — enum, struct, jew class — hija deċiżjoni fundamentali ta' disinn C# li taffettwa l-korrettezza, is-semantika, u l-prestazzjoni, allokka l-fehim tad-differenzi hu importanti. **Enums** jipprovdu kostanti imsemmija siguri għat-tip (għal stati, rwoli, għażliet), ħafna aħjar minn numri magic jew strings li ġenituri l-iżbalji — għodda ta' mudell komuni u ta' valur.

Id-distinzjoni **struct vs class** hija partikolarment sinifikanti minħabba li tiddefinixi **semantika ta' valur vs referenza**: structs huma tipi ta' valur (ikkupjati b'valur, maħżuna inline, ebda allokazzjoni fil-heap) adattati għal valuri żgħira immutabbli fejn is-semantika ta' valur u l-allokazzjoni riduċċa jgħinu l-prestazzjoni, filwaqt li classes huma tipi ta' referenza (ikkondivizi b'referenza, allokkati fil-heap, jappoġġu l-eredità u imġieba riċċa) — il-default għal ħafna oġġetti b'identità u imġieba.

L-għażla żbaljata għandha konsegwenzi reali: struct kbira hi għalja li tikpija, u l-użu ta' struct fejn is-semantika ta' referenza huwa mistenni (jew viċeversa) jikkawża bugs sottili.

L-fehim ta' meta tuża kull waħda — enum għal settijiet ta' kostanti fissi, struct għal valuri żgħira bħal data (miħfuża żgħira), class għal ħafna oġġetti (il-default) — u l-implikazzjonijiet ta' valur-vs-referenza hu għarfien importanti għall-mudell tad-data b'mod korrett u prestażzijonali f'C#.

Minħabba li l-għażla din tidher kull meta tdefinixi tip, u minħabba li d-distinzjoni valur/referenza hija bażi għal ħaffa mill-imġieba ta' C#, l-għarfien tad-differenzi u l-użu xieraq ta' enums, structs, u classes hu għarfien essenzjali, rellevan ta' spiss, u suġġett ta' intervista komuni li jirrifletti l-fehim tas-sistema ta' tipi ta' C#.