Fields and Properties

A field is a variable that lives inside an object. It is real storage: somewhere in memory there is a slot holding that value.

A property looks like a field from the outside and is not one. A property is a pair of small methods — one that runs when a value is read, one that runs when a value is written. The compiler turns product.UnitPrice = 250m into a method call. Understanding that single fact explains most of the surprising behaviour in this lesson.

public class Product
{
    private decimal _unitPrice;                 // the field: actual storage

    public decimal UnitPrice                    // the property: two methods
    {
        get
        {
            return _unitPrice;
        }
        set
        {
            if (value < 0m)
            {
                throw new ArgumentOutOfRangeException(nameof(value), "Price cannot be negative.");
            }

            _unitPrice = value;
        }
    }
}

• _unitPrice is private, so only code inside Product can touch it. The leading underscore is a widely used convention for private fields; the compiler does not care.
• get runs when something reads UnitPrice. set runs when something writes to it.
• Inside set, the keyword value holds whatever was assigned. It is a parameter you never declare.
• The field that stores the value behind a property is called its backing field. Callers never see it.
• Because set is a method, it can refuse. A negative price now throws at the moment somebody tries it.

Most properties need no logic, and writing that much code for storage-and-return would be tedious. So C# lets you write { get; set; } and it generates both methods and a hidden backing field for you. That is an auto-property. It is the same thing as the version above, minus the validation.

public class StockItem
{
    public string Sku { get; }
    public string Name { get; init; } = "";
    public decimal UnitPrice { get; private set; }
    public int QuantityOnHand { get; private set; }

    // Computed on every read, so it can never disagree with the two values above.
    public decimal StockValue => UnitPrice * QuantityOnHand;

    public StockItem(string sku, decimal unitPrice)
    {
        Sku = sku;
        UnitPrice = unitPrice;
    }

    public void Receive(int quantity)
    {
        if (quantity <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(quantity), "Received quantity must be positive.");
        }

        QuantityOnHand += quantity;
    }

    public void Reprice(decimal newPrice)
    {
        if (newPrice <= 0m)
        {
            throw new ArgumentOutOfRangeException(nameof(newPrice), "Price must be above zero.");
        }

        UnitPrice = newPrice;
    }
}

• Sku never changes, so it is get-only. QuantityOnHand and UnitPrice do change, but only through Receive and Reprice, which is what private set buys.
• StockValue has no storage. Nobody can set it to a number that contradicts the price and the quantity, because there is nothing to set.
• = "" on Name gives it a starting value so the compiler is satisfied it can never be null.
• Reading item.StockValue performs a multiplication each time. That is cheap here. If a computed property did expensive work, a method named CalculateStockValue() would set the caller's expectations better.