Classes and Objects in C# Explained — Blueprint, Instance and Real-World Patterns

using System;

// The CLASS — this is the blueprint. It exists at compile time.
// It describes what every bank account will look like.
public class BankAccount
{
    // Fields: the DATA this object holds.
    // 'private' means only code inside this class can touch them directly.
    private string _accountHolder;
    private decimal _balance;

    // Constructor: special method that runs when you create a new object.
    // It guarantees every account starts in a known, valid state.
    public BankAccount(string accountHolder, decimal openingBalance)
    {
        if (string.IsNullOrWhiteSpace(accountHolder))
            throw new ArgumentException("Account holder name cannot be empty.");

        if (openingBalance < 0)
            throw new ArgumentException("Opening balance cannot be negative.");

        _accountHolder = accountHolder;
        _balance = openingBalance;
    }

    // Properties: controlled gateways to read (and sometimes write) fields.
    // Callers can READ the balance but never SET it directly — only Deposit/Withdraw can.
    public string AccountHolder => _accountHolder;
    public decimal Balance => _balance;

    // Methods: the BEHAVIOUR — things this object can DO.
    public void Deposit(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentException("Deposit amount must be positive.");

        _balance += amount;  // Only this method can legitimately increase the balance
        Console.WriteLine($"{_accountHolder} deposited {amount:C}. New balance: {_balance:C}");
    }

    public bool Withdraw(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentException("Withdrawal amount must be positive.");

        if (amount > _balance)
        {
            Console.WriteLine($"Insufficient funds. {_accountHolder} tried to withdraw {amount:C}.");
            return false;  // Signals failure without throwing an exception
        }

        _balance -= amount;
        Console.WriteLine($"{_accountHolder} withdrew {amount:C}. New balance: {_balance:C}");
        return true;
    }

    // ToString override: makes Console.WriteLine(account) print something useful
    public override string ToString()
    {
        return $"Account[{_accountHolder}, Balance: {_balance:C}]";
    }
}

class Program
{
    static void Main()
    {
        // OBJECT CREATION — 'new' allocates memory on the heap and calls the constructor.
        // sarahAccount is a REFERENCE to that object, not the object itself.
        BankAccount sarahAccount = new BankAccount("Sarah", 1000m);
        BankAccount jamesAccount = new BankAccount("James", 500m);

        // Each object has its own independent copy of _balance.
        // Changing Sarah's account has zero effect on James's.
        sarahAccount.Deposit(250m);
        sarahAccount.Withdraw(100m);
        jamesAccount.Withdraw(600m);  // This will fail — insufficient funds

        Console.WriteLine();
        Console.WriteLine(sarahAccount);  // Calls our ToString() override
        Console.WriteLine(jamesAccount);
    }
}

using System;

public class Product
{
    // Private backing fields — callers can't touch these directly
    private string _name;
    private decimal _price;
    private int _stockQuantity;

    // Full constructor: requires all information upfront
    public Product(string name, decimal price, int stockQuantity)
    {
        Name = name;           // Deliberately using the property setter here
        Price = price;         // so validation runs in ONE place
        StockQuantity = stockQuantity;
    }

    // Overloaded constructor: create a product with zero stock (e.g. pre-launch)
    // Chains to the main constructor — no duplicated validation!
    public Product(string name, decimal price) : this(name, price, 0)
    {
        Console.WriteLine($"'{name}' created with no initial stock.");
    }

