Koks yra skirtumas tarp reikšmės ir nuorodos tipų?

Question

Accepted Answer

C# tipai skirstomi į dvi pagrindines kategorijas: **reikšmės tipai** (tiesiogiai saugantys duomenis) ir **nuorodos tipai** (saugantys nuorodą/rodyklę į duomenis heap'e). Jie skiriasi tuo, kaip jie saugomi, kopijuojami ir lyginami — tai yra esmingas skirtumas, turintis įtakos elgesiui visoje kalboje.

## Dvi kategorijos

```text
Value types     → struct, int, double, bool, char, enum, DateTime, decimal
                  Stored INLINE (stack for locals); copied BY VALUE.
Reference types → class, string, array, object, interface, delegate
                  Variable holds a REFERENCE to data on the heap; copied BY REFERENCE.
```

## Pagrindinis skirtumas: kopijavimo semantika

```csharp
// VALUE type — assignment COPIES the value (independent)
int a = 5;
int b = a;      // b is a COPY
b = 10;         // a is still 5

struct Point { public int X; }
Point p1 = new() { X = 1 };
Point p2 = p1;  // COPIES the whole struct
p2.X = 99;      // p1.X is still 1

// REFERENCE type — assignment copies the REFERENCE (both point to the SAME object)
class Box { public int Value; }
Box box1 = new() { Value = 1 };
Box box2 = box1;   // both reference the SAME Box
box2.Value = 99;   // box1.Value is now 99 too!
```

Reikšmės tipo priskyrimas kopijuoja duomenis (nepriklausomi); nuorodos tipo priskyrimas kopijuoja nuorodą (abi vardai rodo į tą patį objektą, todėl mutavimas per vieną veikia kitą).

## Lyginimas ir perdavimas metodams

```csharp
// == compares VALUES for value types, REFERENCES (identity) for reference types
string s1 = "hi"; // (string is special — == compares content)
Box b1 = new(), b2 = new();
b1 == b2;   // false — different objects (reference equality by default)

// methods get a COPY of value types, the reference (by value) for reference types
void Modify(Box b) { b.Value = 100; }   // affects the caller's object
void Modify(int x) { x = 100; }           // does NOT affect the caller's int
```

## null

```text
Reference types can be null (no object). Value types CANNOT be null
(unless made nullable: int? — a Nullable<int>).
```

## Kodėl tai svarbu

Reikšmės ir nuorodos skirtumas yra viena iš pačių pagrindinių C# sąvokų ir paaiškina įvairią elgesį bei klaidas — todėl tai būtina žinoti.

Svarbu suprasti, kad **reikšmės tipai** (struct, primityvai kaip int/double, enum'ai) kopijuojami pagal reikšmę (nepriklausos kopijos), o **nuorodos tipai** (klasės, masyvai, eilutės) kopijuojami pagal nuorodą (abi vardai rodo į tą patį objektą). Tai būtina suvokti, kad numatyti, kaip duomenys elgiasi: reikšmės tipo kopijos modifikavimas neveikia originalo, tačiau bendro nuorodos tipo objekto mutavimas veikia visas jo nuorodas (dažnas netikėtų klaidų šaltinis).

Šis skirtumas taip pat veikia **lygybę** (`==` reikšmės tipams lygina reikšmes, o nuorodos tipams pagal numatymasą lygina nuorodos identitetą), **metodo argumentus** (reikšmės tipai perduodami kaip kopijos, nuorodos tipų nuorodos perduodamos pagal reikšmę — todėl metodai gali mutavinti paduotą objektą, bet ne paduotą int), ir **null galimybę** (tik nuorodos tipai gali būti null, nebent reikšmės tipas padaromas nullable su `?`).

Supratimas, kurie tipai yra reikšmės prieš nuorodą ir iš to kylanti kopijavimo, palyginimo ir mutavimo semantika yra pagrindinis dalykas rašant teisingą C# ir venging dažniausių kalbos konceptualių klaidų — tai grindžia, kaip duomenys teka per programą, ir dažna pokalbio tema, nes ji atskleidžia, ar kūrėjas tikrai supranta C# tipo sistemą.