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.

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<T>). 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.

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.

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).

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;
    }
}

Master C# with Deep Grasping Methodology!

Learn More