    // Property with validation in the setter
    public string Name
    {
        get => _name;
        set
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Product name cannot be blank.");
            _name = value.Trim();
        }
    }

    // Price can be read by anyone but only set privately (internal business logic)
    public decimal Price
    {
        get => _price;
        private set
        {
            if (value < 0)
                throw new ArgumentException($"Price cannot be negative. Got: {value}");
            _price = value;
        }
    }

    // Stock can be read publicly; set privately
    public int StockQuantity
    {
        get => _stockQuantity;
        private set
        {
            if (value < 0)
                throw new ArgumentException("Stock quantity cannot be negative.");
            _stockQuantity = value;
        }
    }

    // Computed (read-only) property — derived from other state, no backing field needed
    public bool IsInStock => _stockQuantity > 0;

    // Method that applies a discount — business logic lives HERE, not in calling code
    public void ApplyDiscount(decimal percentageOff)
    {
        if (percentageOff <= 0 || percentageOff >= 100)
            throw new ArgumentException("Discount must be between 1 and 99 percent.");

        decimal discountMultiplier = 1 - (percentageOff / 100m);
        Price = _price * discountMultiplier;  // Uses private setter — valid internal update
        Console.WriteLine($"Discount applied: {_name} is now {_price:C}");
    }

    public void AddStock(int units)
    {
        if (units <= 0)
            throw new ArgumentException("Units to add must be positive.");
        StockQuantity += units;
        Console.WriteLine($"Stock updated: {_name} now has {_stockQuantity} units.");
    }

    public override string ToString() =>
        $"{_name} | Price: {_price:C} | Stock: {_stockQuantity} | In Stock: {IsInStock}";
}

class Program
{
    static void Main()
    {
        // Using the overloaded constructor — no stock yet
        Product laptop = new Product("ProBook Laptop", 1299.99m);

        // Using the full constructor
        Product headphones = new Product("Studio Headphones", 249.99m, 50);

        laptop.AddStock(10);
        headphones.ApplyDiscount(15);

        Console.WriteLine();
        Console.WriteLine(laptop);
        Console.WriteLine(headphones);

        // This would cause a compile error — Price has a private setter:
        // laptop.Price = 999m;  // ERROR: 'Product.Price.set' is inaccessible
    }
}

using System;
using System.Collections.Generic;

public class Employee
{
    // Static field: shared by ALL Employee objects.
    // Counts every employee ever created — belongs to the class, not any one employee.
    private static int _totalEmployeesCreated = 0;

    // Static read-only: a company-wide policy value. Same for every employee.
    public static readonly decimal MinimumHourlyRate = 11.44m; // UK NMW 2024

    // Instance fields: unique to each employee object
    private readonly int _employeeId;
    private string _fullName;
    private decimal _hourlyRate;

    // Static constructor: runs ONCE when the class is first used, before any objects exist.
    // Useful for initialising heavy static resources (database connections, config loading).
    static Employee()
    {
        Console.WriteLine("[Employee class initialised — static constructor ran]");
    }

    public Employee(string fullName, decimal hourlyRate)
    {
        _totalEmployeesCreated++;          // Increments the class-level counter
        _employeeId = _totalEmployeesCreated; // Each employee gets the next ID

        FullName = fullName;
        HourlyRate = hourlyRate;
    }

    public string FullName
    {
        get => _fullName;
        set
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Full name is required.");
            _fullName = value;
        }
    }

    public decimal HourlyRate
    {
        get => _hourlyRate;
        set
        {
            if (value < MinimumHourlyRate)
                throw new ArgumentException(
                    $"Hourly rate {value:C} is below the minimum wage of {MinimumHourlyRate:C}.");
            _hourlyRate = value;
        }
    }

    public int EmployeeId => _employeeId;

    // Static property: read the class-level counter from outside
    public static int TotalEmployeesCreated => _totalEmployeesCreated;

    // Static method: operates on the TYPE, not a specific instance.
    // Notice it has no access to _fullName or _hourlyRate — those are instance state.
    public static decimal CalculateWeeklyPay(decimal hourlyRate, int hoursWorked)
    {
        if (hoursWorked < 0 || hoursWorked > 168)
            throw new ArgumentException("Hours worked must be between 0 and 168 per week.");

        decimal overtime = hoursWorked > 40 ? (hoursWorked - 40) * hourlyRate * 1.5m : 0m;
        decimal regularPay = Math.Min(hoursWorked, 40) * hourlyRate;
        return regularPay + overtime;
    }

    // Instance method: uses THIS employee's specific hourly rate
    public decimal GetWeeklyPay(int hoursWorked)
    {
        // Delegates to the static version — no code duplication
        return CalculateWeeklyPay(_hourlyRate, hoursWorked);
    }

    public override string ToString() =>
        $"Employee #{_employeeId}: {_fullName} @ {_hourlyRate:C}/hr";
}

