Tipos por referencia y tipos por valor

1. Introducción

Imagina que tienes una caja. Si es una caja que contiene el objeto en sí (por ejemplo, una caja con una manzana dentro), eso se parece a un tipo por valor. Los datos están justo dentro de esa "caja" (la variable).

Por otro lado, imagina que tienes una tarjeta de visita con una dirección. La tarjeta en sí no es la casa, solo indica dónde encontrar la casa. Eso se parece a un tipo por referencia. En este caso, la variable no contiene los datos en sí, sino la "tarjeta" – la dirección en memoria donde están esos datos.

Ejemplos sencillos:

• int x = 5; // Tipo por valor: la variable x "guarda" el número 5 directamente.
• string name = "Vasia"; // Tipo por referencia: la variable name "guarda" una referencia a la cadena "Vasia", que está en algún lugar de la memoria.

¿Quién es quién en este mundo?

Para que te aclares mejor, aquí tienes una lista general de a qué categoría pertenecen los tipos de datos principales:

• Tipos primitivos: int, double, float, bool, char, byte, short, long, decimal, etc.
• Estructuras (struct): Todas las estructuras personalizadas que declares usando la palabra clave struct.
• Enumeraciones (enum): Tipos que te permiten definir un conjunto de constantes con nombre.

• Cadenas (string): Aunque las cadenas tienen algunas particularidades (son inmutables), son un tipo por referencia.
• Todos los arrays: Por ejemplo, int[], string[], YourCustomClass[].
• Todas las clases (class): Todas las clases personalizadas que declares usando la palabra clave class.
• Delegados (delegate): Tipos que representan referencias a métodos.
• Interfaces (interface): Aunque las interfaces en sí no son objetos, una variable de tipo interfaz puede guardar una referencia a un objeto que implemente esa interfaz.
• Listas, diccionarios y otras colecciones: Por ejemplo, List<T>, Dictionary<TKey, TValue>.
• Y en general, todo lo que no sea struct o enum, por defecto es un tipo por referencia en C#.

2. Copiando variables

Aquí es donde está la diferencia práctica principal. Cuando asignas una variable a otra, ¿qué es lo que realmente se copia?

A) Copiando un tipo por valor (Value Type)

Cuando copias un tipo por valor, se crea una copia completa e independiente de los datos. Es como hacer una fotocopia de un documento: los cambios en una copia no afectan al original ni a otras copias.

    int a = 10;
int b = a; 					// b ahora también es 10, pero es "su propia copia"
Console.WriteLine($"Valores iniciales: a = {a}, b = {b}"); // Valores iniciales: a = 10, b = 10

b = 15; 					// Cambiamos b
Console.WriteLine($"Después de cambiar b: a = {a}, b = {b}"); // Después de cambiar b: a = 10, b = 15

Explicación: La variable b recibió su propia copia del valor 10. Cuando b se cambió a 15, a se quedó con su valor original 10. Son totalmente independientes.

B) Copiando un tipo por referencia (Reference Type)

Al copiar un tipo por referencia, se copia solo la referencia, es decir, la "dirección" del objeto en memoria. Ambas variables ahora apuntan al mismo objeto. Es como si dieras a dos personas la misma tarjeta de visita: ambos sabrán la dirección de la misma casa. Si una persona cambia algo en la casa (por ejemplo, pinta una pared), la otra persona, al ir a esa dirección, verá esos cambios.

Vamos a verlo con un ejemplo usando arrays, porque muestran muy bien la "magia" de las referencias (a diferencia de las cadenas, que tienen sus matices).

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 y arr1 apuntan al mismo array en memoria!

// Valores iniciales: arr1[0] = 1, arr2[0] = 1
Console.WriteLine($"Valores iniciales: arr1[0] = {arr1[0]}, arr2[0] = {arr2[0]}"); 

arr2[0] = 42; // Cambiamos un elemento del array usando arr2

// Después de cambiar arr2[0]: arr1[0] = 42, arr2[0] = 42
Console.WriteLine($"Después de cambiar arr2[0]: arr1[0] = {arr1[0]}, arr2[0] = {arr2[0]}"); 

Explicación: Ambas variables (arr1 y arr2) contienen una referencia al mismo array en memoria. Cuando cambias el elemento arr2[0], realmente estás cambiando ese array al que apuntan ambas variables. Por eso arr1[0] también muestra el valor cambiado.

Matiz con las cadenas (string)

Las cadenas en C# son tipos por referencia, pero se comportan un poco diferente porque son inmutables (immutability). Eso significa que después de crear una cadena, no se puede cambiar. Cualquier operación que parezca "modificar" una cadena (por ejemplo, concatenar, Replace()), en realidad crea una nueva cadena en memoria.

string str1 = "Hello";
string str2 = str1; // str2 apunta al mismo objeto "Hello" que str1

// str1 = "Hello", str2 = "Hello"
Console.WriteLine($"Valores iniciales: str1 = \"{str1}\", str2 = \"{str2}\""); 

