C# Valor × Referência

Faça um teste: guarde um número numa variável, copie para outra e mude a cópia. A original não muda. Agora faça o mesmo com um objeto: mude a "cópia" e a original muda junto! Não é defeito. O C# tem dois tipos de tipo: os tipos de valor, em que a variável guarda o próprio dado, e os tipos de referência, em que a variável guarda o endereço de um objeto. Entender essa diferença evita uma família inteira de bugs.

Todos os programas desta aula rodaram com dotnet run arquivo.cs no .NET 10 da máquina da Ana, na pasta ~/cs.

A ideia: a fotocópia e o endereço

A Ana tem uma receita de bolo e quer passá-la para a Bia. Ela pode fazer de dois jeitos:

• Tirar uma fotocópia e dar a cópia. Se a Bia rabiscar a cópia dela, a receita da Ana continua limpa. Cada uma tem a sua. Isso é um tipo de valor.
• Passar o endereço do blog onde a receita está publicada. Agora as duas olham a mesma receita. Se a Bia (que também tem a senha) editar a página, a Ana vê a mudança. Isso é um tipo de referência: a variável guarda o "endereço" do objeto, não o objeto.

Uma regra fácil para o começo: class é referência; números, bool, char, struct e enum são valor. Dá para perguntar ao .NET:

Console.WriteLine(typeof(int).IsValueType);
Console.WriteLine(typeof(decimal).IsValueType);
Console.WriteLine(typeof(DateTime).IsValueType);
Console.WriteLine(typeof(string).IsValueType);
Console.WriteLine(typeof(int[]).IsValueType);
Console.WriteLine(typeof(List<int>).IsValueType);

$ dotnet run tipos.cs
True       « int
True       « decimal
True       « DateTime é uma struct
False      « string
False      « array
False      « List

Copiar um valor: cada um com o seu

int a = 5;
int b = a;
b = 10;
Console.WriteLine($"a = {a}, b = {b}");

int a = 5;

A variável a guarda o número 5 dentro dela.

int b = a;

O 5 é copiado para dentro de b. A partir daqui, a e b não têm nada a ver uma com a outra.

b = 10;

Muda só o b.

$ dotnet run valor.cs
a = 5, b = 10

Nada de surpresa: é o que você esperava desde a aula de Variáveis.

Copiar uma referência: os dois apontam para o mesmo objeto

Caderno c1 = new Caderno();
c1.Dono = "Ana";
Caderno c2 = c1;
c2.Dono = "Bia";
Console.WriteLine($"c1: {c1.Dono}, c2: {c2.Dono}");

class Caderno
{
    public string Dono { get; set; } = "";
}

Caderno c1 = new Caderno();

O new cria um objeto Caderno na memória. A variável c1 não guarda o caderno; guarda o endereço dele (a "referência").

Caderno c2 = c1;

Copia o endereço, não o caderno. Agora c1 e c2 são dois nomes para o mesmo objeto. Repare: não houve new, então não nasceu caderno nenhum.

c2.Dono = "Bia";

"Vá até o objeto para onde c2 aponta e troque o dono." É o mesmo objeto de c1.

$ dotnet run referencia.cs
c1: Bia, c2: Bia

Um desenho ajuda:

  variáveis              objetos na memória
  ┌──────────┐
  │ c1  ●────┼──────┐
  └──────────┘      ▼
  ┌──────────┐   ┌────────────────┐
  │ c2  ●────┼──▶│ Caderno        │
  └──────────┘   │ Dono = "Bia"   │
                 └────────────────┘
  ┌──────────┐
  │ a   5    │    « um int guarda o próprio número
  └──────────┘

Caderno c1 = new Caderno();
c1.Dono = "Ana";
Caderno c2 = c1;
c2.Dono = "Bia";
Console.WriteLine($"c1: {c1.Dono}, c2: {c2.Dono}");

class Caderno
{
    public string Dono { get; set; } = "";
}

Caderno c1 = new Caderno();
c1.Dono = "Ana";
Caderno c2 = new Caderno();
c2.Dono = "Bia";
Console.WriteLine($"c1: {c1.Dono}, c2: {c2.Dono}");

class Caderno
{
    public string Dono { get; set; } = "";
}

Passar para um método

Passar um argumento para um método é uma atribuição disfarçada: o parâmetro recebe uma cópia do que está na variável. Para um valor, é a cópia do dado. Para uma referência, é a cópia do endereço.

