Less Than Or Equal To

The <= (less than or equal to) operator is a binary relational operator that evaluates to true if the left-hand operand is less than or equal in value to the right-hand operand; otherwise, it evaluates to false.

bool result = leftOperand <= rightOperand;

Type Support and Mechanics

The compiler provides built-in support for the <= operator across several primitive, value, and pointer types:

• Numeric Types: Supports all integral (sbyte, byte, short, ushort, int, uint, long, ulong, nint, nuint) and floating-point (float, double, decimal) types. Implicit numeric conversions are applied if the operands are of different numeric types.
• Characters: Supports char operands by comparing their underlying 16-bit Unicode integer values.
• Enumerations: Supports enum types by comparing the underlying integral values of the enumeration members.
• Pointer Types: Supports pointer types (T*) within an unsafe context. The operator evaluates the numeric values of the memory addresses held by the pointers.

Floating-Point NaN Behavior

When operating on float or double types, the <= operator adheres to IEEE 754 standards regarding Not-a-Number (NaN) values. If either the left-hand operand, the right-hand operand, or both evaluate to NaN, the <= operator returns false.

double x = double.NaN;
double y = 5.0;
bool result = x <= y; // Evaluates to false

Lifted Operators for Nullable Types

For nullable value types (T?), the compiler automatically provides a lifted version of the <= operator. The lifted operator evaluates the .HasValue property of both operands:

• If either or both operands are null, the operation evaluates to false.
• If both operands possess a value, the operator unwraps them and applies the underlying <= implementation of type T.

int? a = null;
int? b = 10;
bool result = a <= b; // Evaluates to false

Operator Overloading

User-defined types (class, struct, or record) can overload the <= operator to provide custom comparison semantics. C# enforces a matched-pair rule for relational operators: if a type overloads the <= operator, it must also explicitly overload the >= (greater than or equal to) operator.

public readonly struct Temperature
{
    public double DegreesCelsius { get; }

    public Temperature(double degreesCelsius) => DegreesCelsius = degreesCelsius;

    public static bool operator <=(Temperature left, Temperature right)
    {
        return left.DegreesCelsius <= right.DegreesCelsius;
    }

    // The compiler requires the matching >= operator
    public static bool operator >=(Temperature left, Temperature right)
    {
        return left.DegreesCelsius >= right.DegreesCelsius;
    }
}

Master C# with Deep Grasping Methodology!

Learn More