str2 = "Bye"; // Aquí se crea un NUEVO objeto "Bye", y str2 empieza a apuntar a él

// str1 = "Hello", str2 = "Bye"
Console.WriteLine($"Después de cambiar str2: str1 = \"{str1}\", str2 = \"{str2}\""); 

Explicación: Al principio, str1 y str2 apuntaban al mismo objeto "Hello". Cuando a str2 se le asignó "Bye", C# no cambió el objeto "Hello" existente. En su lugar, creó un nuevo objeto "Bye" en memoria, y str2 ahora apunta a ese nuevo objeto. str1 sigue apuntando al viejo objeto "Hello". Esta diferencia es importante y suele confundir a los que empiezan.

3. Tabla de diferencias principales

4. Ejemplo en una aplicación

Imagina que estamos desarrollando una aplicación de consola sencilla para una encuesta de usuario. Tenemos una estructura para las notas del examen y una clase para el perfil del usuario.

// Tipo por valor: estructura para guardar las notas
struct Score
{
    public int Points;
    public string Grade; // Lo añadimos para que se vea claro
}

// Tipo por referencia: clase para el perfil del usuario
class User
{
    public string Name;
    public Score ExamScore; // Estructura anidada
}

Copiando la estructura (Score)

Score score1 = new Score { Points = 100, Grade = "A" };
Score score2 = score1; // Se copia todo el contenido de score1 en score2
Console.WriteLine($"score1: Points={score1.Points}, Grade={score1.Grade}"); // score1: Points=100, Grade=A
Console.WriteLine($"score2: Points={score2.Points}, Grade={score2.Grade}"); // score2: Points=100, Grade=A

score2.Points = 88;
score2.Grade = "B";

Console.WriteLine("--- Después de cambiar score2 ---");
Console.WriteLine($"score1: Points={score1.Points}, Grade={score1.Grade}"); // score1: Points=100, Grade=A (¡no cambió!)
Console.WriteLine($"score2: Points={score2.Points}, Grade={score2.Grade}"); // score2: Points=88, Grade=B

Resultado: score1 se quedó igual. Esto pasó porque al hacer Score score2 = score1; el contenido de score1 (todos sus campos) se copió en score2. Ahora ambas variables tienen sus propios datos independientes.

Copiando la clase (User)

User u1 = new User 
{ 
    Name = "Anna", 
    ExamScore = new Score { Points = 95, Grade = "A" } 
};
User u2 = u1; // Ahora u2 y u1 apuntan al MISMO usuario en memoria!
Console.WriteLine($"u1: Name={u1.Name}, Score={u1.ExamScore.Points}"); // u1: Name=Anna, Score=95
Console.WriteLine($"u2: Name={u2.Name}, Score={u2.ExamScore.Points}"); // u2: Name=Anna, Score=95

u2.Name = "Ivan"; // Cambiamos el nombre usando u2
u2.ExamScore.Points = 60; // Cambiamos la nota usando u2
u2.ExamScore.Grade = "C";

Console.WriteLine("--- Después de cambiar u2 ---");
Console.WriteLine($"u1: Name={u1.Name}, Score={u1.ExamScore.Points}, Grade={u1.ExamScore.Grade}"); // u1: Name=Ivan, Score=60, Grade=C
Console.WriteLine($"u2: Name={u2.Name}, Score={u2.ExamScore.Points}, Grade={u2.ExamScore.Grade}"); // u2: Name=Ivan, Score=60, Grade=C

Resultado: u1 también cambió! Esto pasó porque u1 y u2 al principio apuntaban al mismo objeto User en memoria. Cuando cambiamos las propiedades del objeto usando u2 (por ejemplo, u2.Name = "Ivan";), realmente cambiamos el objeto en sí. Por eso, cuando accedemos a u1.Name, ya vemos el valor cambiado. Incluso la estructura anidada ExamScore cambió para u1, porque es parte del objeto User al que apuntan ambas referencias.

5. ¿Qué pasa al pasar variables a métodos?

Entender cómo se pasan los tipos a los métodos es clave para que tu programa se comporte como esperas.

Pasando un tipo por valor (Value Type) a un método

Al pasar un tipo por valor a un método, por defecto se hace paso por valor. Eso significa que el método recibe una copia de la variable original. Cualquier cambio que se haga dentro del método a esa copia no afecta al original fuera del método.

void AddTen(int x)
{
    Console.WriteLine($"Dentro del método (antes de cambiar): x = {x}"); // Dentro del método (antes de cambiar): x = 5
    x = x + 10; // x ahora es 15, pero es una copia local
    Console.WriteLine($"Dentro del método (después de cambiar): x = {x}"); // Dentro (después de cambiar): x = 15
    // Esta copia local 'x' "morirá" al salir del método.
}

