¿Por qué a menudo se ve "nulo! = Variable" en lugar de "variable! = Nulo" en C #?

En c #, ¿hay alguna diferencia en la velocidad de ejecución para el orden en el que indica la condición?

if (null != variable) ...
if (variable != null) ...

Desde hace poco veía el primero con bastante frecuencia y me llamó la atención ya que estaba acostumbrado al segundo.

Si no hay diferencia, ¿cuál es la ventaja del primero?

Es una retención de C. En C, si usa un compilador incorrecto o no tiene advertencias lo suficientemente altas, esto se compilará sin advertencia alguna (y de hecho es un código legal):

// Probably wrong
if (x = 5)

cuando probablemente quisiste decir

if (x == 5)

Puede solucionar esto en C haciendo:

if (5 == x)

Un error tipográfico aquí resultará en un código no válido.

Ahora, en C # todo esto es una tontería. A menos que esté comparando dos valores booleanos (que es raro, IME), puede escribir el código más legible, ya que una declaración "if" requiere una expresión booleana para comenzar, y el tipo de " x=5" Int32no lo es Boolean.

Sugiero que si ve esto en el código de sus colegas, los eduque en las formas de los lenguajes modernos y sugiera que escriban la forma más natural en el futuro.

Hay una buena razón para usar null primero: if(null == myDuck)

Si su class Duckanula el ==operador, entonces if(myDuck == null)puede entrar en un bucle infinito.

Usar nullprimero usa un comparador de igualdad predeterminado y realmente hace lo que pretendías.

(Escuché que eventualmente te acostumbras a leer código escrito de esa manera, simplemente no he experimentado esa transformación todavía).

Aquí hay un ejemplo:

public class myDuck
{
    public int quacks;
    static override bool operator ==(myDuck a, myDuck b)
    {
        // these will overflow the stack - because the a==null reenters this function from the top again
        if (a == null && b == null)
            return true;
        if (a == null || b == null)
            return false;

        // these wont loop
        if (null == a && null == b)
            return true;
        if (null == a || null == b)
            return false;
        return a.quacks == b.quacks; // this goes to the integer comparison
    }
}

Como todo el mundo ya notó, proviene más o menos del lenguaje C, donde podría obtener un código falso si accidentalmente olvida el segundo signo igual. Pero hay otra razón que también coincide con C #: Legibilidad.

Solo tome este simple ejemplo:

if(someVariableThatShouldBeChecked != null
   && anotherOne != null
   && justAnotherCheckThatIsNeededForTestingNullity != null
   && allTheseChecksAreReallyBoring != null
   && thereSeemsToBeADesignFlawIfSoManyChecksAreNeeded != null)
{
    // ToDo: Everything is checked, do something...
}

Si simplemente intercambia todas las palabras nulas al principio, puede detectar mucho más fácilmente todas las verificaciones:

if(null != someVariableThatShouldBeChecked
   && null != anotherOne
   && null != justAnotherCheckThatIsNeededForTestingNullity
   && null != allTheseChecksAreReallyBoring
   && null != thereSeemsToBeADesignFlawIfSoManyChecksAreNeeded)
{
    // ToDo: Everything is checked, do something...
}

Entonces, este ejemplo es quizás un mal ejemplo (consulte las pautas de codificación), pero solo piense en desplazarse rápidamente sobre un archivo de código completo. Simplemente viendo el patrón

if(null ...

inmediatamente sabes lo que viene a continuación.

Si fuera al revés, siempre debe escanear hasta el final de la línea para ver la verificación de nulidad, lo que le permitirá tropezar por un segundo para averiguar qué tipo de verificación se realiza allí. Entonces, tal vez el resaltado de sintaxis pueda ayudarlo, pero siempre es más lento cuando esas palabras clave están al final de la línea en lugar de al principio.

Supongo que este es un programador en C que ha cambiado de idioma.

En C, puede escribir lo siguiente:

int i = 0;
if (i = 1)
{
    ...
}

Observe el uso de un solo signo igual allí, lo que significa que el código asignará 1 a la variable i, luego devolverá 1 (una asignación es una expresión) y usará 1 en la declaración if, que se manejará como verdadera. En otras palabras, lo anterior es un error.

Sin embargo, en C # esto no es posible. De hecho, no hay diferencia entre los dos.

En épocas anteriores, la gente olvidaba el '!' (o el '=' adicional para la igualdad, que es más difícil de detectar) y hacer una tarea en lugar de una comparación. poner el nulo al frente elimina la posibilidad del error, ya que nulo no es un valor l (es decir, no se le puede asignar).

La mayoría de los compiladores modernos dan una advertencia cuando haces una asignación en un condicional hoy en día, y C # en realidad da un error. La mayoría de la gente se queda con el esquema var == null ya que es más fácil de leer para algunas personas.

No veo ninguna ventaja en seguir esta convención. En C, donde no existen tipos booleanos, es útil escribir

if( 5 == variable)

más bien que

if (variable == 5)

porque si te olvidas de uno de los dos signos, terminas con

if (variable = 5)

que asigna 5 a la variable y siempre se evalúa como verdadero. Pero en Java, un booleano es un booleano. Y con! =, No hay ninguna razón.

Sin embargo, un buen consejo es escribir

if (CONSTANT.equals(myString))

más bien que

if (myString.equals(CONSTANT))

porque ayuda a evitar NullPointerExceptions.

Mi consejo sería pedir una justificación de la regla. Si no hay ninguno, ¿por qué seguirlo? No ayuda a la legibilidad

Para mi siempre ha sido el estilo que prefieres

@Shy - Por otra parte, si confunde a los operadores, entonces debería querer obtener un error de compilación o estará ejecutando un código con un error, un error que regresa y lo muerde más adelante, ya que produjo un comportamiento inesperado

Como muchos señalaron, está principalmente en el código C antiguo que se usó para identificar el error de compilación, ya que el compilador lo aceptó como legal

Los nuevos lenguajes de programación como java, go son lo suficientemente inteligentes como para capturar tales errores de compilación

No se deben usar condiciones similares a "nulo! = Variable" en el código, ya que es muy ilegible

Una cosa más ... Si está comparando una variable con una constante (entero o cadena, por ejemplo), poner la constante a la izquierda es una buena práctica porque nunca se encontrará con NullPointerExceptions:

int i;
if(i==1){        // Exception raised: i is not initialized. (C/C++)
  doThis();
}

mientras

int i;
if(1==i){        // OK, but the condition is not met.
  doThis();
}

Ahora, dado que por defecto C # instancia todas las variables, no debería tener ese problema en ese lenguaje.