valor - nullable property c#

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

Question

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

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

Answer 1

> = solo significa "mayor que o igual" 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 cuerda, podría significar "ordena igual o más alto" o podría significar "la misma longitud o más".

Answer 2

¿Qué valores esperarías?

null == null true

null> = null falso

null> null false

null <= nulo falso

null <nulo falso

null! = nulo falso

1 == nulo falso

1> = nulo falso

1> nulo falso

1 <= nulo falso

1 <nulo falso

1! = Null true aka! (1 == nulo)

Answer 3

Hubo un gran debate sobre esta rareza cuando la función fue diseñada 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 valores que se pueden anotar, tiene las siguientes opciones.

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

   • a) Hace que sea ilegal tener una igualdad de tipo de valor que admite valores nulos en una instrucción if , porque la instrucción if necesita un bool, no un bool nullable. En cambio, requieren que todos usen HasValue si quieren comparar con nulo. Esto es detallado e irritante.

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

2. La igualdad anulable no se levanta. La igualdad anulable es verdadera o falsa, y la comparación con nulo es una verificación nula. Esto hace que la igualdad anulable sea incoherente con la desigualdad anulable.

Ninguna de estas elecciones 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 # 2.

Answer 4

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

Answer 5

Otra forma de describir ''> ='' es: no menos que. Sin mención de iguales. Tan pronto como uno de los operandos en una prueba de no igualdad es nulo, el resultado es desconocido también (es nulo). Sin embargo, si quiere saber si ambos operandos son nulos, entonces nulo == nulo 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 a 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   
 */   

Answer 6

Porque la Igualdad se define por separado de la Comparabilidad.
Puedes probar x == null pero x > null tiene sentido. En C # siempre será falso.

Answer 7

>= opera en un valor numérico; cual nulo no es

Podría overload el operador >= para proporcionarle lo que desea en un tipo específico.