ternario - c#¿necesita verificar si algo tiene un valor y si algo es mayor que 0?

switch c#

Question

Trabajando en un proyecto y el codificador lo hace mucho en sus cheques. Primero, comprueba si el int nullable tiene un valor, y luego comprueba si es mayor que 0. ¿Por qué? ¿Por qué hacer dos comprobaciones si una comprobación, si es mayor que 0, debería ser suficiente? Porque los nulos no son mayores que 0 entonces ... ¿Eso es redundante?

No estaba seguro de si esto era algo que preguntaría aquí, pero no sabría cómo decirlo en una búsqueda en Google, así que tal vez no sé algo que haga este programador.

Answer 1

El código es probablemente redundante.

Si yo int? entonces:

if (i.HasValue && i.Value > 0)

es equivalente a:

if (i > 0)

Desde MSDN :

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 para! = (No 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. Solo num1! = Num2 se evalúa como verdadero.

Answer 2

El seguimiento:

class Program {
    static void Main(string[] args) {
        int? i = null;
        if (i > 0) { Console.WriteLine(">0");
        } else {     Console.WriteLine("not >0");
        }
        if (i < 0) { Console.WriteLine("<0");
        } else {     Console.WriteLine("not <0");
        }
        if (i == 0) {Console.WriteLine("==0");
        } else {     Console.WriteLine("not ==0");
        }
        Console.ReadKey();
    }
}

saldrá

not >0
not <0
not ==0

sin lanzar una excepción. Entonces la verificación nula / HasValue en este caso es redundante. Hay una pequeña diferencia. El seguimiento:

(i.HasValue && (i.Value == 0))

es aproximadamente el doble de rápido que

(i == 0)

cuando soy nulo, aunque ambos son tan rápidos, no es una diferencia importante. Cuando tengo un valor, las dos comparaciones tardan aproximadamente el mismo tiempo.

Answer 3

Es posible que el valor de la variable tenga diferentes significados en ese contexto.

int? someNumber = null; //might mean "there is no value"
int? someOtherNumber = 0; //might mean "the user has selected: 0"

Answer 4

La comprobación nula generalmente se realiza para evitar excepciones o para establecer valores predeterminados (antes de .NET 4). Buscar cero sería más una opción de lógica de negocios, dependiendo de las circunstancias.

Answer 5

Puede encontrar que el programador está acostumbrado al siguiente tipo de comprobación de tipos de referencia antes de desreferenciarlos. Teniendo en cuenta que el Nullable HasValue es similar en concepto a la verificación nula, supongo que el patrón ''se estancó'', aunque es redundante con tipos que aceptan HasValue .

if ((myObject != null)  && (myObject.SomeValue > 0))

...