Es muy común la necesidad de tener una manera de acceder a las variables miembros de una clase desde código que exista fuera de esa clase. Una manera en la que puedes hacerlo sería hacer las variables públicas para así accederlas directamente. Esto es suficiente pero hay otra manera, esa manera es usar propiedades.

Las propiedades mismas actúan como variables y encapsulan variables miembros, las mismas que también podemos llamar campos. Esta encapsulación nos da más control sobre cuándo y cómo se accede a un campo.

public class Hero
{
    private int experience;
}

Digamos que tenemos un campo llamado experience que existe en la clase Hero y queremos una manera para que el código que está fuera de la clase lo pueda acceder. Deberíamos crear una propiedad.

La sintaxis para una propiedad funciona así:

Primero, especifica el modificador de acceso public. Luego especifica el tipo int seguido del nombre de la propiedad Experience. Una buena regla a seguir es nombrar la propiedad con el mismo nombre que tiene el campo, pero ponerla en mayúsculas.

public class Hero
{
    private int experience;

    // modificador de acceso: public
    // tipo: int
    // nombre de propiedad: Expecience
    public int Expecience
}

Después de nombrar la propiedad abres y cierras llaves {...} tal como lo harías para una función. Dentro de estas llaves van los descriptores de acceso. Una propiedad puede tener dos descriptores de acceso: get y set. Estas son las funciones que se invocan cuando se hace referencia a una propiedad y cuando se hace una asignación a una propiedad, respectivamente.

public class Hero
{
    private int experience;

    // modificador de acceso: public
    // tipo: int
    // nombre de propiedad: Expecience
    public int Expecience
    {
        // referencia
        get { }
        // asignación
        set { }
    }
}

Dentro del descriptor de acceso get (obtener) vamos a retornar el campo que estamos encapsulando usando la palabra reservada return seguido del campo. En el descriptor de acceso set (asignar) le asignamos al campo usando la palabra reservada value.

public class Hero
{
    private int experience;

    // modificador de acceso: public
    // tipo: int
    // nombre de propiedad: Expecience
    public int Expecience
    {
        // referencia
        get
        {
            return experience;
        }
        // asignación
        set
        {
            experience = value;
        }
    }
}

Puede usar expresiones lambda para simplificar la expresión de una propiedad.

public class Hero
{
    private int experience;

    // modificador de acceso: public
    // tipo: int
    // nombre de propiedad: Expecience
    public int Expecience
    {
        // referencia
        get => experience;
        // asignación
        set => experience = value;
    }
}

Esto es todo lo que se requiere para implementar una propiedad.

Ahora, en otro script llamado Game podemos usar la propiedad en vez del campo exactamente como lo habríamos hecho normalmente.

public class Game : MonoBehaviour
{
    private void Start()
    {
        // instancia la clase Hero
        Hero myHero = new Hero();

        // referencia
        int x = myHero.Experience;
        // asignación
        myHero.Experience = 25;
    }
}

Ventajas del uso de propiedades.

Tal vez te estés preguntando por qué irías a través del proceso de crear una propiedad cuando puedes usar el modificador de acceso público para la variable desde el principio.

Hay dos cosas que puedes hacer con las propiedades que no puedes hacer con las variables públicas:

La primera es que al omitir el get o el set pueden efectivamente hacer que el campo sea solo lectura o solo escritura. Si el campo es privado, no puedes leerlo sin un descriptor de acceso get y no puedes escribir en él sin un descriptor de acceso set.

public class Hero
{
    private int experience;

    // propiedad solo de lectura
    public int Expecience
    {
        get => experience;
    }
}

public class Hero
{
    private int experience;

    // propiedad solo de escritura
    public int Expecience
    {
        set = experience = value;
    }
}

La segunda es que los descriptores de acceso también pueden tratarse como funciones. Eso significa que podrías ejecutar otras líneas de código o poner invocaciones a otras funciones dentro de ellas.

public class Hero
{
    private int experience;

    // propiedad solo de escritura
    public int Expecience
    {
        set
        {
            experience = value;
            CalculateLevel(experience);
        }
    }

    private void CalculateLevel(int value)
    {
        // Calcula el nivel basado en la experiencia
    }
}

Una extensión de esta idea es el comenzar corrutinas usando el descriptor de acceso set. La encapsulación del campo no necesita ser directa.

public class Hero
{
    private int experience;

    // propiedad solo de escritura
    public int Expecience
    {
        set
        {
            experience = value;
            StartCoroutine(ExampleCoroutine());
        }
    }

    private IEnumerator ExampleCoroutine()
    {
        yield return new WaitForSeconds(.25f);
        // example code
    }
}

Cómo aplicarlo

Considera un juego donde el héroe gane experiencia y sube de nivel después de cada 1000 puntos de experiencia. Si tienes un campo que representa los puntos de experiencia, podrías también tener una propiedad para representar el nivel del héroe, en vez de regresar el número de puntos de experiencias el descriptor de acceso get del nivel podría retornar el campo experiencia dividido por 1000.

Por lo tanto, regresará el nivel numérico y no la experiencia que tiene el jugador. Es más, la propiedad nivel podría tener un descriptor de acceso set que recibe un nivel y calcula la cantidad de experiencia que él jugador tiene y la guarda en el campo experience.

public class Hero
{
    private int experience;

    public int Expecience
    {
        get => experience;
        set => experience = value;
    }

    public int Level
    {
        get
        {
            return experience / 1000;
        }
        set
        {
            experience = value * 1000;
        }
    }
}

Otra característica de las propiedades es que pueden ser autoimplementadas. Para crear una propiedad autoimplementada usarías una sintaxis de acceso rápido. En esta sintaxis, los descriptores de acceso get y set están seguidos por un punto y coma.

public class Hero
{
    // propiedad autoimplementada
    public int Health { get; set; }
}

Crear una propiedad de esta manera hace que se comporte de la misma manera que un campo; la diferencia es que podría hacerla de solo lectura o escritura al eliminar el descriptor de acceso get o set.

Apoya el contenido de mi blog a través de:

Fuente:

• Microsoft Docs: Properties C#
• Unity Learn: Junior Programer