Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

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