Propiedades, enums y pattern matching en C#

Propiedades: un campo con guardia#

Un campo público (public int vida;) deja que cualquiera lo lea y lo escriba sin control. Una propiedad parece un campo desde fuera, pero por dentro puede validar, avisar o calcular.

public class Personaje : MonoBehaviour
{
    [SerializeField] private int vidaMax = 100;
    private int vida;

    // Propiedad con lógica: nunca se sale de rango y avisa al cambiar
    public int Vida
    {
        get => vida;
        set
        {
            vida = Mathf.Clamp(value, 0, vidaMax);   // 'value' = lo que se asigna
            if (vida == 0) Morir();
        }
    }
}

objeto.Vida = 120; guardará 100 (el clamp) y, si llega a 0, llamará a Morir(). Toda la protección vive en un sitio.

Auto-propiedades y solo lectura#

Cuando no necesitas lógica, la versión corta:

public int Puntos { get; private set; }   // se lee desde fuera, solo se escribe desde dentro
public float Velocidad { get; set; } = 5f; // con valor por defecto
public string Nombre { get; }              // solo lectura: se fija en el constructor

El Inspector no serializa propiedades

Unity no muestra las propiedades en el Inspector (solo campos). Si quieres un valor editable en el editor, usa [SerializeField] private en un campo y, si hace falta control de acceso, envuélvelo en una propiedad. Ver SerializeField vs public.

Enums: estados con nombre#

Un enum es una lista cerrada de valores con nombre. Sustituye "números mágicos" o strings frágiles por algo legible y a prueba de erratas.

public enum EstadoEnemigo { Patrullando, Persiguiendo, Atacando, Muerto }

public class Enemigo : MonoBehaviour
{
    [SerializeField] private EstadoEnemigo estado = EstadoEnemigo.Patrullando;
}

En el Inspector aparece como un desplegable. Son la base de una máquina de estados.

Enums como flags (combinables)

Con [System.Flags] y valores potencia de dos (1, 2, 4, 8...) un enum puede combinar opciones: Fuego | Hielo. Es justo cómo funcionan los LayerMask de Unity por dentro.

Pattern matching: menos código, más claro#

El switch moderno (switch expression) devuelve un valor y encaja perfecto con enums:

// En vez de un switch clásico de 10 líneas:
float velocidad = estado switch
{
    EstadoEnemigo.Patrullando => 2f,
    EstadoEnemigo.Persiguiendo => 5f,
    EstadoEnemigo.Atacando     => 0f,
    _                          => 0f   // '_' = por defecto (obligatorio)
};

También comprueba tipos y condiciones:

string Describir(object x) => x switch
{
    int n when n < 0 => "negativo",
    int n            => "entero " + n,
    string s         => "texto: " + s,
    null             => "nada",
    _                => "otra cosa"
};

Errores frecuentes#

Esperar ver una propiedad en el Inspector (no se serializa; usa un campo con [SerializeField]).
Comparar enums con números crudos ((int)estado == 2): frágil, usa el nombre.
Un switch expression sin caso _: no compila si no cubre todos los casos.
Poner lógica pesada en un get: se llama muchas veces; que sea barato.

Ponte a prueba#

📝 Pon a prueba lo aprendido

Resumen#

Las propiedades son campos con guardia: get/set para validar o reaccionar (recuerda que el Inspector no las serializa). Los enums dan estados legibles y a prueba de erratas, base de las máquinas de estado. Y el pattern matching (switch expression) convierte cadenas de if/switch en una expresión corta que devuelve un valor. Tres piezas del C# moderno que aparecen constantemente en código de Unity.