C# Operator Overloading: No GetHashCode Breaks HashSet

using System;

// A simple struct representing a temperature reading
public struct Temperature
{
    public double Celsius { get; }

    public Temperature(double celsius)
    {
        Celsius = celsius;
    }

    // The compiler turns 'temp1 + temp2' into this static method call.
    // Both parameters must relate to our type — here both ARE our type.
    public static Temperature operator +(Temperature left, Temperature right)
    {
        return new Temperature(left.Celsius + right.Celsius);
    }

    // Scalar multiplication: allow 'temperature * factor'
    // One parameter is our type, the other is double — that's allowed.
    public static Temperature operator *(Temperature temp, double factor)
    {
        return new Temperature(temp.Celsius * factor);
    }

    // Override ToString so our output is readable
    public override string ToString() => $"{Celsius:F1}°C";
}

class Program
{
    static void Main()
    {
        var morningTemp = new Temperature(18.5);
        var afternoonRise = new Temperature(6.0);

        // This calls operator+ behind the scenes
        Temperature peakTemp = morningTemp + afternoonRise;
        Console.WriteLine($"Peak temperature: {peakTemp}");

        // This calls operator* — scalar scaling
        Temperature doubled = morningTemp * 2.0;
        Console.WriteLine($"Doubled morning: {doubled}");
    }
}

using System;
using System.Collections.Generic;

public readonly struct Money : IEquatable<Money>
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        if (string.IsNullOrWhiteSpace(currency))
            throw new ArgumentException("Currency code cannot be empty.", nameof(currency));

        Amount = Math.Round(amount, 2); // Money is always 2 decimal places
        Currency = currency.ToUpperInvariant();
    }

    // ── Arithmetic operators ────────────────────────────────────────────

    public static Money operator +(Money left, Money right)
    {
        // Business rule lives HERE, not scattered across callers
        EnsureSameCurrency(left, right, "+");
        return new Money(left.Amount + right.Amount, left.Currency);
    }

    public static Money operator -(Money left, Money right)
    {
        EnsureSameCurrency(left, right, "-");
        return new Money(left.Amount - right.Amount, left.Currency);
    }

    // Scale by a factor — e.g. applying a tax rate
    public static Money operator *(Money money, decimal factor)
    {
        return new Money(money.Amount * factor, money.Currency);
    }

    // Allow factor * money as well (commutativity for the caller's convenience)
    public static Money operator *(decimal factor, Money money) => money * factor;

    public static bool operator >(Money left, Money right)
    {
        EnsureSameCurrency(left, right, ">");
        return left.Amount > right.Amount;
    }

    public static bool operator <(Money left, Money right)
    {
        EnsureSameCurrency(left, right, "<");
        return left.Amount < right.Amount;
    }

    // ── Equality operators ──────────────────────────────────────────────
    // Rule: overload == → must also overload !=
    // Rule: overload == → must also override Equals and GetHashCode

    public static bool operator ==(Money left, Money right) => left.Equals(right);
    public static bool operator !=(Money left, Money right) => !left.Equals(right);

    // IEquatable<Money> — used by List.Contains, LINQ, etc. without boxing
    public bool Equals(Money other)
        => Amount == other.Amount &&
           string.Equals(Currency, other.Currency, StringComparison.OrdinalIgnoreCase);

    // Required override when Equals is overridden — used by dictionaries/hashsets
    public override bool Equals(object? obj)
        => obj is Money other && Equals(other);

    public override int GetHashCode()
        => HashCode.Combine(Amount, Currency.ToUpperInvariant());

    public override string ToString() => $"{Currency} {Amount:F2}";

    // ── Private helpers ─────────────────────────────────────────────────

    private static void EnsureSameCurrency(Money left, Money right, string op)
    {
        if (!string.Equals(left.Currency, right.Currency, StringComparison.OrdinalIgnoreCase))
            throw new InvalidOperationException(
                $"Cannot apply '{op}' to {left.Currency} and {right.Currency}. " +
                $"Convert to the same currency first.");
    }
}

