Mikä on ero arvo- ja viitetyyppien välillä?

Question

Accepted Answer

C#:n tyypit jakaantuvat kahteen perustavanlaatuiseen kategoriaan: **arvotyypit** (tallentavat datan suoraan) ja **viitetyypit** (tallentavat viitteen/osoittimen heap-muistissa olevaan dataan). Ne eroavat siinä, miten ne tallennetaan, kopioidaan ja vertaillaan — kriittinen ero, joka vaikuttaa käyttäytymiseen koko kielen laajuudella.

## Kaksi kategoriaa

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

## Pääero: kopioinnin semantiikka

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

Arvotyypin sijoittaminen kopioi datan (itsenäinen); viitetyypin sijoittaminen kopioi viitteen (molemmat nimet osoittavat samaan objektiin, joten mutatointi yhden kautta vaikuttaa toiseen).

## Vertailu ja menetelmille välittäminen

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

## Miksi se on tärkeää

Arvo- ja viitetyyppijaottelu on yksi C#:n perustavanlaatuisimmista käsitteistä, ja se selittää laajan valikoiman käyttäytymisiä ja bugeja — mikä tekee siitä olennaisen tiedon.

Ymmärtäminen siitä, että **arvotyypit** (structit, primitiivit kuten int/double, enumit) kopioidaan arvon mukaan (itsenäisiä kopioita) kun taas **viitetyypit** (luokat, taulukot, merkkijonot) kopioidaan viitteen mukaan (molemmat nimet osoittavat samaan objektiin) on ratkaisevan tärkeää ennustettaessa, miten data käyttäytyy: arvotyyppikopion mutatointi ei vaikuta alkuperäiseen, mutta jaetun viitetyyppiobjektin mutatointi vaikuttaa kaikkiin siihen viittaaviin muuttujiin (yleinen hämmennyksen lähde).

Tämä jaottelu vaikuttaa myös **vertailuun** (`==` vertaa arvoja arvotyypeille mutta viiteidentiteettiä viitetyypeille oletuksena), **menetelmän argumentteihin** (arvotyypit välitetään kopioina, viitetyyppien viitteet välitetään arvona — joten metodit voivat mutatoida välitettyä objektia mutta ei välitettyä inttiä) ja **nollattavuuteen** (vain viitetyypit voivat olla null, ellei arvotyyppistä ole tehty nullable-tyyppistä `?`:llä).

Ymmärtäminen siitä, mitkä tyypit ovat arvo- tai viitetyyppejä ja siitä johtuvat kopiointi-, vertailu- ja mutaatiosemantiikat on perustavanlaatuista C#:n oikean kirjoittamisen kannalta ja yleisten käsitteellisten sudenkuoppiensa välttämiseksi — se pohjustaa, kuinka data kulkee ohjelman läpi ja on usein haastattelu-aihe juuri siksi, että se paljastaa, ymmärtääkö kehittäjä todella C#:n tyyppijärjestelmää.