Qual é a diferença entre tipos de valor e tipos de referência?

Question

Accepted Answer

Os tipos em C# se dividem em duas categorias fundamentais: **tipos de valor** (armazenam os dados diretamente) e **tipos de referência** (armazenam uma referência/ponteiro para dados no heap). Eles diferem em como são armazenados, copiados e comparados — uma distinção crucial que afeta o comportamento em toda a linguagem.

## As duas categorias

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

## A diferença-chave: semântica de cópia

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

Atribuir um tipo de valor copia os dados (independente); atribuir um tipo de referência copia a referência (ambos os nomes apontam para o mesmo objeto, então mutações através de um afetam o outro).

## Comparação e passagem para 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 que isso importa

A distinção valor-versus-referência é um dos conceitos mais fundamentais em C#, e explica uma ampla gama de comportamentos e bugs — tornando-a um conhecimento essencial.

Entender que **tipos de valor** (structs, primitivos como int/double, enums) são copiados por valor (cópias independentes) enquanto **tipos de referência** (classes, arrays, strings) são copiados por referência (ambos os nomes apontando para o mesmo objeto) é crucial para prever como os dados se comportam: modificar uma cópia de tipo de valor não afeta o original, mas mutar um objeto de tipo de referência compartilhado afeta todas as referências a ele (uma fonte comum de bugs surpreendentes).

Esta distinção também afeta **igualdade** (`==` compara valores para tipos de valor mas identidade de referência para tipos de referência por padrão), **argumentos de método** (tipos de valor passados como cópias, referências de tipos de referência passadas por valor — então métodos podem mutar um objeto passado mas não um int passado), e **nulabilidade** (apenas tipos de referência podem ser null, a menos que um tipo de valor seja tornado nullable com `?`).

Entender quais tipos são valor versus referência e a semântica resultante de cópia, comparação e mutação é fundamental para escrever C# correto e evitar as armadilhas conceituais mais comuns da linguagem — ela sustenta como os dados fluem através de um programa e é um tópico frequente em entrevistas precisamente porque revela se um desenvolvedor realmente entende o sistema de tipos do C#.