class Program
{
    static void Main()
    {
        var price = new Money(19.99m, "USD");
        var shipping = new Money(4.99m, "USD");
        var taxRate = 0.08m; // 8% tax

        Money subtotal = price + shipping;          // calls operator+
        Money tax = subtotal * taxRate;              // calls operator*
        Money total = subtotal + tax;

        Console.WriteLine($"Price:    {price}");
        Console.WriteLine($"Shipping: {shipping}");
        Console.WriteLine($"Tax (8%): {tax}");
        Console.WriteLine($"Total:    {total}");
        Console.WriteLine();

        // Equality check works correctly
        var duplicatePrice = new Money(19.99m, "USD");
        Console.WriteLine($"price == duplicatePrice: {price == duplicatePrice}");
        Console.WriteLine($"price == total:          {price == total}");
        Console.WriteLine();

        // Works correctly in a HashSet because GetHashCode is consistent with Equals
        var priceSet = new HashSet<Money> { price, shipping, duplicatePrice };
        Console.WriteLine($"HashSet count (price added twice): {priceSet.Count}");
        Console.WriteLine();

        // Comparison operators
        Console.WriteLine($"total > price: {total > price}");

        // This would throw — different currencies
        try
        {
            var euros = new Money(10.00m, "EUR");
            var _ = price + euros;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine($"Expected error: {ex.Message}");
        }
    }
}

using System;

public struct Percentage
{
    public double Value { get; } // 0.0 to 100.0

    public Percentage(double value)
    {
        // Clamp silently — percentages can't exceed 100% or go below 0%
        Value = Math.Clamp(value, 0.0, 100.0);
    }

    // Unary negation — "remaining percentage"
    // e.g. !Percentage(30) → Percentage(70) means "70% remaining"
    public static Percentage operator !(Percentage p)
        => new Percentage(100.0 - p.Value);

    // Unary increment — nudge up by 1 point
    public static Percentage operator ++(Percentage p)
        => new Percentage(p.Value + 1.0);

    // Binary addition
    public static Percentage operator +(Percentage left, Percentage right)
        => new Percentage(left.Value + right.Value); // clamped by constructor

    // Comparison pair — C# REQUIRES both < and > if you want either
    public static bool operator <(Percentage left, Percentage right)
        => left.Value < right.Value;

    public static bool operator >(Percentage left, Percentage right)
        => left.Value > right.Value;

    // Equality pair — C# REQUIRES both == and != if you want either
    public static bool operator ==(Percentage left, Percentage right)
        => Math.Abs(left.Value - right.Value) < 0.0001; // float-safe comparison

    public static bool operator !=(Percentage left, Percentage right)
        => !(left == right);

    public override bool Equals(object? obj)
        => obj is Percentage other && this == other;

    public override int GetHashCode() => Math.Round(Value, 4).GetHashCode();

    public override string ToString() => $"{Value:F1}%";
}

class Program
{
    static void Main()
    {
        var discount = new Percentage(30.0);
        var extraOff = new Percentage(15.0);

        // += is automatically derived from operator+ — we never wrote it
        Percentage combined = discount;
        combined += extraOff;
        Console.WriteLine($"Combined discount: {combined}");

        // Unary ! gives us the "remaining" percentage
        Percentage customerPays = !combined;
        Console.WriteLine($"Customer pays: {customerPays}");

        // ++ operator
        Percentage bumped = discount;
        bumped++;
        Console.WriteLine($"Bumped discount: {bumped}");

        // Clamping — adding beyond 100% is safe
        var huge = new Percentage(80.0) + new Percentage(80.0);
        Console.WriteLine($"Clamped result: {huge}");

        // Comparison
        Console.WriteLine($"discount > extraOff: {discount > extraOff}");

        // Demonstrating that == and != must be paired
        Console.WriteLine($"discount == extraOff: {discount == extraOff}");
        Console.WriteLine($"discount != extraOff: {discount != extraOff}");
    }
}

using System;

public readonly struct Celsius
{
    public double Degrees { get; }

    public Celsius(double degrees) => Degrees = degrees;

    // IMPLICIT: wrapping a double in Celsius is always safe — no information lost
    // Caller can write: Celsius temp = 100.0;  (no cast needed)
    public static implicit operator Celsius(double degrees)
        => new Celsius(degrees);

    // EXPLICIT: converting to Fahrenheit changes the scale.
    // Caller must write: double f = (double)temp;  to acknowledge the conversion.
    // We return double because Fahrenheit is just a double to the outside world here.
    public static explicit operator double(Celsius celsius)
        => (celsius.Degrees * 9.0 / 5.0) + 32.0;

    // Arithmetic still works — combining with previous section's lessons
    public static Celsius operator +(Celsius left, Celsius right)
        => new Celsius(left.Degrees + right.Degrees);

    public override string ToString() => $"{Degrees:F2}°C";
}

