C# Properties Explained — Getters, Setters and Real-World Patterns

using System;

public class BankAccount
{
    // AUTO-PROPERTY: compiler generates a hidden backing field automatically.
    // Use this when you need no logic — just store and retrieve.
    public string AccountHolder { get; set; }

    // FULL PROPERTY with explicit backing field.
    // We need this because depositing a negative amount must be rejected.
    private decimal _balance;  // backing field — private, never touched directly from outside

    public decimal Balance
    {
        get
        {
            // getter runs every time someone reads Balance
            return _balance;
        }
        set
        {
            // setter runs every time someone assigns to Balance
            if (value < 0)
            {
                // reject bad data here rather than letting corruption spread
                throw new ArgumentOutOfRangeException(
                    nameof(value),
                    "Balance cannot be negative. Use Withdraw() instead.");
            }
            _balance = value;  // only store when the value is valid
        }
    }

    public BankAccount(string accountHolder, decimal openingBalance)
    {
        AccountHolder = accountHolder;  // hits the auto-property setter
        Balance = openingBalance;        // hits our validated setter — good from day one
    }
}

class Program
{
    static void Main()
    {
        var account = new BankAccount("Alice Chen", 500m);
        Console.WriteLine($"Account: {account.AccountHolder}");
        Console.WriteLine($"Balance: {account.Balance:C}");

        account.Balance = 750m;  // valid — setter stores the value
        Console.WriteLine($"After deposit adjustment: {account.Balance:C}");

        try
        {
            account.Balance = -100m;  // invalid — setter throws immediately
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"Caught: {ex.Message}");
        }
    }
}

using System;
using System.Collections.Generic;

public class OrderLine
{
    // INIT-ONLY PROPERTY (C# 9+): can be set at object creation, never changed after.
    // Perfect for immutable value objects — keeps object-initializer syntax working.
    public string ProductName { get; init; }
    public decimal UnitPrice  { get; init; }
    public int     Quantity   { get; init; }

    // COMPUTED PROPERTY — no backing field. Calculated fresh on every read.
    // The 'get' is implicit with the '=>' expression-body syntax.
    public decimal LineTotal => UnitPrice * Quantity;
}

public class Order
{
    // GETTER-ONLY AUTO-PROPERTY: set in constructor, never exposed for external mutation.
    public string OrderId { get; }
    public DateTime PlacedAt { get; }

    private readonly List<OrderLine> _lines = new();

    // READ-ONLY property exposing the collection safely.
    // We return IReadOnlyList so callers can iterate but not Add/Remove.
    public IReadOnlyList<OrderLine> Lines => _lines;

    // COMPUTED PROPERTY derived from child data — always in sync, zero maintenance.
    public decimal GrandTotal
    {
        get
        {
            decimal total = 0m;
            foreach (var line in _lines)
                total += line.LineTotal;  // each LineTotal is itself computed
            return total;
        }
    }

    public Order(string orderId)
    {
        OrderId  = orderId;              // only assignment allowed for getter-only props
        PlacedAt = DateTime.UtcNow;
    }

    public void AddLine(OrderLine line) => _lines.Add(line);
}

class Program
{
    static void Main()
    {
        var order = new Order("ORD-2024-001");

        // Object initializer syntax works because of 'init' setters
        order.AddLine(new OrderLine { ProductName = "Mechanical Keyboard", UnitPrice = 129.99m, Quantity = 1 });
        order.AddLine(new OrderLine { ProductName = "USB-C Cable",         UnitPrice = 12.49m,  Quantity = 3 });

        Console.WriteLine($"Order: {order.OrderId}");
        Console.WriteLine($"Placed: {order.PlacedAt:u}");
        Console.WriteLine();

        foreach (var line in order.Lines)
        {
            // LineTotal computed on the fly — no stored value to go stale
            Console.WriteLine($"  {line.ProductName,-22} x{line.Quantity}  =  {line.LineTotal:C}");
        }

        Console.WriteLine($"\n  Grand Total: {order.GrandTotal:C}");

        // This would be a compile error — init-only cannot be changed after construction:
        // order.Lines[0].ProductName = "Mouse";  // CS8852
    }
}

using System;
using System.ComponentModel;  // INotifyPropertyChanged lives here
using System.Runtime.CompilerServices;

// A reusable base class — write this once, inherit everywhere in your MVVM layer
public abstract class ObservableBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;

    // [CallerMemberName] automatically fills in the calling property's name.
    // Callers write: SetField(ref _name, value) — no magic strings needed.
    protected bool SetField<T>(ref T backingField, T newValue,
        [CallerMemberName] string propertyName = "")
    {
        // Skip the event if the value hasn't actually changed — avoids UI thrash
        if (EqualityComparer<T>.Default.Equals(backingField, newValue))
            return false;

        backingField = newValue;  // update the backing field first
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        return true;  // return true so callers know a change actually happened
    }
}

public class CustomerViewModel : ObservableBase
{
    private string _fullName = string.Empty;
    private int    _loyaltyPoints;
    private bool   _isPremiumMember;

    public string FullName
    {
        get => _fullName;
        set => SetField(ref _fullName, value);  // fires PropertyChanged automatically
    }

    public int LoyaltyPoints
    {
        get => _loyaltyPoints;
        set
        {
            if (value < 0)
                throw new ArgumentOutOfRangeException(nameof(value), "Points cannot be negative.");

            SetField(ref _loyaltyPoints, value);

            // Changing points might flip premium status — update that property too
            IsPremiumMember = value >= 1000;
        }
    }

    // Private setter: the class controls this, callers just observe it
    public bool IsPremiumMember
    {
        get => _isPremiumMember;
        private set => SetField(ref _isPremiumMember, value);
    }

    // Computed — no setter at all. Always derived, always correct.
    public string MembershipLabel => IsPremiumMember ? "⭐ Premium" : "Standard";
}

class Program
{
    static void Main()
    {
        var customer = new CustomerViewModel();

        // Subscribe to the event — in a real UI framework, the data binding does this
        customer.PropertyChanged += (sender, e) =>
            Console.WriteLine($"  [UI notified] '{e.PropertyName}' changed");

        Console.WriteLine("--- Setting name ---");
        customer.FullName = "Jordan Rivera";

        Console.WriteLine("\n--- Adding 500 points (stays Standard) ---");
        customer.LoyaltyPoints = 500;
        Console.WriteLine($"  Status: {customer.MembershipLabel}");

        Console.WriteLine("\n--- Adding 600 more points (becomes Premium) ---");
        customer.LoyaltyPoints = 1100;
        Console.WriteLine($"  Status: {customer.MembershipLabel}");

        Console.WriteLine("\n--- Setting same value again (no event fired) ---");
        customer.FullName = "Jordan Rivera";  // SetField skips because value is unchanged
        Console.WriteLine($"  Name: {customer.FullName}");
    }
}