> ## 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# Greater Than Or Equal To The `>=` (greater than or equal to) operator is a binary relational operator that compares two operands and returns a `bool` value. It evaluates to `true` if the left-hand operand is greater than or equal in value to the right-hand operand; otherwise, it evaluates to `false`. ```csharp theme={"dark"} bool result = leftOperand >= rightOperand; ``` ## Supported Built-in Types The compiler provides built-in support for the `>=` operator across the following types: * **Numeric types:** All integral (`sbyte`, `byte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `nint`, `nuint`) and floating-point (`float`, `double`, `decimal`) types. * **`char`:** Operands are compared based on their underlying 16-bit Unicode integer values. * **`enum`:** Operands are compared based on the values of their underlying integral types. ## Nullable Value Types For the supported built-in types, the `>=` operator is lifted to support nullable value types (`Nullable`). When comparing nullable types, if either the left operand, the right operand, or both are `null`, the `>=` operator evaluates to `false`. The operator only compares the underlying values if both operands are non-null. ```csharp theme={"dark"} int? a = null; int? b = 5; bool result1 = a >= b; // Evaluates to false bool result2 = a >= a; // Evaluates to false ``` ## Implicit Conversions When the left and right operands are of different supported types, the C# compiler applies implicit numeric promotion to convert them to a common type before performing the comparison. For example, comparing an `int` and a `double` will result in the `int` being implicitly converted to a `double` prior to evaluation. ## Floating-Point Edge Cases When working with `float` or `double`, the `>=` operator adheres to IEEE 754 standards regarding Not-a-Number (`NaN`) values. If either the left operand, the right 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 ``` ## Operator Overloading User-defined types (`class` or `struct`) 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 `<=` (less than or equal to) operator. Failure to do so results in a compiler error (CS0216). ```csharp theme={"dark"} public readonly struct CustomType { private readonly int _value; public CustomType(int value) => _value = value; public static bool operator >=(CustomType left, CustomType right) { return left._value >= right._value; } // The paired <= operator is mandatory when >= is overloaded public static bool operator <=(CustomType left, CustomType right) { return left._value <= right._value; } } ```

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More