Estructura de IF encadenada

Question

Imagine este caso en el que tengo un objeto que necesito verificar una propiedad. Sin embargo, el objeto actualmente puede tener un valor nulo.

¿Cómo puedo verificar estas dos condiciones en una sola condición "si"?

Actualmente, tengo que hacer algo como esto:

if (myObject != null) 
{ 
    if (myObject.Id != pId) 
    { 
     myObject.Id = pId; 
     myObject.Order = pOrder; 
    } 
} 

me gustaría algo como esto:

if (myObject != null && myObject.Id != pId) 

Deseo evaluar la segunda condición sólo si el primero era cierto.

Tal vez me falta algo, y por eso necesito su ayuda ;-)

Answer 1

if(myObject != null && myObject.Id != pId) 
{ 
    myObject.Id = pId; 
    myObject.Order = pOrder; 
} 

&& es una prueba de la lógica de cortocircuito - que sólo evalúa la mano del lado derecho si la izquierda lado de la mano es cierto. Contraste con "un & b", que siempre se evalúa ambos lados (y hace un bit a bit "y")

Answer 2

if (myObject != null && myObject.Id != pId) 
{ 
//bla 
} 

esto es seguro porque operador & & se evalúa con pereza, lo que significa que si el LHS es falsa, el RHS Nunca se evalúa

Answer 3

if (myObject != null && myObject.Id != pId) 
{ 
    myObject.Id = pId; 
    myObject.Order = pOrder; 
} 

Answer 4

Este código primero comprueba si myObject no es nulo, en el caso de que es cierto que se compruebe la siguiente condición, en el caso de que no es cierto que no se compruebe la siguiente condición y no ejecuta el código.

if (myObject != null && myObject.Id != pId) 
{ 
    myObject.Id = pId; 
    myObject.Order = pOrder; 
} 

Answer 5

Tienes muchas buenas respuestas sobre cómo hacerlo. Solo quiero poner una advertencia sobre cómo no hacerlo. No envuelva la prueba única para id = pid en un bloque try-catch. Es un desperdicio y supondría la introducción de una verificación de excepción para atrapar una condición no excepcional. Es una mala idea que ni siquiera voy a ilustrarlo con un ejemplo.

Answer 6

Cabe destacar que la evaluación en cortocircuito de la & & en el caso de() está absolutamente garantizada por los estándares del lenguaje (C, C++, Java y C#). Ha sido así desde la primera edición de K & R's "C Programming Language".

No es algo de lo que tenga que preocuparse "¿Funciona mi compilador esto?". Si definitivamente hace.

Answer 7

if(!(myObject == null || myObject.Id == pId)) 
{ 
    myObject.Id = pId; 
    myObject.Order = pOrder; 
} 

Answer 8

Creo que en VB.net puede utilizar la palabra clave andAlso como alternativa a este comportamiento. Así que algo como ...

if(myObject != null andAlso myObject.Id != pId) 
    { 
    myObject.Id = pId; 
    myObject.Order = pOrder; 
    } 

hace exactamente lo mismo que yo creo pero está allí como una alternativa!

Editar: cambió C# a VB.neto por encima de

Answer 9

Dado que creo que puede ser útil para otros que miran esta pregunta en el futuro. Como se indicó, el uso de & & proporciona la funcionalidad que desea. Pero, también debe tenerse en cuenta, la funcionalidad que tenía miedo, que ambas partes serían evaluadas independientemente del resultado de la primera evaluación se puede obtener utilizando & en lugar de & &. Entonces:

//DO NOT USE THIS CODE 
//this will throw an exception if myObject is null 
//because myOject.Id != pId will still be evaluated 
if(myObject != null & myObject.Id != pId) 
{ 
    myObject.Id = pId; 
    myObject.Order = pOrder; 
} 

De nuevo, para este ejemplo, NO QUIERE este código. Simplemente quería añadirlo a la conversación, porque puede haber casos (aunque nunca he encontrado uno), donde ésta es la funcionalidad que desee, por ejemplo:

//always run both methods 
if(MethodA() & MethodB()) 
{ 
    //do stuff only when both methods return true 
} 

Answer 10

Puede utilizar & para evaluar dos condiciones, pero si quiere probar el segundo solo si el primer elemento es verdadero, puede usar & &.

En portugués llamamos esto: "AND com curto circuito".

if (myObject != null && myObject.Id != pId) 

si myObject es falso que no se puede probar myObject.Id porque myObject es nula y no se puede acceder a una propiedad de un objeto nulo.

:::::::::::::::::::::::

aba & & b

cierto cierto cierto

verdadero falso falso

falso verdadero falso

false false false

:::::::::::::::::::::::