class Program
{
    static void Main()
    {
        // Static constructor fires here, the first time Employee is used
        Console.WriteLine($"Employees before hiring: {Employee.TotalEmployeesCreated}");
        Console.WriteLine($"Minimum wage: {Employee.MinimumHourlyRate:C}\n");

        Employee alice = new Employee("Alice Nguyen", 18.50m);
        Employee bob   = new Employee("Bob Okafor", 22.00m);
        Employee carol = new Employee("Carol Singh", 11.44m); // Exactly minimum wage — valid

        Console.WriteLine($"\nTotal employees hired: {Employee.TotalEmployeesCreated}");
        Console.WriteLine();

        // Instance method — uses Alice's specific rate
        Console.WriteLine($"{alice.FullName}'s pay for 45hrs: {alice.GetWeeklyPay(45):C}");

        // Static method — useful when you don't have an Employee object yet (e.g. salary negotiation UI)
        decimal negotiatedPay = Employee.CalculateWeeklyPay(25.00m, 40);
        Console.WriteLine($"Negotiated offer for 40hrs @ £25/hr: {negotiatedPay:C}");

        Console.WriteLine();
        Console.WriteLine(alice);
        Console.WriteLine(bob);
        Console.WriteLine(carol);

        // This would throw at runtime:
        // Employee underpaid = new Employee("Dave", 9.00m);
        // ArgumentException: Hourly rate £9.00 is below the minimum wage of £11.44.
    }
}

using System;

public class ShoppingCart
{
    public string CustomerName { get; set; }
    public decimal TotalValue  { get; set; }

    public ShoppingCart(string customerName, decimal totalValue)
    {
        CustomerName = customerName;
        TotalValue   = totalValue;
    }

    // Returns a genuine independent copy of this cart — a 'deep clone'
    public ShoppingCart Clone()
    {
        return new ShoppingCart(CustomerName, TotalValue);
    }

    public override string ToString() =>
        $"Cart[{CustomerName}, Total: {TotalValue:C}]";
}

class Program
{
    // This method receives a REFERENCE — modifying the cart here affects the caller's cart
    static void ApplyVIPDiscount(ShoppingCart cart)
    {
        cart.TotalValue *= 0.85m;  // 15% discount applied to the ORIGINAL object
        Console.WriteLine($"  Inside method: {cart}");
    }

    // This method receives a reference to a CLONED cart — caller's original is untouched
    static ShoppingCart PreviewVIPDiscount(ShoppingCart cart)
    {
        ShoppingCart preview = cart.Clone();  // Work on the copy
        preview.TotalValue  *= 0.85m;
        return preview;
    }

    static void Main()
    {
        ShoppingCart aliceCart = new ShoppingCart("Alice", 200m);

        // --- REFERENCE TRAP DEMO ---
        Console.WriteLine("=== Reference Assignment Trap ===");
        ShoppingCart aliasCart = aliceCart;  // NOT a copy — same object, two variable names

        aliasCart.TotalValue = 999m;  // This changes aliceCart too!
        Console.WriteLine($"aliceCart after aliasCart change: {aliceCart}");  // Shows 999!
        Console.WriteLine($"aliasCart:                        {aliasCart}");
        Console.WriteLine($"Same object? {ReferenceEquals(aliceCart, aliasCart)}");

        Console.WriteLine();

        // --- METHOD REFERENCE DEMO ---
        Console.WriteLine("=== Passing to Method — Reference Behaviour ===");
        ShoppingCart bobCart = new ShoppingCart("Bob", 300m);
        Console.WriteLine($"Before discount call: {bobCart}");
        ApplyVIPDiscount(bobCart);                    // Mutates Bob's cart inside the method
        Console.WriteLine($"After discount call:  {bobCart}");  // Already changed!

        Console.WriteLine();

        // --- CORRECT CLONE DEMO ---
        Console.WriteLine("=== Safe Preview Using Clone ===");
        ShoppingCart carolCart  = new ShoppingCart("Carol", 150m);
        ShoppingCart discounted = PreviewVIPDiscount(carolCart);
        Console.WriteLine($"Original carol cart:    {carolCart}");   // Unchanged
        Console.WriteLine($"Discounted preview cart: {discounted}"); // Clone with discount
        Console.WriteLine($"Same object? {ReferenceEquals(carolCart, discounted)}");
    }
}