Cili është ndryshimi midis tipeve me vlerë dhe tipeve me referencë?

Question

Accepted Answer

Tipet në C# bien në dy kategori themelore: **tipet me vlerë** (ruajnë të dhënat drejtpërdrejtë) dhe **tipet me referencë** (ruajnë një referencë/tregues në të dhënat në heap). Ato ndryshojnë në mënyrën se si ruhen, kopjohen dhe krahasohen — një dallim vendimtar që ndikon në sjellje në të gjithë gjuhën.

## Dy kategorit

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

## Ndryshimi kyç: semantika e kopjimit

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

Përcaktimi i një tipi me vlerë e kopjon të dhënat (të pavarur); përcaktimi i një tipi me referencë e kopjon referencën (të dy emrat tregojnë në të njëjtin objekt, kështu që mutacioni përmes njërit ndikon në tjetrin).

## Krahasimi dhe kalimi në metoda

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

## Pse ka rëndësi

Makiyaja midis vlerës dhe referencës është një nga konceptet më themelore në C#, dhe ajo shpjegon një gamë të gjerë sjelljesh dhe gabimesh — duke e bërë atë njohuri thelbësore.

Përkuptimi që **tipet me vlerë** (struct, primitiva si int/double, enum) kopjohen sipas vlerës (kopje të pavarura) ndërsa **tipet me referencë** (klasat, vargjet, stringjet) kopjohen sipas referencës (të dy emrat tregojnë në të njëjtin objekt) është vendimtar për parashikimin se si sillet të dhënat: ndryshimi i një kopjeje të tipit me vlerë nuk prek origjinalin, por mutacioni i një objekti të referecës të ndarë ndikon në të gjitha referencat në të (një burim i zakonshëm i gabimeve në befasi).

Ky dallim ndikon edhe në **barazimin** (`==` krahason vlerat për tipet me vlerë por identitetin e referencës për tipet me referencë si parazgjedhje), **argumentet e metodave** (tipet me vlerë kalojnë si kopje, referencat e tipeve me referencë kalojnë sipas vlerës — kështu metodat mund të ndryshojnë një objekt të kaluar por jo një int të kaluar), dhe **nullabilitetin** (vetëm tipet me referencë mund të jenë null, përveç nëse një tip me vlerë bëhet nullable me `?`).

Përkuptimi se cilat tipe janë me vlerë përkundër referencës dhe semantika rezultuese e kopjimit, krahasimit dhe mutacionit është themeli për të shkruar C# të saktë dhe për të shmangur gafet më të zakonshme të gjuhës — ajo mbështet se si rrjedhin të dhënat përmes një programi dhe është një temë e shpeshtë në intervista pikërisht sepse zbulon nëse një zhvillues vërtet kupton sistemin e tipeve të C#-it.