int pontos = 10;
DobrarNumero(pontos);
Console.WriteLine($"pontos = {pontos}");

Placar placar = new Placar { Pontos = 10 };
DobrarPlacar(placar);
Console.WriteLine($"placar.Pontos = {placar.Pontos}");

void DobrarNumero(int numero)
{
    numero = numero * 2;
}

void DobrarPlacar(Placar p)
{
    p.Pontos = p.Pontos * 2;
}

class Placar
{
    public int Pontos { get; set; }
}

$ dotnet run metodos.cs
pontos = 10           « o método dobrou a cópia
placar.Pontos = 20    « o método mexeu no mesmo objeto

DobrarNumero(pontos)

O parâmetro numero recebe uma cópia do 10. O método dobra a cópia, e ela some quando o método termina. A variável pontos nem fica sabendo.

DobrarPlacar(placar)

O parâmetro p recebe uma cópia do endereço. p e placar apontam para o mesmo objeto, então p.Pontos = … muda o placar de verdade.

Mas trocar o objeto inteiro não funciona

O método recebeu uma cópia do endereço. Se ele fizer o parâmetro apontar para outro objeto, a variável de fora continua apontando para o antigo:

Placar placar = new Placar { Pontos = 10 };
Zerar(placar);
Console.WriteLine($"placar.Pontos = {placar.Pontos}");

void Zerar(Placar p)
{
    p = new Placar();
    p.Pontos = 0;
}

class Placar
{
    public int Pontos { get; set; }
}

$ dotnet run trocar.cs
placar.Pontos = 10    « o Zerar mexeu num placar novo, que ninguém viu

O p = new Placar(); fez só o p apontar para um placar novo. Se você precisa que um método troque a variável de quem chamou, existe o ref (veja ref, out e in). Mas, quase sempre, o melhor é o método devolver o objeto novo com return.

Arrays e listas são referências

Um array é um objeto, mesmo que seja de int. Copiar a variável copia o endereço:

int[] notas = [7, 8, 9];
int[] copia = notas;
copia[0] = 10;
Console.WriteLine(string.Join(", ", notas));

int[] deVerdade = (int[])notas.Clone();
deVerdade[1] = 0;
Console.WriteLine(string.Join(", ", notas));
Console.WriteLine(string.Join(", ", deVerdade));

$ dotnet run arrays.cs
10, 8, 9     « mudar a "copia" mudou as notas
10, 8, 9     « o Clone criou um array novo: as notas ficaram
10, 0, 9

int[] copia = notas;

Não copia nada: copia é outro nome para o mesmo array.

(int[])notas.Clone()

O Clone() cria um array novo, com os mesmos elementos. Ele devolve object, por isso o (int[]) na frente (veja Conversão de Tipos). Com listas, use new List<int>(lista) ou lista.ToList().

E o string?

O string é um tipo de referência, mas parece um valor:

string s1 = "Ana";
string s2 = s1;
s2 = s2 + " Souza";
Console.WriteLine($"s1 = {s1}, s2 = {s2}");

$ dotnet run texto.cs
s1 = Ana, s2 = Ana Souza

O segredo é que um string é imutável: nenhum método muda o texto que já existe (veja Strings). O s2 + " Souza" cria um texto novo e faz o s2 apontar para ele, igual ao p = new Placar() de antes. O s1 continua apontando para o "Ana" antigo. Como ninguém consegue mudar um texto "por dentro", compartilhar a referência nunca causa surpresas. E o == do string compara o conteúdo, não o endereço.

Quem pode ser null

null quer dizer "não aponta para nada". Só faz sentido para referências: um endereço pode estar vazio, mas um int sempre guarda um número.

int idade = null;

$ dotnet run nulo.cs
/home/ana/cs/nulo.cs(1,13): error CS0037: Não é possível converter o valor nulo em 'int' porque ele não é um tipo de valor não anulável

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Boxing: um valor dentro de uma caixa

A variável object é uma referência: ela guarda um endereço. Então, como object caixa = 42; funciona, se o 42 é um valor? O C# faz um truque chamado boxing ("encaixotar"): cria um objeto no heap, coloca uma cópia do 42 dentro e guarda o endereço da caixa. O caminho de volta, tirar o valor da caixa, é o unboxing.

int n = 42;
object caixa = n;
n = 7;
Console.WriteLine($"n = {n}, caixa = {caixa}");

