Почему компилятор C # переводит это сравнение =, как если бы это было сравнение?

Я случайно обнаружил, что компилятор C # превращает этот метод:

static bool IsNotNull(object obj)
{
    return obj != null;
}

... в этот CIL :

.method private hidebysig static bool IsNotNull(object obj) cil managed
{
    ldarg.0   // obj
    ldnull
    cgt.un
    ret
}

... или, если вы предпочитаете смотреть на декомпилированный код C #:

static bool IsNotNull(object obj)
{
    return obj > null;   // (note: this is not a valid C# expression)
}

Почему это !=переводится как " >"?

Короткий ответ:

В IL нет инструкции «сравнить-не-равно», поэтому !=оператор C # не имеет точного соответствия и не может быть переведен буквально.

Тем не менее, существует команда «сравнить с равным» ( ceqпрямое соответствие ==оператору), поэтому в общем случае она x != yпереводится как ее немного более длинный эквивалент (x == y) == false.

В IL ( ) есть также инструкция «сравнить больше, чем», cgtкоторая позволяет компилятору использовать определенные комбинации клавиш (т. Е. Генерировать более короткий код IL), при этом неравенство сравнения объектов с нулем obj != nullпереводится так, как если бы они были » obj > null».

Давайте углубимся в некоторые детали.

Если в IL нет инструкции «сравнить-не-равно», то как следующий метод будет переведен компилятором?

static bool IsNotEqual(int x, int y)
{
    return x != y;
}

Как уже говорилось выше, компилятор превратит x != yв (x == y) == false:

.method private hidebysig static bool IsNotEqual(int32 x, int32 y) cil managed 
{
    ldarg.0   // x
    ldarg.1   // y
    ceq
    ldc.i4.0  // false
    ceq       // (note: two comparisons in total)
    ret
}

Оказывается, компилятор не всегда создает этот довольно длинный шаблон. Посмотрим, что произойдет, когда мы заменим yна константу 0:

static bool IsNotZero(int x)
{
    return x != 0;
}

Производимый ИЛ несколько короче, чем в общем случае:

.method private hidebysig static bool IsNotZero(int32 x) cil managed 
{
    ldarg.0    // x
    ldc.i4.0   // 0
    cgt.un     // (note: just one comparison)
    ret
}

Компилятор может воспользоваться тем фактом, что целые числа со знаком хранятся в дополнении к двум (где, если результирующие битовые шаблоны интерпретируются как целые числа без знака - это то, что .unзначит - 0 имеет наименьшее возможное значение), поэтому он переводится так, x == 0как если бы он был unchecked((uint)x) > 0,

Оказывается, компилятор может сделать то же самое для проверки неравенства null:

static bool IsNotNull(object obj)
{
    return obj != null;
}

Компилятор выдает почти тот же IL, что и для IsNotZero:

.method private hidebysig static bool IsNotNull(object obj) cil managed 
{
    ldarg.0
    ldnull   // (note: this is the only difference)
    cgt.un
    ret
}

По-видимому, компилятору разрешается предполагать, что битовая комбинация nullссылки является наименьшей битовой комбинацией, возможной для любой ссылки на объект.

Этот ярлык явно упоминается в Аннотированном стандарте общеязыковой инфраструктуры (1-е издание от октября 2003 г.) (на стр. 491, в качестве сноски к Таблице 6-4, «Двоичные сравнения или операции в филиалах»):

« cgt.unразрешено и проверяемо в ObjectRefs (O). Это обычно используется при сравнении ObjectRef с нулевым значением (нет инструкции« сравнить-не-равно », которая в противном случае была бы более очевидным решением).»