¿Por qué> = devuelve falso cuando == devuelve verdadero para valores nulos?

¿Tengo dos variables de tipo int? (o Nullable <int> si lo desea). Quería hacer una comparación mayor o igual (> =) en las dos variables, pero resulta que esto devuelve falso si ambas variables son nulas, mientras que obviamente el operador == devuelve verdadero.

¿Puede alguien explicarme por qué eso es lógico porque la definición semántica del operador> = contiene la palabra "o"?

Hubo un gran debate sobre esta rareza cuando la función se diseñó originalmente en C # 2.0. El problema es que los usuarios de C # están completamente acostumbrados a que esto sea significativo:

if(someReference == null)

Al extender la igualdad a tipos de valor que aceptan valores NULL, tiene las siguientes opciones.

1. La igualdad anulable se levanta realmente . Si uno o ambos operandos es nulo, el resultado no es ni verdadero ni falso, sino nulo. En este caso, puede:

   • a) Haga que sea ilegal tener una igualdad de tipo de valor anulable en una ifdeclaración, porque la ifdeclaración necesita un bool, no un bool anulable. En su lugar, solicite que todos usen HasValuesi quieren comparar con nulo. Esto es prolijo e irritante.

   • b) Convierta automáticamente nulo en falso. La desventaja de esto es que x==nulldevuelve falso si x es nulo, lo cual es confuso y va en contra de la comprensión de las personas sobre las comparaciones nulas con tipos de referencia.

2. La igualdad anulable no se levanta. La igualdad que acepta valores NULL es verdadera o falsa, y la comparación con nulo es una comprobación nula. Esto hace que la igualdad anulable sea incompatible con la desigualdad anulable.

Ninguna de estas opciones es obviamente correcta; todos tienen pros y contras. VBScript elige 1b, por ejemplo. Después de mucho debate, el equipo de diseño de C # eligió el n. ° 2.

Porque la igualdad se define por separado de la comparabilidad.
Puede probar x == nullpero no x > nulltiene sentido. En C # siempre será falso.

Otra forma de describir '> =' es: No menor que. Sin mención de iguales. Tan pronto como uno de los operandos en una prueba de no igualdad sea nulo, el resultado también será desconocido (es nulo). Sin embargo, si desea saber si ambos operandos son nulos, entonces Null == Null es una prueba razonable (debería dar como resultado verdadero). Deshacerse de la parte de desigualdad del operador marca la diferencia.

El siguiente ejemplo de código de http://msdn.microsoft.com/en-us/library/2cf62fcy.aspx#sectionToggle4 resume cómo C # trata Null:

int? num1 = 10;   
int? num2 = null;   
if (num1 >= num2)   
{   
    Console.WriteLine("num1 is greater than or equal to num2");   
}   
else   
{   
    // This clause is selected, but num1 is not less than num2.   
    Console.WriteLine("num1 >= num2 returned false (but num1 < num2 also is false)");   
}   

if (num1 < num2)   
{   
    Console.WriteLine("num1 is less than num2");   
}   
else   
{   
    // The else clause is selected again, but num1 is not greater than   
    // or equal to num2.   
    Console.WriteLine("num1 < num2 returned false (but num1 >= num2 also is false)");   
}   

if (num1 != num2)   
{   
    // This comparison is true, num1 and num2 are not equal.   
    Console.WriteLine("Finally, num1 != num2 returns true!");   
}   

// Change the value of num1, so that both num1 and num2 are null.   
num1 = null;   
if (num1 == num2)   
{   
    // The equality comparison returns true when both operands are null.   
    Console.WriteLine("num1 == num2 returns true when the value of each is null");   
}   

/* Output:   
 * num1 >= num2 returned false (but num1 < num2 also is false)   
 * num1 < num2 returned false (but num1 >= num2 also is false)   
 * Finally, num1 != num2 returns true!   
 * num1 == num2 returns true when the value of each is null   
 */   

>=opera con un valor numérico; que nulo no es.

Podría sobrecargar al >=operador para que le proporcione lo que desea en un tipo específico.

NULL no es cero (valor numérico o binario), una cadena de longitud cero o un espacio en blanco (valor de carácter). Por lo tanto, cualquier operador de comparación siempre devolverá falso. Leer más sobre esto aquí

¿Qué valores esperarías?

nulo == nulo verdadero

nulo> = nulo falso

nulo> nulo falso

nulo <= nulo falso

nulo <nulo falso

nulo! = nulo falso

1 == nulo falso

1> = nulo falso

1> nulo falso

1 <= nulo falso

1 <nulo falso

1! = Nulo verdadero también conocido como! (1 == nulo)

> = solo significa "mayor o igual que" cuando se usa de esa manera específica bien definida. Cuando se usa en una clase con operadores sobrecargados, significa cualquier cosa que el desarrollador de la clase quiera que signifique. Cuando se aplica a una clase similar a una cadena, puede significar "ordena igual o superior" o puede significar "la misma longitud o más".

Dado que, de forma predeterminada, an intno puede ser nulo y su valor se establecerá en 0, el operador de> y <, que está construido para inttipo, espera trabajar con valuesy no con nulls.

vea mi respuesta a una pregunta similar en la que escribí algunas formas de manejar nullable intcon los operadores less <y https://stackoverflow.com/a/51507612/7003760greater >