// A lightweight struct that ONLY holds Fahrenheit — shows cross-type conversion
public readonly struct Fahrenheit
{
    public double Degrees { get; }
    public Fahrenheit(double degrees) => Degrees = degrees;

    // Explicit conversion FROM Celsius TO Fahrenheit
    public static explicit operator Fahrenheit(Celsius c)
        => new Fahrenheit((c.Degrees * 9.0 / 5.0) + 32.0);

    // Explicit conversion back from Fahrenheit to Celsius
    public static explicit operator Celsius(Fahrenheit f)
        => new Celsius((f.Degrees - 32.0) * 5.0 / 9.0);

    public override string ToString() => $"{Degrees:F2}°F";
}

class Program
{
    static void Main()
    {
        // Implicit conversion — no cast syntax required
        Celsius boiling = 100.0;  // implicit operator Celsius(double) fires here
        Console.WriteLine($"Boiling point: {boiling}");

        // Explicit conversion to double — caller must acknowledge scale change
        double boilingF = (double)boiling;
        Console.WriteLine($"In Fahrenheit (as double): {boilingF:F2}");

        // Explicit conversion to Fahrenheit struct
        Fahrenheit boilingFahrenheit = (Fahrenheit)boiling;
        Console.WriteLine($"In Fahrenheit (as struct): {boilingFahrenheit}");

        // Round-trip: Fahrenheit → Celsius → back to Fahrenheit
        var bodyTemp = new Fahrenheit(98.6);
        Celsius bodyTempC = (Celsius)bodyTemp;
        Fahrenheit roundTrip = (Fahrenheit)bodyTempC;
        Console.WriteLine($"Body temp round-trip: {bodyTemp} → {bodyTempC} → {roundTrip}");

        // Arithmetic on Celsius still works naturally
        Celsius morning = 15.0;   // implicit
        Celsius afternoon = 8.0;  // implicit
        Celsius peak = morning + afternoon;
        Console.WriteLine($"Peak: {peak}");
    }
}

using System;

// Models a three-state logical value: True, False, Indeterminate
public struct ThreeState
{
    // Internal representation:
    //  1 = True, -1 = False, 0 = Indeterminate
    private readonly sbyte _value;

    private ThreeState(sbyte value) => _value = value;

    public static readonly ThreeState True = new ThreeState(1);
    public static readonly ThreeState False = new ThreeState(-1);
    public static readonly ThreeState Indeterminate = new ThreeState(0);

    // The 'true' operator: returns true if the value is definitely true
    public static bool operator true(ThreeState x) => x._value == 1;

    // The 'false' operator: returns true if the value is definitely false
    public static bool operator false(ThreeState x) => x._value == -1;

    // Logical AND: & operator (needed before && can be used)
    public static ThreeState operator &(ThreeState left, ThreeState right)
    {
        // If either is false, result is false
        if (left._value == -1 || right._value == -1)
            return False;
        // If either is indeterminate, result is indeterminate
        if (left._value == 0 || right._value == 0)
            return Indeterminate;
        // Both are true
        return True;
    }

    // Logical OR: | operator (needed before || can be used)
    public static ThreeState operator |(ThreeState left, ThreeState right)
    {
        // If either is true, result is true
        if (left._value == 1 || right._value == 1)
            return True;
        // If either is indeterminate, result is indeterminate
        if (left._value == 0 || right._value == 0)
            return Indeterminate;
        // Both are false
        return False;
    }

    // Logical NOT: ! operator
    public static ThreeState operator !(ThreeState x)
    {
        return x._value switch
        {
            1 => False,
            -1 => True,
            _ => Indeterminate
        };
    }

    // Override Equals/GetHashCode for consistency
    public override bool Equals(object? obj) => obj is ThreeState other && _value == other._value;
    public override int GetHashCode() => _value.GetHashCode();

    public override string ToString() => _value switch
    {
        1 => "True",
        -1 => "False",
        _ => "Indeterminate"
    };
}

class Program
{
    static void Main()
    {
        var t = ThreeState.True;
        var f = ThreeState.False;
        var i = ThreeState.Indeterminate;

        // Short-circuit && works because true/false operators are defined
        // The compiler generates: if (t) then evaluate f else false
        Console.WriteLine($"t && f: {t && f}");  // False
        Console.WriteLine($"f && t: {f && t}");  // False (short-circuits, no evaluation of right)
        Console.WriteLine($"t || f: {t || f}");  // True (short-circuits, no evaluation of right)
        Console.WriteLine($"f || t: {f || t}");  // True
        Console.WriteLine($"i && t: {i && t}");  // ? (Indeterminate, because i is not true nor false)
        // For i && t: false operator on i returns false (i is not definitely false), so conditional evaluates right side.
        // i && t resolves to i & t = Indeterminate & True = Indeterminate
        Console.WriteLine($"!t: {!t}");
    }
}

// io.thecodeforge — csharp tutorial

