Почему в C # часто встречается «null! = Variable» вместо «variable! = Null»?

В C # есть ли разница в скорости выполнения для порядка, в котором вы указываете условие?

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

С недавнего времени я довольно часто видел первый, и он привлек мое внимание, так как ко второму я привык.

Если нет разницы, в чем преимущество первого?

Это задержка от C. В C, если вы либо используете плохой компилятор, либо предупреждения не выставлены достаточно высоко, это будет компилироваться без каких-либо предупреждений (и действительно является допустимым кодом):

// Probably wrong
if (x = 5)

когда вы на самом деле, вероятно, имели в виду

if (x == 5)

Вы можете обойти это в C, выполнив:

if (5 == x)

Опечатка здесь приведет к неверному коду.

Теперь, в C # это все чепуха. Если вы не сравниваете два логических значения (что бывает редко, IME), вы можете написать более читаемый код, поскольку для оператора «if» требуется логическое выражение для начала, а тип « x=5» - Int32нет Boolean.

Я предлагаю, если вы заметите это в коде своих коллег, обучите их современным языкам и предложите им писать в более естественной форме в будущем.

Есть веская причина использовать сначала null: if(null == myDuck)

Если вы class Duckпереопределяете ==оператор, то if(myDuck == null)можете войти в бесконечный цикл.

Использование nullfirst использует компаратор равенства по умолчанию и фактически делает то, что вы намеревались.

(Я слышал, что со временем ты привыкаешь читать код, написанный таким образом - я просто еще не испытал этого преобразования).

Вот пример:

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

Как все уже отмечали, это более или менее связано с языком C, где вы можете получить ложный код, если случайно забудете второй знак равенства. Но есть еще одна причина, которая также соответствует C #: читаемость.

Возьмем этот простой пример:

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

Если вы просто переставляете все нулевые слова в начало, вы можете намного легче обнаружить все проверки:

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

Так что этот пример может быть плохим (см. Рекомендации по кодированию), но просто подумайте о том, как быстро пролистать весь файл кода. Просто увидев образец

if(null ...

вы сразу знаете, что будет дальше.

Если бы все было наоборот, вам всегда нужно сканировать до конца строки, чтобы увидеть проверку на недействительность, просто позволяя вам на секунду задержаться, чтобы узнать, какой тип проверки там делается. Так что, возможно, подсветка синтаксиса может вам помочь, но вы всегда будете медленнее, когда эти ключевые слова находятся в конце строки, а не в начале.

Думаю, это программист на C, который переключил языки.

На C вы можете написать следующее:

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

Обратите внимание на использование единственного знака равенства, что означает, что код присвоит 1 переменной i, затем вернет 1 (присвоение является выражением) и использует 1 в операторе if, который будет обработан как истина. Другими словами, это ошибка.

Однако в C # это невозможно. Между ними действительно нет разницы.

Раньше люди забывали знак "!" (или лишнее '=' для равенства, которое труднее обнаружить) и выполнять присваивание вместо сравнения. размещение нуля впереди исключает возможность ошибки, поскольку null не является l-значением (IE не может быть присвоено).

Большинство современных компиляторов выдают предупреждение, когда вы выполняете присваивание в условном выражении, а C # фактически выдает ошибку. Большинство людей просто придерживаются схемы var == null, так как некоторым людям ее легче читать.

Я не вижу никаких преимуществ в том, чтобы следовать этому соглашению. В C, где логические типы не существуют, полезно написать

if( 5 == variable)

скорее, чем

if (variable == 5)

потому что если вы забудете один из знаков равенства, вы получите

if (variable = 5)

который присваивает переменной 5 и всегда возвращает значение true. Но в Java логическое значение является логическим. А с! = Вообще нет причин.

Тем не менее, один хороший совет - написать

if (CONSTANT.equals(myString))

скорее, чем

if (myString.equals(CONSTANT))

потому что это помогает избежать исключений NullPointerExceptions.

Я бы посоветовал попросить обоснования правила. Если его нет, зачем ему следовать? Не улучшает читаемость

Для меня всегда было то, какой стиль ты предпочитаешь

@Shy - Опять же, если вы путаете операторы, вы должны получить ошибку компиляции, или вы будете запускать код с ошибкой - ошибка, которая возвращается и укусит вас позже, поскольку она произвела неожиданное поведение

Как многие отметили, это в основном в старом коде C, он использовался для выявления ошибки компиляции, поскольку компилятор принял это как законное

Новый язык программирования, такой как java, go, достаточно умен, чтобы фиксировать такие ошибки компиляции.

Не следует использовать в коде условия типа "null! = Variable", так как это очень нечитабельно.

Еще одна вещь ... Если вы сравниваете переменную с константой (например, целым числом или строкой), размещение константы слева - хорошая практика, потому что вы никогда не столкнетесь с NullPointerExceptions:

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

в то время как

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

Теперь, поскольку по умолчанию C # инстанцирует все переменные, у вас не должно быть этой проблемы на этом языке.