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 la encapsulación en C#. En lugar de exponer directamente los campos, los envuelves 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;  // Mínimo del cero absoluto
            else
                celsius = value;
        }
    }
}

Ahora el código externo no puede establecer una temperatura imposible. La propiedad actúa como guardiana, asegurándose de que tu objeto siempre permanezca en un estado válido. Esto es la encapsulación en acción: los datos internos están protegidos y, al mismo tiempo, siguen siendo accesibles mediante 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 te permiten cambiar los detalles de implementación sin romper el código que usa tu clase: una ventaja clave de una encapsulación adecuada.

Desafío

Fácil

Construyamos un sistema de inventario de productos que use propiedades para proteger la integridad de los datos. Crearás una clase en la que los precios nunca puedan ser negativos y las cantidades siempre se mantengan dentro de límites válidos, lo que demuestra 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 administre la información del producto mediante propiedades con validación. Tu producto necesita:
- Un campo privado price (decimal) con una propiedad pública Price que garantice que el precio nunca sea inferior a 0; si alguien intenta establecer un precio negativo, se debe almacenar como 0
- Un campo privado quantity (int) con una propiedad pública Quantity que mantenga los valores entre 0 y 1000; los valores inferiores a 0 se convierten en 0 y los valores superiores a 1000 se convierten en 1000
- Una propiedad pública autoimplementada Name (string)
- Una propiedad calculada de solo lectura 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 usando los valores de entrada. Después, intenta modificar el precio y la cantidad con valores de entrada adicionales que podrían no ser válidos. Imprime el estado del producto después de crearlo 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 que se establecerá (decimal, podría ser negativo)
Nueva cantidad que se establecerá (entero, podría estar fuera del rango)

Imprime la salida con 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 el objeto de estados no válidos: ¡esto es la encapsulación en acción!

Pruébalo tú mismo

using System;
using Inventory;

class Program
{
    public static void Main(string[] args)
    {
        // Lee los datos de entrada
        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: Crea un Product con los valores iniciales
        
        // TODO: Imprime el estado del producto después de crearlo
        Console.WriteLine("After creation:");
        // Formato de impresión: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
        
        // TODO: Modifica el precio y la cantidad con los nuevos valores
        
        // TODO: Imprime el estado del producto después de las modificaciones
        Console.WriteLine("After modifications:");
        // Formato de impresión: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
    }
}