Operator Overloading in C# — How, Why and When to Use It

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