Warum sieht man in C # oft "null! = Variable" anstelle von "Variable! = Null"?

Gibt es in c # einen Unterschied in der Ausführungsgeschwindigkeit für die Reihenfolge, in der Sie die Bedingung angeben?

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

Seit kurzem habe ich das erste ziemlich oft gesehen, und es hat meine Aufmerksamkeit erregt, seit ich an das zweite gewöhnt war.

Wenn es keinen Unterschied gibt, was ist der Vorteil des ersten?

Es ist ein Überbleibsel von C. Wenn Sie in C entweder einen schlechten Compiler verwenden oder die Warnungen nicht hoch genug sind, wird dies ohne jegliche Warnung kompiliert (und ist in der Tat ein gesetzlicher Code):

// Probably wrong
if (x = 5)

als du eigentlich wohl gemeint hast

if (x == 5)

Sie können dies in C umgehen, indem Sie Folgendes tun:

if (5 == x)

Ein Tippfehler hier führt zu ungültigem Code.

Nun, in C # ist das alles piffle. Wenn Sie nicht zwei Boolesche Werte vergleichen (was selten vorkommt, IME), können Sie den besser lesbaren Code schreiben, da für eine "if" -Anweisung zunächst ein Boolescher Ausdruck erforderlich ist und der Typ " x=5" Int32nichtBoolean .

Ich schlage vor, wenn Sie dies im Code Ihrer Kollegen sehen, erziehen Sie sie in modernen Sprachen und schlagen vor, dass sie in Zukunft die natürlichere Form schreiben.

Es gibt einen guten Grund, zuerst null zu verwenden: if(null == myDuck)

Wenn Sie class Duckden ==Operator überschreiben , if(myDuck == null)können Sie in eine Endlosschleife gehen.

Bei der nullersten Verwendung wird ein Standard-Gleichstellungskomparator verwendet, der tatsächlich das tut, was Sie beabsichtigt haben.

(Ich habe gehört, dass Sie sich daran gewöhnt haben, Code zu lesen, der irgendwann so geschrieben wurde - ich habe diese Transformation noch nicht erlebt).

Hier ist ein Beispiel:

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
    }
}

Wie alle bereits bemerkt haben, kommt es mehr oder weniger aus der C-Sprache, wo Sie falschen Code erhalten könnten, wenn Sie versehentlich das zweite Gleichheitszeichen vergessen. Es gibt aber noch einen anderen Grund, der auch mit C # übereinstimmt: Lesbarkeit.

Nehmen Sie einfach dieses einfache Beispiel:

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

Wenn Sie einfach alle Nullwörter an den Anfang tauschen würden , könnten Sie alle Überprüfungen viel einfacher erkennen:

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

Dieses Beispiel ist vielleicht ein schlechtes Beispiel (siehe Codierungsrichtlinien), aber denken Sie nur daran, dass Sie schnell über eine vollständige Codedatei scrollen. Indem Sie einfach das Muster sehen

if(null ...

Sie wissen sofort, was als nächstes kommt.

Wenn es umgekehrt wäre, müssen Sie immer bis zum Ende der Zeile scannen , um die Nichtigkeitsprüfung zu sehen, und Sie müssen nur eine Sekunde lang stolpern, um herauszufinden, welche Art von Prüfung dort durchgeführt wird. Vielleicht hilft Ihnen die Hervorhebung der Syntax, aber Sie sind immer langsamer, wenn sich diese Schlüsselwörter am Ende der Zeile anstatt am Anfang befinden.

Ich denke, dies ist ein C-Programmierer, der die Sprache gewechselt hat.

In C können Sie Folgendes schreiben:

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

Beachten Sie die Verwendung eines einzelnen Gleichheitszeichens, was bedeutet, dass der Code der Variablen i 1 zuweist, dann 1 zurückgibt (eine Zuweisung ist ein Ausdruck) und 1 in der if-Anweisung verwendet, die als wahr behandelt wird. Mit anderen Worten, das Obige ist ein Fehler.

In C # ist dies jedoch nicht möglich. Es gibt in der Tat keinen Unterschied zwischen den beiden.

In früheren Zeiten vergaßen die Leute das '!' (oder das zusätzliche '=' für Gleichheit, das schwieriger zu erkennen ist) und führen Sie eine Zuweisung anstelle eines Vergleichs durch. Wenn Sie die Null voranstellen, wird die Möglichkeit für den Fehler ausgeschlossen, da null kein l-Wert ist (IE kann ihm nicht zugewiesen werden).

Die meisten modernen Compiler geben heutzutage eine Warnung aus, wenn Sie eine Zuweisung unter bestimmten Bedingungen ausführen, und C # gibt tatsächlich einen Fehler aus. Die meisten Leute halten sich einfach an das Schema var == null, da es für manche Leute einfacher zu lesen ist.

Ich sehe keinen Vorteil darin, dieser Konvention zu folgen. In C, wo es keine booleschen Typen gibt, ist es nützlich zu schreiben

if( 5 == variable)

eher, als

if (variable == 5)

denn wenn Sie eines der Gleichheitszeichen vergessen, erhalten Sie am Ende

if (variable = 5)

Dies weist der Variablen 5 zu und wertet immer true aus. In Java ist ein Boolescher Wert ein Boolescher Wert. Und mit! = Gibt es überhaupt keinen Grund.

Ein guter Rat ist jedoch zu schreiben

if (CONSTANT.equals(myString))

eher, als

if (myString.equals(CONSTANT))

weil es hilft, NullPointerExceptions zu vermeiden.

Mein Rat wäre, um eine Begründung der Regel zu bitten. Wenn es keine gibt, warum dann folgen? Es hilft nicht die Lesbarkeit

Für mich war es immer der Stil, den Sie bevorzugen

@Shy - Wenn Sie die Operatoren verwirren, sollten Sie einen Kompilierungsfehler erhalten, oder Sie führen Code mit einem Fehler aus - einem Fehler, der zurückkommt und Sie später beißt, da er unerwartetes Verhalten hervorruft

Wie viele betonten, wurde es hauptsächlich in altem C-Code verwendet, um Kompilierungsfehler zu identifizieren, da der Compiler dies als legal akzeptierte

Neue Programmiersprachen wie Java, go sind intelligent genug, um solche Kompilierungsfehler zu erfassen

Man sollte keine "null! = Variablen" -ähnlichen Bedingungen im Code verwenden, da diese sehr unlesbar sind

Noch etwas ... Wenn Sie eine Variable mit einer Konstanten vergleichen (z. B. Ganzzahl oder Zeichenfolge), empfiehlt es sich, die Konstante links zu setzen, da Sie nie auf NullPointerExceptions stoßen:

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

wohingegen

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

Da C # standardmäßig alle Variablen instanziiert, sollte dieses Problem in dieser Sprache nicht auftreten.