Proprietà per l'incapsulamento

Fa parte della sezione Programmazione orientata agli oggetti del percorso C# di Coddy. Lezione 32 di 70.

Le proprietà sono lo strumento principale per implementare l'incapsulamento in C#. Invece di esporre direttamente i campi, li racchiudi in proprietà che controllano il modo in cui i dati vengono consultati e modificati.

Lo schema combina un campo privato con una proprietà pubblica che include una convalida o una logica nei relativi accessori:

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

Ora il codice esterno non può impostare una temperatura impossibile. La proprietà funge da guardiano, assicurando che il tuo oggetto rimanga sempre in uno stato valido. Questo è l’incapsulamento in azione: i dati interni sono protetti, ma restano accessibili tramite un’interfaccia controllata.

Puoi anche usare le proprietà per calcolare valori o attivare effetti collaterali:

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

Il mondo esterno vede due proprietà, ma internamente c’è un solo campo. Le proprietà ti permettono di modificare i dettagli di implementazione senza compromettere il codice che usa la tua classe: un vantaggio fondamentale di un corretto incapsulamento.

Sfida

Facile

Costruiamo un sistema di inventario dei prodotti che usa le proprietà per proteggere l'integrità dei dati. Creerai una classe in cui i prezzi non possono mai diventare negativi e le quantità vengono sempre mantenute entro limiti validi: in questo modo vedrai come le proprietà fungono da custodi dei tuoi dati.

Organizzerai il codice in due file:

Product.cs: crea una classe Product nello spazio dei nomi Inventory che gestisce le informazioni sui prodotti con la convalida tramite proprietà. Il prodotto deve avere:
- Un campo privato price (decimal) con una proprietà pubblica Price che garantisce che il prezzo non scenda mai sotto 0: se qualcuno prova a impostare un prezzo negativo, al suo posto deve essere memorizzato 0
- Un campo privato quantity (int) con una proprietà pubblica Quantity che mantiene i valori tra 0 e 1000: i valori inferiori a 0 diventano 0, quelli superiori a 1000 diventano 1000
- Una proprietà pubblica automatica Name (string)
- Una proprietà di sola lettura calcolata TotalValue che restituisce Price * Quantity
Includi un costruttore che accetta nome, prezzo e quantità (in quest'ordine) e imposta tutti i valori tramite le proprietà, in modo che venga applicata la convalida.
Program.cs: nel file principale, crea un Product usando i valori di input. Poi prova a modificare il prezzo e la quantità con ulteriori valori di input, che potrebbero non essere validi. Stampa lo stato del prodotto dopo la creazione e dopo ogni modifica, per vedere come le proprietà proteggono i dati.

Riceverai cinque input:

Nome del prodotto
Prezzo iniziale (decimal)
Quantità iniziale (intero)
Nuovo prezzo da impostare (decimal, potrebbe essere negativo)
Nuova quantità da impostare (intero, potrebbe essere fuori dall'intervallo consentito)

Stampa l'output in questo formato:

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

Per esempio, se gli input sono Laptop, 999.99, 50, -100 e 1500, l'output dovrebbe essere:

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

Nota come il prezzo negativo è diventato 0 e la quantità di 1500 è stata limitata a 1000. Le tue proprietà proteggono l'oggetto dagli stati non validi: questa è l'incapsulazione in azione!

Provalo tu

using System;
using Inventory;

class Program
{
    public static void Main(string[] args)
    {
        // Leggi i dati di input
        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 usando i valori iniziali
        
        // TODO: Stampa lo stato del prodotto dopo la creazione
        Console.WriteLine("After creation:");
        // Formato di stampa: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
        
        // TODO: Modifica il prezzo e la quantità con i nuovi valori
        
        // TODO: Stampa lo stato del prodotto dopo le modifiche
        Console.WriteLine("After modifications:");
        // Formato di stampa: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
    }
}