Propriedades para Encapsulamento

Parte da seção Programação Orientada a Objetos do Journey de C# da Coddy — lição 32 de 70.

Propriedades são a ferramenta principal para implementar o encapsulamento em C#. Em vez de expor campos diretamente, você os envolve com propriedades que controlam como os dados são acessados e modificados.

O padrão combina um campo privado com uma propriedade pública que inclui validação ou lógica em seus acessores:

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;
        }
    }
}

Agora, o código externo não pode definir uma temperatura impossível. A propriedade atua como um guardião, garantindo que seu objeto permaneça sempre em um estado válido. Isso é o encapsulamento em ação - os dados internos são protegidos enquanto permanecem acessíveis por meio de uma interface controlada.

Você também pode usar propriedades para calcular valores ou disparar efeitos colaterais:

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

O mundo externo vê duas propriedades, mas internamente existe apenas um campo. As propriedades permitem que você altere detalhes de implementação sem quebrar o código que usa sua classe - um benefício fundamental do encapsulamento adequado.

Desafio

Fácil

Vamos construir um sistema de inventário de produtos que utiliza propriedades para proteger a integridade dos dados. Você criará uma classe onde os preços nunca podem ser negativos e as quantidades são sempre mantidas dentro de limites válidos - demonstrando como as propriedades atuam como guardiãs para seus dados.

Você organizará seu código em dois arquivos:

Product.cs: Crie uma classe Product no namespace Inventory que gerencia informações do produto com validação através de propriedades. Seu produto precisa de:
- Um campo privado price (decimal) com uma propriedade pública Price que garante que o preço nunca fique abaixo de 0 - se alguém tentar definir um preço negativo, ele deve ser armazenado como 0
- Um campo privado quantity (int) com uma propriedade pública Quantity que mantém os valores entre 0 e 1000 - valores abaixo de 0 tornam-se 0, valores acima de 1000 tornam-se 1000
- Uma propriedade auto-implementada pública Name (string)
- Uma propriedade somente leitura computada TotalValue que retorna Price * Quantity
Inclua um construtor que aceite nome, preço e quantidade (nessa ordem) e defina todos os valores através das propriedades para que a validação seja aplicada.
Program.cs: No seu arquivo principal, crie um Product usando valores de entrada. Em seguida, tente modificar o preço e a quantidade com valores de entrada adicionais que podem ser inválidos. Imprima o estado do produto após a criação e após cada modificação para ver como as propriedades protegem os dados.

Você receberá cinco entradas:

Nome do produto
Preço inicial (decimal)
Quantidade inicial (inteiro)
Novo preço a ser definido (decimal, pode ser negativo)
Nova quantidade a ser definida (inteiro, pode estar fora do intervalo)

Imprima a saída neste formato:

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

Por exemplo, se as entradas forem Laptop, 999.99, 50, -100, e 1500, a saída deve ser:

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

Observe como o preço negativo tornou-se 0 e a quantidade de 1500 foi limitada a 1000. Suas propriedades estão protegendo o objeto de estados inválidos - isso é o encapsulamento em ação!

Folha de consulta

As propriedades envolvem campos privados com acesso controlado por meio dos acessores get e set, permitindo validação e encapsulamento:

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

As propriedades podem computar valores com base em campos internos:

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

Propriedades somente leitura omitem o acessor set, permitindo apenas a recuperação de valores computados ou armazenados.

Experimente você mesmo

using System;
using Inventory;

class Program
{
    public static void Main(string[] args)
    {
        // Ler as 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: Criar um Produto usando os valores iniciais
        
        // TODO: Imprimir o estado do produto após a criação
        Console.WriteLine("After creation:");
        // Formato de impressão: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
        
        // TODO: Modificar o preço e a quantidade com os novos valores
        
        // TODO: Imprimir o estado do produto após as modificações
        Console.WriteLine("After modifications:");
        // Formato de impressão: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
    }
}