> ## 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
The `<` (less than) operator is a binary relational operator that evaluates whether its left-hand operand is strictly less than its right-hand operand, returning a `bool` result.
```csharp theme={"dark"}
int leftOperand = 5;
int rightOperand = 10;
bool result = leftOperand < rightOperand; // Evaluates to true
```
**Type Support and Numeric Promotion**
The operator is natively defined for all built-in integral (`sbyte`, `byte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `nint`, `nuint`) and floating-point (`float`, `double`, `decimal`) numeric types. When operands are of mixed numeric types, C# applies implicit numeric promotion to convert them to a common type before evaluation.
The operator is also natively supported for:
* `char`: Evaluates the underlying 16-bit Unicode integer values.
* `enum`: Evaluates the underlying integral values of the enumeration members.
* Pointer types (`T*`): Evaluates the memory addresses held by the pointers, requiring an `unsafe` context.
**Floating-Point Evaluation Rules**
When evaluating `float` or `double` types, the operator adheres to IEEE 754 standards. If either the left or right operand evaluates to Not-a-Number (`NaN`), the `<` operator strictly returns `false`.
```csharp theme={"dark"}
double x = double.NaN;
double y = 5.0;
bool isLess = x < y; // Evaluates to false
```
**Lifted Operators for Nullable Types**
For nullable value types (`T?`), C# provides lifted operators. The lifted `<` operator safely evaluates the operands by checking their `HasValue` properties rather than blindly unwrapping them. If either or both operands evaluate to `null` (meaning `HasValue` is `false`), the result of the `<` operation is always `false`.
```csharp theme={"dark"}
int? a = null;
int? b = 10;
bool isLess = a < b; // Evaluates to false
```
**Operator Overloading**
User-defined types (`class`, `struct`, or `record`) can overload the `<` operator to define custom comparison logic. C# enforces a strict pairing rule for relational operators: if a type overloads the `<` operator, it must also explicitly overload the `>` (greater than) operator.
```csharp theme={"dark"}
public readonly struct Temperature
{
public double Value { get; }
public Temperature(double value) => Value = value;
public static bool operator <(Temperature left, Temperature right)
{
return left.Value < right.Value;
}
public static bool operator >(Temperature left, Temperature right)
{
return left.Value > right.Value;
}
}
```
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
