Если NULL проверить на левой или правой стороне

Question

При рассмотрении какой-то код, я видел:

if (null == condition) { ... } 

и я также видел:

if (condition == null) { ... } 

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

Так это вопрос стиля, или есть ли преимущество иметь null с левой или с правой стороны оценки?

Answer 1

Это может сделать differenc е в трех случаях.

В одном случае опечатка condition = null действительна в if. Это чаще встречается в языках C-стиля, которые позволяли бы null в if (оценены как false), что является большинством из них, но не C#.

Можно создать тип, который имеет этот эффект в C#:

public class Test 
{ 
    public static bool operator true(Test x) 
    { 
    return true; 
    } 
    public static bool operator false(Test x) 
    { 
    return false; 
    } 
} 
void Main() 
{ 
    Test test = new test(); 
    if (test = null) 
    { 
    Console.WriteLine("!"); 
    } 
} 

Там не много раз, что перегрузка эти операторы имеют смысл, особенно с .Net 2.0 введена дженериков (это было больше значения для таких типов, как SqlBoolean, которые позволили указать значение true, false или null таким образом, каким мы теперь будем использовать bool?).

Так что этот случай довольно маргинален в C#.

Другой похож, если есть неявное преобразование в bool или к типу, который в свою очередь, реализующий true и false операторы:

void Main() 
{ 
    Test test = new Test(); 
    if (test = null) 
    { 
    Console.WriteLine("!"); 
    } 
} 
public class Test 
{ 
    public static implicit operator bool(Test x) 
    { 
    return true; 
    } 
} 

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

Еще один, если == перегружен в несимметричной образом:

public class Test 
{ 
    public static bool operator == (Test x, Test y) 
    { 
    return ReferenceEquals(x, null); 
    } 
    public static bool operator !=(Test x, Test y) 
    { 
    return !(x == y); 
    } 
} 
void Main() 
{ 
    Test test = new Test(); 
    if (test == null) 
    { 
    Console.WriteLine("This won't print."); 
    } 
    if (null == test) 
    { 
    Console.WriteLine("This will print."); 
    } 
} 

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

Так что, хотя это может иметь эффект на C#, случаи случаются редко и в основном основаны на том, что кто-то сделал что-то, чего они не должны.

Как таковой, в основном это вопрос стиля. Люди, которые положили null, сначала, как правило, поднимают его с языков, где это имеет большее значение.

Answer 2

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

if (false = condition) { ... } 

тогда это абсолютно легально (но, вероятно, не то, что задумал автор:

if (condition = false) { ... } 

Примечание: эта проблема ограничена в C# (по сравнению с ванилью C), поскольку операторы if требуют bool (как отмечено в комментариях ниже), поэтому единственный случай, который на самом деле вызывает проблемы, - это ваш тип bool.

Answer 3

Независимо от того, как (null == condition) компилирует, используя примерной значения, как null в качестве первого (левого) операнда нелогичный. Вместо этого первый операнд должен предлагать то, что вы собираетесь оценивать.