¿Cuál es la diferencia entre tipos de valor y tipos de referencia?

Question

Accepted Answer

Los tipos de C# se dividen en dos categorías fundamentales: **tipos de valor** (almacenan los datos directamente) y **tipos de referencia** (almacenan una referencia/puntero a datos en el heap). Se diferencian en cómo se almacenan, se copian y se comparan — una distinción crucial que afecta el comportamiento en toda el lenguaje.

## Las dos categorías

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

## La diferencia clave: semántica de copia

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

Asignar un tipo de valor copia los datos (independiente); asignar un tipo de referencia copia la referencia (ambos nombres apuntan al mismo objeto, por lo que mutar a través de uno afecta al otro).

## Comparación y paso a métodos

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

## Por qué es importante

La distinción valor-vs-referencia es uno de los conceptos más fundamentales en C#, y explica una amplia gama de comportamientos y errores — convirtiéndolo en conocimiento esencial.

Entender que los **tipos de valor** (structs, primitivos como int/double, enums) se copian por valor (copias independientes) mientras que los **tipos de referencia** (clases, arrays, strings) se copian por referencia (ambos nombres apuntando al mismo objeto) es crucial para predecir cómo se comportan los datos: modificar una copia de tipo de valor no afecta al original, pero mutar un objeto tipo de referencia compartido afecta todas las referencias a él (una fuente común de errores sorprendentes).

Esta distinción también afecta la **igualdad** (`==` compara valores para tipos de valor pero identidad de referencia para tipos de referencia por defecto), los **argumentos de método** (tipos de valor pasados como copias, referencias de tipos de referencia pasadas por valor — por lo que los métodos pueden mutar un objeto pasado pero no un int pasado), y la **nulabilidad** (solo tipos de referencia pueden ser null, a menos que un tipo de valor sea hecho nullable con `?`).

Entender cuáles tipos son valor vs referencia y la semántica resultante de copia, comparación y mutación es fundamental para escribir C# correcto y evitar los errores conceptuales más comunes del lenguaje — subyace en cómo los datos fluyen a través de un programa y es un tema frecuente en entrevistas precisamente porque revela si un desarrollador verdaderamente comprende el sistema de tipos de C#.