Propiedades para el encapsulamiento

Parte de la sección Programación Orientada a Objetos del Journey de C# de Coddy — lección 32 de 70.

Las propiedades son la herramienta principal para implementar el encapsulamiento en C#. En lugar de exponer los campos directamente, se envuelven con propiedades que controlan cómo se accede a los datos y cómo se modifican.

El patrón combina un campo privado con una propiedad pública que incluye validación o lógica en sus accesores:

public class Temperature
{
    private double celsius;
    
    public double Celsius
    {
        get { return celsius; }
        set
        {
            if (value < -273.15)
                celsius = -273.15;  // Absolute zero minimum
            else
                celsius = value;
        }
    }
}

Ahora el código externo no puede establecer una temperatura imposible. La propiedad actúa como un guardián, asegurando que su objeto permanezca siempre en un estado válido. Esto es la encapsulación en acción: los datos internos están protegidos mientras siguen siendo accesibles a través de una interfaz controlada.

También puedes usar propiedades para calcular valores o desencadenar efectos secundarios:

public double Fahrenheit
{
    get { return celsius * 9 / 5 + 32; }
    set { celsius = (value - 32) * 5 / 9; }
}

El mundo exterior ve dos propiedades, pero internamente solo hay un campo. Las propiedades le permiten cambiar los detalles de implementación sin romper el código que utiliza su clase: un beneficio clave de una encapsulación adecuada.

Desafío

Fácil

Vamos a construir un sistema de inventario de productos que utiliza propiedades para proteger la integridad de los datos. Crearás una clase donde los precios nunca pueden ser negativos y las cantidades siempre se mantienen dentro de límites válidos, demostrando cómo las propiedades actúan como guardianes de tus datos.

Organizarás tu código en dos archivos:

Product.cs: Crea una clase Product en el espacio de nombres Inventory que gestione la información del producto con validación a través de propiedades. Tu producto necesita:
- Un campo privado price (decimal) con una propiedad pública Price que asegure que el precio nunca baje de 0; si alguien intenta establecer un precio negativo, debe almacenarse como 0 en su lugar.
- Un campo privado quantity (int) con una propiedad pública Quantity que mantenga los valores entre 0 y 1000; los valores por debajo de 0 se convierten en 0, los valores por encima de 1000 se convierten en 1000.
- Una propiedad auto-implementada pública Name (string).
- Una propiedad de solo lectura calculada TotalValue que devuelva Price * Quantity.
Incluye un constructor que acepte el nombre, el precio y la cantidad (en ese orden) y establezca todos los valores a través de las propiedades para que se aplique la validación.
Program.cs: En tu archivo principal, crea un Product utilizando los valores de entrada. Luego intenta modificar el precio y la cantidad con valores de entrada adicionales que podrían ser inválidos. Imprime el estado del producto después de la creación y después de cada modificación para ver cómo las propiedades protegen los datos.

Recibirás cinco entradas:

Nombre del producto
Precio inicial (decimal)
Cantidad inicial (entero)
Nuevo precio a establecer (decimal, puede ser negativo)
Nueva cantidad a establecer (entero, puede estar fuera de rango)

Imprime la salida en este formato:

After creation:
{Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
After modifications:
{Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}

Por ejemplo, si las entradas son Laptop, 999.99, 50, -100, y 1500, la salida debería ser:

After creation:
Laptop: Price=999.99, Qty=50, Total=49999.50
After modifications:
Laptop: Price=0, Qty=1000, Total=0

Observa cómo el precio negativo se convirtió en 0 y la cantidad de 1500 se limitó a 1000. Tus propiedades están protegiendo al objeto de estados inválidos: ¡esto es la encapsulación en acción!

Hoja de referencia

Las propiedades envuelven campos privados con acceso controlado a través de los accesores get y set, lo que permite la validación y el encapsulamiento:

public class Temperature
{
    private double celsius;
    
    public double Celsius
    {
        get { return celsius; }
        set
        {
            if (value < -273.15)
                celsius = -273.15;
            else
                celsius = value;
        }
    }
}

Las propiedades pueden calcular valores basados en campos internos:

public double Fahrenheit
{
    get { return celsius * 9 / 5 + 32; }
    set { celsius = (value - 32) * 5 / 9; }
}

Las propiedades de solo lectura omiten el accesor set, permitiendo únicamente la recuperación de valores calculados o almacenados.

Pruébalo tú mismo

using System;
using Inventory;

class Program
{
    public static void Main(string[] args)
    {
        // Leer entradas
        string name = Console.ReadLine();
        decimal initialPrice = Convert.ToDecimal(Console.ReadLine());
        int initialQuantity = Convert.ToInt32(Console.ReadLine());
        decimal newPrice = Convert.ToDecimal(Console.ReadLine());
        int newQuantity = Convert.ToInt32(Console.ReadLine());

        // TODO: Crear un Product usando los valores iniciales
        
        // TODO: Imprimir el estado del producto después de la creación
        Console.WriteLine("After creation:");
        // Formato de impresión: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
        
        // TODO: Modificar el precio y la cantidad con los nuevos valores
        
        // TODO: Imprimir el estado del producto después de las modificaciones
        Console.WriteLine("After modifications:");
        // Formato de impresión: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
    }
}