public readonly struct Money
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        Amount = amount;
        Currency = currency ?? throw new ArgumentNullException(nameof(currency));
    }

    public static Money operator +(Money left, Money right)
    {
        if (left.Currency != right.Currency)
            throw new InvalidOperationException($"Currency mismatch: {left.Currency} vs {right.Currency}");
        return new Money(left.Amount + right.Amount, left.Currency);
    }

    public static Money operator *(Money money, decimal multiplier)
    {
        return new Money(money.Amount * multiplier, money.Currency);
    }
}

// Usage:
var salary = new Money(5000, "USD");
var bonus = new Money(1000, "USD");
var total = salary + bonus;
var doubled = salary * 2;
Console.WriteLine(total.Amount);  // 6000
Console.WriteLine(doubled.Amount); // 10000

// io.thecodeforge — csharp tutorial

public readonly struct Counter
{
    public int Value { get; }

    public Counter(int value) => Value = value;

    // One method handles both prefix (++x) and postfix (x++)
    public static Counter operator ++(Counter c) => new Counter(c.Value + 1);

    // Overload ! to mean "is zero" — domain-specific
    public static bool operator !(Counter c) => c.Value == 0;
}

// Usage:
var c = new Counter(5);
c++;               // postfix: returns old value (5), c becomes 6
++c;               // prefix: returns new value (7), c becomes 7
Console.WriteLine(c.Value);  // 7
Console.WriteLine(!c);       // False (Value is not 0)

var zero = new Counter(0);
Console.WriteLine(!zero);    // True

// io.thecodeforge — csharp tutorial

public readonly struct Money
{
    private readonly decimal _amount;
    private readonly string _currency;

    public Money(decimal amount, string currency)
    {
        _amount = amount;
        _currency = currency;
    }

    // Safe — no data loss
    public static implicit operator decimal(Money m) => m._amount;

    // Risky — we drop currency and may round
    public static explicit operator Money(decimal d) =>
        new Money(Math.Round(d, 2), "USD");
}

var price = new Money(19.99m, "USD");
decimal value = price; // implicit — reads clearly

var fromDecimal = (Money)20.001m; // explicit — you asked for it
// fromDecimal._amount == 20.00

// io.thecodeforge — csharp tutorial

public readonly struct Validated<T>
{
    private readonly T _value;
    private readonly bool _isValid;

    public Validated(T value, bool isValid)
    {
        _value = value;
        _isValid = isValid;
    }

    public static bool operator true(Validated<T> v) => v._isValid;
    public static bool operator false(Validated<T> v) => !v._isValid;

    // Required for && to work
    public static Validated<T> operator &(Validated<T> a, Validated<T> b) =>
        new Validated<T>(a._isValid ? b._value : a._value, a._isValid && b._isValid);
}

var a = new Validated<int>(42, true);
var b = new Validated<int>(0, false);

if (a && b) Console.WriteLine("Both valid");
else Console.WriteLine("Short-circuited");
// Output: Short-circuited — never evaluates b since a is false? No, a is true.
// b operator false is called, & operator short-circuits via false.

public readonly struct Money
{
    public long Cents { get; }
    public Money(long cents) => Cents = cents;

    // Unchecked operator (default)
    public static Money operator +(Money a, Money b)
    {
        unchecked
        {
            return new Money(a.Cents + b.Cents);
        }
    }

    // Checked operator
    public static Money operator checked +(Money a, Money b)
    {
        checked
        {
            return new Money(a.Cents + b.Cents);
        }
    }
}

// Usage
var big = new Money(long.MaxValue);
var result = checked(big + new Money(1)); // throws OverflowException

public readonly struct Money
{
    public decimal Amount { get; }
    public Money(decimal amount) => Amount = amount;

    // Implicit conversion from decimal (safe)
    public static implicit operator Money(decimal value) => new Money(value);

    // Explicit conversion to decimal (may lose precision)
    public static explicit operator decimal(Money money) => money.Amount;

    // Explicit conversion to int (may truncate)
    public static explicit operator int(Money money) => (int)money.Amount;
}

// Usage
Money salary = 50000.75m;          // implicit
decimal salaryDecimal = (decimal)salary; // explicit
int salaryInt = (int)salary;            // explicit, truncates to 50000

// Operator overloading
public readonly struct Money
{
    public decimal Amount { get; }
    public Money(decimal amount) => Amount = amount;

    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
}

// Extension method alternative
public static class MoneyExtensions
{
    public static Money Add(this Money a, Money b) => new Money(a.Amount + b.Amount);
}

// Usage
var sum1 = money1 + money2;          // operator
var sum2 = money1.Add(money2);       // extension