c# - validar - ¿Cómo manejan los tipos anulables los valores nulos con los operadores de comparación?

string nullable c#

Question

¿Alguien tiene información concreta sobre cómo C # maneja las comparaciones con los Nullable<T> cuando un lado de la comparación es nulo?

Según tengo entendido al experimentar con el compilador, parece que la comparación siempre devuelve falso, pero no puedo encontrar ninguna documentación que lo respalde. ¿Es esta una característica real del lenguaje (y, por lo tanto, algo con lo que puedo contar), o es un detalle de implementación que podría cambiar en futuras versiones?

En otras palabras, ¿el siguiente método devuelve verdadero implica y.HasValue , y puede señalarme alguna documentación que demuestre que sí?

    public bool foo(int x, int? y)
    {
        return x < y;
    }

Answer 1

¿Alguien tiene información concreta sobre cómo C # maneja las comparaciones con tipos de Nullable cuando un lado de la comparación es nulo?

Sí, la especificación del lenguaje C #, sección 7.3.7. En este caso, es un operador relacional:

Para los operadores de relación < > <= >= existe una forma levantada de un operador si los tipos de operandos son tipos no anulables y si el tipo de resultado es bool . La forma levantada se construye agregando un solo ? Modificador a cada tipo de operando. El operador elevado produce el valor false si uno o ambos operandos son nulos. De lo contrario, el operador elevado desenvuelve los operandos y aplica el operador subyacente para producir el resultado bool .

Hay secciones similares detalladas para otros operadores.

Cuando tenga dudas sobre cómo funciona algún aspecto del lenguaje (y si está garantizado o es específico de la implementación), la especificación del lenguaje C # debe ser su primer puerto de escala.

Answer 2

MSDN tiene lo siguiente para decir al respecto:

Cuando realiza comparaciones con tipos anulables, si el valor de uno de los tipos anulables es nulo y el otro no, todas las comparaciones se evalúan como falsas, excepto por! = (No igual).

http://msdn.microsoft.com/en-us/library/2cf62fcy(v=vs.100).aspx

Aquí están los ejemplos de código proporcionados:

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

Answer 3

Sé que llego tarde, pero voy a tirar mis dos centavos.

Si la memoria sirve, las reglas para un comparador son las siguientes:

• Si x e y son nulos, devuelve 0 (son iguales).
• Si x es nulo y y no lo es, devuelve -1 (x es menor que y).
• Si x no es nulo e y es nulo, devuelve 1 (x es mayor que y).

Para todos los valores no nulos:

• Cuando el valor de x se evalúa como menor que y, devuelve -1.
• Cuando el valor de x evalúa y, devuelve 0.
• Cuando el valor de x se evalúa como mayor que y, devuelve 1.

Para todos los propósitos, un Nullable <T> se evalúa como nulo cuando no tiene valor. Así que las reglas son esencialmente las mismas. Al menos, así es como he escrito mis comparadores. Si lo estoy haciendo mal, entonces, Dios santo, lo estoy haciendo mal, ¡y espero que alguien me diga cómo solucionarlo!

Answer 4

Si no se implementó un CompareTo específico, entonces mi investigación me dice que el objeto usará el CompareTo (objeto). En el caso de un int, puede compararlo con un int o un objeto. En este caso, solo verifica si el objeto es nulo o no. Aquí hay un enlace al int CompareTo (objeto), que detalla la razón de los resultados de comparar un int y un objeto.

http://msdn.microsoft.com/en-us/library/system.int32.aspx

No puedo encontrar nada seguro, pero no veo nada que indique que .NET Framework se haya ampliado para incluir un método CompareTo para System.Nullable<T> para cada <T> .

Si fuera mi código, me protegería y extendería la clase Int para incluir un CompareTo.

Answer 5

Si uno de los valores es nulo, la comparación será falsa (excepto por != )

Cuando realiza comparaciones con tipos anulables, si el valor de uno de los tipos anulables es nulo y el otro no, todas las comparaciones se evalúan como falsas, excepto por! = (No es igual). Es importante no asumir que debido a que una comparación particular devuelve falso, el caso opuesto devuelve verdadero. En el siguiente ejemplo, 10 no es mayor que, menor que, ni igual a nulo. Sólo num1! = Num2 se evalúa como verdadero.

Fuente MSDN