> ## 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.
# C# 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`.
```csharp theme={"dark"}
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`.
```csharp theme={"dark"}
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`.
```csharp theme={"dark"}
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.
```csharp theme={"dark"}
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;
}
}
```
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
