Değer türleri (value types) ile referans türleri (reference types) arasındaki fark nedir?

Question

Accepted Answer

C# türleri iki temel kategoriye ayrılır: **değer türleri** (veriyi doğrudan depolar) ve **referans türleri** (yığın üzerindeki veriye bir referans/işaretçi depolar). Bunlar nasıl depolandıkları, kopyalandıkları ve karşılaştırıldıkları açısından farklıdır — bu, dil içinde davranışı etkileyen önemli bir ayrımdır.

## İki kategori

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

## Temel fark: kopyalama semantiği

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

Bir değer türünü atamak veriyi kopyalar (bağımsız); bir referans türünü atamak referansı kopyalar (her iki ad aynı nesneyi gösterir, bu nedenle biri üzerinden değiştirme diğerini etkiler).

## Karşılaştırma ve metodlara geçişi

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

## Neden önemli

Değer-referans ayrımı C#'taki en temel kavramlardan biridir ve geniş bir davranış ve hata yelpazesini açıklar — bu da onu temel bilgi kılmaktadır.

**Değer türleri** (struct'lar, int/double gibi ilkel türler, enum'lar) değere göre kopyalanır (bağımsız kopyalar) ve **referans türleri** (sınıflar, diziler, string'ler) referansa göre kopyalanır (her iki ad aynı nesneyi gösterir) olduğunu anlamak, verilerin nasıl davrandığını tahmin etmek için önemlidir: bir değer türü kopyasını değiştirmek orijinali etkilemez, ancak paylaşılan bir referans türü nesnesini değiştirmek ona yapılan tüm referansları etkiler (yaygın bir sürpriz kaynağı).

Bu ayrım aynı zamanda **eşitliği** (`==` değer türleri için değerleri, referans türleri için varsayılan olarak referans kimliğini karşılaştırır), **metod argümanlarını** (değer türleri kopyalar olarak geçirilir, referans türlerinin referansları değere göre geçirilir — metodlar geçilen bir nesneyi değiştirebilir fakat geçilen int'i değiştiremez) ve **boş değerlenebilirliği** (sadece referans türleri null olabilir, değer türü `?` ile nullable yapılmadıkça) etkiler.

Hangi türlerin değer vs referans olduğunu ve sonuçta ortaya çıkan kopyalama, karşılaştırma ve değiştirme semantiğini anlamak, doğru C# yazmak ve dilin en yaygın kavramsal tuzaklarından kaçınmak için temeldir — bu, verilerin bir program içinde nasıl aktığının altını çizer ve bir geliştirici gerçekten C#'ın tür sistemini anlayıp anlamadığını ortaya çıkardığı için sık sorulan bir mülakat konusudur.