C# Academy · Lección

Patrones de objetos inmutables

Diseñe objetos que nunca cambien después de su creación.

Patrones de objetos inmutables es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Diseño de objetos inmutables

Un objeto inmutable nunca cambia después de su construcción. La inmutabilidad elimina categorías enteras de errores relacionados con el estado mutable compartido y hace que los objetos sean seguros de pasar y almacenar en caché.

Propiedades de solo lectura

La propiedad inmutable más sencilla es de solo lectura y se asigna una vez desde un constructor.

using System;

class Point {
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}

var p = new Point(3, 4);
Console.WriteLine(p.X + "," + p.Y); // 3,4

init para la sintaxis de inicializadores

Utilice propiedades init cuando quiera inmutabilidad junto con la práctica sintaxis de inicializador de objetos.

using System;

class Color {
    public int R { get; init; }
    public int G { get; init; }
    public int B { get; init; }
}

var c = new Color { R = 255, G = 128, B = 0 };
Console.WriteLine(c.R + "," + c.G + "," + c.B); // 255,128,0

required para campos obligatorios

Combine required + init para que los campos esenciales no puedan olvidarse ni cambiar.

using System;

class Money {
    public required decimal Amount { get; init; }
    public required string Currency { get; init; }
}

var m = new Money { Amount = 9.99m, Currency = "USD" };
Console.WriteLine(m.Amount + " " + m.Currency); // 9.99 USD

Devolver objetos nuevos en lugar de modificar

Los tipos inmutables exponen las operaciones de «cambio» como métodos que devuelven una instancia nueva y dejan intacta la original.

using System;

class Point {
    public int X { get; init; }
    public int Y { get; init; }
    public Point Move(int dx, int dy) => new Point { X = X + dx, Y = Y + dy };
}

var a = new Point { X = 1, Y = 1 };
var b = a.Move(2, 3);
Console.WriteLine(a.X + "," + a.Y + " -> " + b.X + "," + b.Y); // 1,1 -> 3,4

Colecciones inmutables

Para los campos de tipo colección, almacene una colección inmutable o de solo lectura, de modo que su contenido no pueda modificarse a través del objeto.

using System;
using System.Collections.Immutable;

class Team {
    public ImmutableList<string> Members { get; init; } = ImmutableList<string>.Empty;
}

var t = new Team { Members = ["Ada", "Lin"] };
var t2 = new Team { Members = t.Members.Add("Sam") };
Console.WriteLine(t.Members.Count + " " + t2.Members.Count); // 2 3

Copia defensiva

Si debe aceptar una colección mutable, cópiela al recibirla para impedir que los cambios externos se propaguen al objeto.

using System;
using System.Collections.Generic;
using System.Linq;

class Snapshot {
    private readonly int[] data;
    public Snapshot(IEnumerable<int> source) => data = source.ToArray();
    public IReadOnlyList<int> Data => data;
}

var list = new List<int> { 1, 2, 3 };
var snap = new Snapshot(list);
list.Add(4); // does not affect snap
Console.WriteLine(snap.Data.Count); // 3

Igualdad por valor

Los objetos inmutables suelen necesitar igualdad basada en el valor: dos instancias con los mismos datos se consideran iguales. Los records la proporcionan de forma automática; las clases necesitan sobrescribirla.

using System;

record Coord(int X, int Y);

Console.WriteLine(new Coord(1, 2) == new Coord(1, 2)); // True

Seguridad de subprocesos incluida

Como los objetos inmutables nunca cambian, son intrínsecamente seguros para compartir entre subprocesos sin bloqueos.

using System;

class ReadonlyConfig {
    public required string Env { get; init; }
}

var cfg = new ReadonlyConfig { Env = "prod" };
// safe to read from many threads without synchronization
Console.WriteLine(cfg.Env); // prod

Campos readonly y structs

Utilice campos readonly y readonly struct para imponer la inmutabilidad de los tipos de valor en el nivel del campo.

using System;

readonly struct Vector {
    public readonly double X, Y;
    public Vector(double x, double y) { X = x; Y = y; }
    public double Length => Math.Sqrt(X * X + Y * Y);
}

Console.WriteLine(new Vector(3, 4).Length); // 5

Integración

Un tipo completamente inmutable que combina required, init, igualdad por valor y un método de actualización que no modifica el objeto.

using System;

record Account(string Id, decimal Balance) {
    public Account Deposit(decimal amount) => this with { Balance = Balance + amount };
}

var a = new Account("A1", 100m);
var b = a.Deposit(50m);
Console.WriteLine(a.Balance + " -> " + b.Balance); // 100 -> 150

Comprobación rápida

Confirme el principio de actualización inmutable.

Resumen

Ha aprendido patrones para crear objetos inmutables.

Utilice propiedades de solo lectura o init, además de required para los datos obligatorios.
Modele los cambios mediante métodos que devuelvan instancias nuevas.
Almacene colecciones inmutables o copiadas de forma defensiva.
Los records proporcionan igualdad por valor y copias con with; la inmutabilidad aporta seguridad para los subprocesos.

Preguntas frecuentes

¿La lección «Patrones de objetos inmutables» es gratis?

Sí — el texto completo de «Patrones de objetos inmutables» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Patrones de objetos inmutables»?

Diseñe objetos que nunca cambien después de su creación. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Patrones de objetos inmutables»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C# Academy