int deVolta = (int)caixa;
Console.WriteLine(deVolta + 1);

object caixa = n;

Boxing: a caixa recebe uma cópia do 42. Acontece sozinho, sem você escrever nada.

n = 7;

Muda o n. A caixa tem a sua própria cópia e continua com 42.

(int)caixa

Unboxing: tira o valor da caixa. Precisa do cast (int), porque o compilador só sabe que ali há "um object".

$ dotnet run boxing.cs
n = 7, caixa = 42
43

Sem o cast, o compilador recusa:

$ dotnet run semcast.cs
/home/ana/cs/semcast.cs(2,9): error CS0266: Não é possível converter implicitamente tipo "object" em "int". Existe uma conversão explícita (há uma conversão ausente?)

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

O unboxing tem de usar o tipo exato

Uma caixa com um int só abre como int. Nem um long, que cabe um int com folga, serve:

object caixa = 42;
long grande = (long)caixa;
Console.WriteLine(grande);

$ dotnet run unbox.cs
Unhandled exception. System.InvalidCastException: Unable to cast object of type 'System.Int32' to type 'System.Int64'.
   at Program.<Main>$(String[] args) in /home/ana/cs/unbox.cs:line 2
$ echo $?
134

Desta vez compilou, e o erro só apareceu rodando: uma exceção (em inglês, como toda exceção do .NET no Linux). "Não é possível converter um objeto do tipo Int32 (o int) para o tipo Int64 (o long)." O conserto é abrir a caixa com o tipo certo e, só depois, converter: long grande = (int)caixa;. Se você não sabe o que há na caixa, pergunte com is: if (caixa is int numero) { … }.

Por que evitar

Cada boxing cria um objeto novo na memória, e isso custa tempo. Num laço com milhões de voltas, faz diferença. Por isso o C# moderno usa generics: uma List<int> guarda os int direto, sem caixas, enquanto a antiga ArrayList (de antes dos generics) guardava tudo como object. Regra prática: use o tipo certo, não object, e o boxing quase nunca aparece.

object caixa = 42;
long grande = (long)caixa;
Console.WriteLine(grande);

Quando dá errado

$ dotnet run nulo.cs
/home/ana/cs/nulo.cs(1,13): error CS0037: Não é possível converter o valor nulo em 'int' porque ele não é um tipo de valor não anulável

Referência

Exercícios

Carrinho daAna = new Carrinho();
daAna.Itens.Add("Café");

Carrinho daBia = daAna.Copiar();
daBia.Itens.Add("Chá");

Console.WriteLine($"Ana: {string.Join(", ", daAna.Itens)}");
Console.WriteLine($"Bia: {string.Join(", ", daBia.Itens)}");

class Carrinho
{
    public List<string> Itens { get; } = [];

    public Carrinho Copiar()
    {
        return this;
    }
}

Carrinho daAna = new Carrinho();
daAna.Itens.Add("Café");

Carrinho daBia = daAna.Copiar();
daBia.Itens.Add("Chá");

Console.WriteLine($"Ana: {string.Join(", ", daAna.Itens)}");
Console.WriteLine($"Bia: {string.Join(", ", daBia.Itens)}");

class Carrinho
{
    public List<string> Itens { get; } = [];

    public Carrinho Copiar()
    {
        Carrinho novo = new Carrinho();
        novo.Itens.AddRange(Itens);
        return novo;
    }
}

Pense no que aconteceria se o Copiar() fizesse novo.Itens = Itens; (se a propriedade tivesse set): os dois carrinhos teriam objetos diferentes, mas a mesma lista lá dentro, e o problema voltaria. Copiar o objeto de fora sem copiar as referências de dentro é chamado de cópia rasa; copiar tudo, até o fundo, é a cópia profunda.

Resumo

• Tipo de valor (int, decimal, bool, struct, enum): a variável guarda o dado; b = a faz uma cópia independente.
• Tipo de referência (class, string, arrays, listas): a variável guarda o endereço; b = a faz dois nomes para o mesmo objeto.
• Métodos recebem cópias: do dado ou do endereço. Pelo endereço, o método pode mudar o objeto, mas não trocar a variável de quem chamou.
• O string é referência, mas imutável, e por isso se comporta como valor. Tipos de valor não aceitam null (CS0037); use int?.
• Boxing põe uma cópia de um valor numa caixa object; o unboxing exige o tipo exato (InvalidCastException). Prefira generics a object. Próxima aula: Structs.