C# Properties — Silent Data Corruption via Bypassed Setters

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

using System;
using System.ComponentModel;
using System.Collections.Generic;

public class TemperatureSensor : INotifyDataErrorInfo
{
    private double _celsius;
    private readonly Dictionary<string, string> _errors = new();

    // Pattern 1: Throw on invalid value (for critical constraints)
    public double Celsius
    {
        get => _celsius;
        set
        {
            if (value < -273.15)
                throw new ArgumentOutOfRangeException(
                    nameof(value), "Temperature cannot be below absolute zero.");
            _celsius = value;
        }
    }

    // Pattern 2: Clamp to acceptable range (for UI sliders)
    private double _humidity;
    public double Humidity
    {
        get => _humidity;
        set
        {
            var clamped = Math.Clamp(value, 0, 100);
            if (clamped != value)
            {
                // log the clamping for debugging
                Console.WriteLine($"Humidity clamped from {value} to {clamped}");
            }
            _humidity = clamped;
        }
    }

    // Pattern 3: Set an error flag (for form validation with multiple errors)
    private string _location = string.Empty;
    public string Location
    {
        get => _location;
        set
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                _errors[nameof(Location)] = "Location is required.";
                ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(Location)));
            }
            else
            {
                _errors.Remove(nameof(Location));
            }
            _location = value;
        }
    }

    // INotifyDataErrorInfo members
    public bool HasErrors => _errors.Count > 0;
    public event EventHandler<DataErrorsChangedEventArgs>? ErrorsChanged;
    public System.Collections.IEnumerable GetErrors(string? propertyName) =>
        propertyName != null && _errors.TryGetValue(propertyName, out var err) ? new[] { err } : Array.Empty<string>();
}

class Program
{
    static void Main()
    {
        var sensor = new TemperatureSensor();

        try { sensor.Celsius = -300; }
        catch (ArgumentOutOfRangeException ex) { Console.WriteLine($"Caught: {ex.Message}"); }

        sensor.Humidity = 150;   // clamped to 100
        Console.WriteLine($"Humidity after clamp: {sensor.Humidity}");

        sensor.Location = "";
        Console.WriteLine($"Location errors: {sensor.HasErrors}");
    }
}

using System;

// Interface property contract
public interface IAccount
{
    string AccountId { get; }
    decimal Balance { get; }
    void Deposit(decimal amount);
    void Withdraw(decimal amount);
}

// Abstract base class with both abstract and virtual properties
public abstract class AccountBase : IAccount
{
    public abstract string AccountId { get; }
    public abstract decimal Balance { get; }

    // Virtual property with default implementation
    public virtual string Status => "Active";

    public abstract void Deposit(decimal amount);
    public abstract void Withdraw(decimal amount);
}

// Concrete implementation
public class SavingsAccount : AccountBase
{
    private decimal _balance;
    public override string AccountId { get; }

    public override decimal Balance
    {
        get => _balance;
        // No setter — balance changes only through Deposit/Withdraw
    }

    public override void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentException("Deposit amount must be positive.");
        _balance += amount;
    }

    public override void Withdraw(decimal amount)
    {
        if (amount <= 0) throw new ArgumentException("Withdrawal amount must be positive.");
        if (amount > _balance) throw new InvalidOperationException("Insufficient funds.");
        _balance -= amount;
    }

    public SavingsAccount(string accountId)
    {
        AccountId = accountId;
    }
}

class Program
{
    static void Main()
    {
        IAccount account = new SavingsAccount("SAV-123");
        account.Deposit(500);
        Console.WriteLine($"Account {account.AccountId}: Balance = {account.Balance:C}");
        account.Withdraw(200);
        Console.WriteLine($"After withdrawal: {account.Balance:C}");
    }
}