int num = 5;
Console.WriteLine($"Antes de llamar al método: num = {num}"); // Antes de llamar al método: num = 5
AddTen(num);
Console.WriteLine($"Después de llamar al método: num = {num}"); // Después de llamar al método: num = 5 (¡no cambió!)

Resultado: La variable num no cambió (5). x dentro de AddTen es una variable totalmente aparte, inicializada con una copia del valor de num.

Pasando un tipo por referencia (Reference Type) a un método

Al pasar un tipo por referencia a un método, por defecto también se hace paso por valor, pero lo que se copia es el valor de la referencia, no el objeto en sí. Eso significa que dentro del método tienes una copia de la "tarjeta" (dirección) al objeto original. Ambas referencias (la original y la del método) apuntan al mismo objeto en memoria.

void RenameUser(User u)
{
    // Dentro del método (antes de cambiar): u.Name = "Olga"
    Console.WriteLine($"Dentro del método (antes de cambiar): u.Name = \"{u.Name}\""); 
    u.Name = "Nuevo nombre"; // Cambiamos la propiedad del objeto al que apunta 'u'
    // Dentro del método (después de cambiar): u.Name = "Nuevo nombre"
    Console.WriteLine($"Dentro del método (después de cambiar): u.Name = \"{u.Name}\""); 
}

User user = new User { Name = "Olga" };
// Antes de llamar al método: user.Name = "Olga"
Console.WriteLine($"Antes de llamar al método: user.Name = \"{user.Name}\""); 
RenameUser(user); 
// Después de llamar al método: user.Name = "Nuevo nombre"
Console.WriteLine($"Después de llamar al método: user.Name = \"{user.Name}\""); 

Resultado: El nombre del usuario cambió a "Nuevo nombre". El método RenameUser recibió una copia de la referencia al objeto user. Con esa copia de la referencia, el método pudo acceder al objeto original en el heap y cambiar su propiedad Name.

Dato importante: ¿Qué pasa si dentro del método asignamos un nuevo objeto a la variable pasada de tipo por referencia?

void ReassignUser(User u)
{
    u = new User { Name = "Usuario totalmente nuevo" }; // 'u' ahora apunta a un nuevo objeto
    Console.WriteLine($"Dentro del método (después de reasignar): u.Name = \"{u.Name}\"");
}

User originalUser = new User { Name = "Usuario original" };
Console.WriteLine($"Antes de llamar a ReassignUser: originalUser.Name = \"{originalUser.Name}\"");
ReassignUser(originalUser); 
Console.WriteLine($"Después de llamar a ReassignUser: originalUser.Name = \"{originalUser.Name}\""); // "Usuario original" - ¡no cambió!

Resultado: originalUser no cambió! Esto es porque ReassignUser recibió una copia de la referencia. Cuando u = new User(...) ocurrió dentro del método, la variable local u empezó a apuntar a un objeto totalmente nuevo. La referencia original originalUser sigue apuntando al mismo objeto de antes. ¡Esto es muy importante!

6. "Lágrimas de principiante": errores típicos y sus causas

Entender los tipos por referencia y por valor puede ser complicado al principio. Aquí tienes algunos errores y confusiones comunes:

Lío al copiar arrays: Muchas veces se espera que al hacer arr2 = arr1; se cree una copia independiente del array. En realidad, solo tienes dos referencias al mismo array. Es como dos mandos para el mismo juego: lo que pulses en uno afecta al juego y se ve en el otro. Para crear una copia independiente del array, tienes que clonarlo explícitamente (por ejemplo, int[] arr2 = (int[])arr1.Clone(); o usando métodos Copy).

Esperar que las cadenas cambien "por referencia": Como string es un tipo por referencia, a veces se piensa que se comportará como un array al cambiarlo. Pero, por la inmutabilidad de las cadenas, cualquier operación que parezca cambiarla en realidad crea un nuevo objeto string. Esto suele dar resultados inesperados y puede ser ineficiente si haces muchas operaciones con cadenas en un bucle (para eso es mejor usar StringBuilder).

Olvidar el null: Los tipos por valor, salvo los nullable (int?, bool?), siempre tienen algún valor y nunca pueden ser null. Los tipos por referencia sí pueden ser null, es decir, no apuntar a ningún objeto. Si intentas acceder a un miembro de un objeto que es null, te saldrá el famoso NullReferenceException. Siempre revisa las variables por referencia por si son null antes de usarlas, si hay posibilidad de que no estén definidas.

Usar clases en vez de structs para datos pequeños: A veces, por costumbre, todo se declara como clase. Para conjuntos de datos pequeños y simples que representan una sola cosa (por ejemplo, un punto Point { X, Y }, un color Color { R, G, B }), las estructuras pueden ser más eficientes, ya que se guardan en la pila y se copian por valor, lo que reduce el trabajo del recolector de basura. Sin embargo, las estructuras deberían ser inmutables, pequeñas y no contener tipos por referencia que puedan ser null o cambiar su estado.