Что происходит в конструкциях "If (.. ||..)" и "If (... &&...)" внутри?

Мне просто интересно, что происходит внутри ", если OR" и ", если AND". У меня есть ощущение, что это просто синтаксический сахар для использования && и ||, и внутренне все случаи строятся как одиночные операторы if.

Компактная форма ||:

if(a || b || c)
{
    DoSomething();
}

Потенциальная внутренняя форма:

if(a)
{
    DoSomething();
}    
else if(b)
{
    DoSomething();
}    
else if(c)
{
    DoSomething();
}

Компактная форма & &:

if(a && b && c)
{
    DoSomething();
}

Потенциальная внутренняя форма:

if(a)
{
    if(b)
    {
        if(c)
        {
            DoSomething();
        }
    }
}

Есть ли разница в производительности этих двух примеров?

* Edit: добавлено else в значение || Случай

Ответ 1

Прежде всего, || и && short-circuit. Это означает, что в:

if(a || b || c)
    DoSomething();

если a истинно, b и c не будут оцениваться.

Во-вторых, ваша реализация || неверна:

if(a)
    DoSomething();
if(b)
    DoSomething();
if(c)
    DoSomething();

DoSomething() будет называться до 3 раз.

Это должно быть:

if(a)
    DoSomething();
else if(b)
    DoSomething();
else if(c)
    DoSomething();

Чтобы закончить, если вы хотите, чтобы производительность предпочитала более короткий вызов сначала в ваших условиях:

if(aShortFunctionToExecute() || aVeryVeryLongFunctionToExecute())
     DoSomething();

Будет быстрее, чем

if(aVeryVeryLongFunctionToExecute() || aShortFunctionToExecute())
     DoSomething();

Из-за ленивая оценка

Если вы разобрали код:

private static void Main()
{
    if (a() && b() && c())
    {
        Console.WriteLine("DoSomething");
    }
}
bool a(){
    return true;
}
bool b(){
    return 3 % 2 == 1;
}
bool c(){
    return (3 % 2) / 1 == 1;
}

Вы получите:

    if (a() && b() && c())
00000022  call        FFFFFFFFFFEE8D90 
00000027  mov         byte ptr [rbp+20h],al 
0000002a  movzx       eax,byte ptr [rbp+20h] 
0000002e  test        eax,eax 
00000030  je          000000000000005A 
00000032  call        FFFFFFFFFFEE8D98 
00000037  mov         byte ptr [rbp+21h],al 
0000003a  movzx       eax,byte ptr [rbp+21h] 
0000003e  test        eax,eax 
00000040  je          000000000000005A 
00000042  call        FFFFFFFFFFEE8DA0 
00000047  mov         byte ptr [rbp+22h],al 
0000004a  movzx       ecx,byte ptr [rbp+22h] 
0000004e  xor         eax,eax 
00000050  test        ecx,ecx 
00000052  sete        al 
00000055  mov         dword ptr [rbp+24h],eax 
00000058  jmp         0000000000000062 
0000005a  nop 
0000005b  mov         dword ptr [rbp+24h],1 
00000062  nop 
00000063  movzx       eax,byte ptr [rbp+24h] 
00000067  mov         byte ptr [rbp+2Fh],al 
0000006a  movzx       eax,byte ptr [rbp+2Fh] 
0000006e  test        eax,eax 
00000070  jne         0000000000000087 
        {
00000072  nop 
            Console.WriteLine("DoSomething");
00000073  mov         rcx,12603398h 
0000007d  mov         rcx,qword ptr [rcx] 
00000080  call        00000000577A82A0 
00000085  nop 
        }

и для кода:

private static void Main()
{
    if (a())
        if(b())
            if(c())
                Console.WriteLine("DoSomething");
}
static bool a(){
    return true;
}
static bool b(){
    return 3 % 2 == 1;
}
static bool c(){
    return (3 % 2) / 1 == 1;
}

Вы получите:

if (a())
00000022  call        FFFFFFFFFFEE8D90 
00000027  mov         byte ptr [rbp+20h],al 
0000002a  movzx       ecx,byte ptr [rbp+20h] 
0000002e  xor         eax,eax 
00000030  test        ecx,ecx 
00000032  sete        al 
00000035  mov         dword ptr [rbp+24h],eax 
00000038  movzx       eax,byte ptr [rbp+24h] 
0000003c  mov         byte ptr [rbp+3Fh],al 
0000003f  movzx       eax,byte ptr [rbp+3Fh] 
00000043  test        eax,eax 
00000045  jne         00000000000000A4 
            if(b())
00000047  call        FFFFFFFFFFEE8D98 
0000004c  mov         byte ptr [rbp+28h],al 
0000004f  movzx       ecx,byte ptr [rbp+28h] 
00000053  xor         eax,eax 
00000055  test        ecx,ecx 
00000057  sete        al 
0000005a  mov         dword ptr [rbp+2Ch],eax 
0000005d  movzx       eax,byte ptr [rbp+2Ch] 
00000061  mov         byte ptr [rbp+3Fh],al 
00000064  movzx       eax,byte ptr [rbp+3Fh] 
00000068  test        eax,eax 
0000006a  jne         00000000000000A4 
                if(c())
0000006c  call        FFFFFFFFFFEE8DA0 
00000071  mov         byte ptr [rbp+30h],al 
00000074  movzx       ecx,byte ptr [rbp+30h] 
00000078  xor         eax,eax 
0000007a  test        ecx,ecx 
0000007c  sete        al 
0000007f  mov         dword ptr [rbp+34h],eax 
00000082  movzx       eax,byte ptr [rbp+34h] 
00000086  mov         byte ptr [rbp+3Fh],al 
00000089  movzx       eax,byte ptr [rbp+3Fh] 
0000008d  test        eax,eax 
0000008f  jne         00000000000000A4 
                    Console.WriteLine("DoSomething");
00000091  mov         rcx,125D3398h 
0000009b  mov         rcx,qword ptr [rcx] 
0000009e  call        00000000577B82A0 
000000a3  nop

Это немного дольше: вместо 31 требуется 40 инструкций.

Как указано thanosqr, производительность также зависит от вероятности того, что ваше условие будет истинным. Чтобы взять его пример:

Если a не работает 99% времени и занимает 1 секунду для запуска, и если b преуспеть в 99% случаев и занять 10 секунд, более 100 попыток вы быстрее ставите b:

if(b || a) => 10s 99% ==> 100 runs will take 99*10+11 = 1001s
if(b || a) => 11s 1%

if(a || b) => 11s 99% ==> 100 runs will take 99*11+1 = 1090s
if(a || b) => 1s 1%

Кроме того, я предлагаю вам это чтение Почему быстрее обрабатывать отсортированный массив, чем несортированный массив?, что довольно интересно!

Ответ 2

Используя компактную форму, IL, испускаемый компилятором С#, будет менее подробным, что приведет к меньшему количеству команд, которые будут обрабатываться во время выполнения. Испускаемые утверждения IL и их логика на самом деле одинаковы, поэтому нет никакой фантастической встроенной поддержки для обработки этого случая или какой-либо специальной инструкции (помните, что вы можете поместить любое выражение с логическим результатом в if).

Для компактной формы с помощью оператора || (сборка отладки):

.method private hidebysig static void  One() cil managed
{
  // Code size       38 (0x26)
  .maxstack  2
  .locals init ([0] bool CS$4$0000)
  IL_0000:  nop
  IL_0001:  ldsfld     bool ConsoleApplication4.Program::a
  IL_0006:  brtrue.s   IL_0019
  IL_0008:  ldsfld     bool ConsoleApplication4.Program::b
  IL_000d:  brtrue.s   IL_0019
  IL_000f:  ldsfld     bool ConsoleApplication4.Program::c
  IL_0014:  ldc.i4.0
  IL_0015:  ceq
  IL_0017:  br.s       IL_001a
  IL_0019:  ldc.i4.0
  IL_001a:  nop
  IL_001b:  stloc.0
  IL_001c:  ldloc.0
  IL_001d:  brtrue.s   IL_0025
  IL_001f:  call       void ConsoleApplication4.Program::DoSomething()
  IL_0024:  nop
  IL_0025:  ret
} // end of method Program::One

С вашей внутренней формой (учитывая, что вы используете else if вместо if):

.method private hidebysig static void  Two() cil managed
{
  // Code size       60 (0x3c)
  .maxstack  2
  .locals init ([0] bool CS$4$0000)
  IL_0000:  nop
  IL_0001:  ldsfld     bool ConsoleApplication4.Program::a
  IL_0006:  ldc.i4.0
  IL_0007:  ceq
  IL_0009:  stloc.0
  IL_000a:  ldloc.0
  IL_000b:  brtrue.s   IL_0015
  IL_000d:  call       void ConsoleApplication4.Program::DoSomething()
  IL_0012:  nop
  IL_0013:  br.s       IL_003b
  IL_0015:  ldsfld     bool ConsoleApplication4.Program::b
  IL_001a:  ldc.i4.0
  IL_001b:  ceq
  IL_001d:  stloc.0
  IL_001e:  ldloc.0
  IL_001f:  brtrue.s   IL_0029
  IL_0021:  call       void ConsoleApplication4.Program::DoSomething()
  IL_0026:  nop
  IL_0027:  br.s       IL_003b
  IL_0029:  ldsfld     bool ConsoleApplication4.Program::c
  IL_002e:  ldc.i4.0
  IL_002f:  ceq
  IL_0031:  stloc.0
  IL_0032:  ldloc.0
  IL_0033:  brtrue.s   IL_003b
  IL_0035:  call       void ConsoleApplication4.Program::DoSomething()
  IL_003a:  nop
  IL_003b:  ret
} // end of method Program::Two

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

С точки зрения производительности (каждый метод измеряется 10 раз с 10.000.000 итераций и удаляет самые высокие и самые низкие значения, выпускает сборку):

Компактная форма: 55 мс в среднем

Подробная форма: 56 мс в среднем

Таким образом, нет большой разницы.

Ответ 3

Для тех, кто читает С# лучше, чем сборки, реальные внутренние формы ближе к:

if(a) goto yes;
if(b) goto yes;
if(c) goto yes;
goto no;
yes:  DoSomething();
goto done;
no:   /* if there were an else it would go here */;
done: ;

для

if(a || b || c)
  DoSomething();

if(!a) goto no;
if(!b) goto no;
if(!c) goto no;
yes:  DoSomething();
goto done;
no:   /* if there were an else it would go here */;
done: ;

для

if(a && b && c)
  DoSomething();

Это потому, что фактические инструкции являются условными ветвями - во внутренней форме невозможно связать if с блоком, вложенным if или фактически чем-либо, кроме goto.

Ответ 4

Код:

if(a)
    if(b)
        if(c)
            DoSomething();

является логическим (но не "практическим" ) эквивалентом для:

if(a && b && c)
    DoSomething();

Что касается оператора OR, у вас это немного неверно. Логический (но, опять же, не "практический" ) эквивалент для:

if(a || b || c)
    DoSomething();

if(a)
    DoSomething();
else if(b)
    DoSomething();
else if(c)
    DoSomething();

По практическим соображениям я понимаю любые возникающие различия в коде, введенные компилятором (подробнее см. другие ответы).

Ответ 5

|| и && являются условными -операторов. Они также являются операторами, как и другие операторы, которых вы, возможно, знаете. (например, +, *,...)

Их поведение аналогично логическим операторам, | и &. Они получают две переменные типа bool и возвращают значение bool следующим образом:

// If one of them is true, the return value is true. Otherwise, it false.
true  | true  == true
true  | false == true
false | true  == true
false | false == false
// If both of them are true, the return value is true. Otherwise, it false.
true  & true  == true
true  & false == false
false & true  == false
false & false == false

Однако, как и для условных операторов, существует разность бит: короткое замыкание.

Предположим, что этот код:

bool func1() { .. }
bool func2() { .. }

bool b1 = func1() || func2();
bool b2 = func1() && func2();

Если func1() возвращает true, b1 становится true независимо от того, что возвращает func2(). Поэтому нам не нужно вызывать func2() и на самом деле этого не делать. Если func1() возвращает false, то же самое относится к b2. Такое поведение называется короткозамкнутым.

Теперь подумайте о своем примере.

if (a || b || c)
    DoSomething();

Он равен

bool value = a || b || c;
if (value)
    DoSomething();

Так как порядок оценки условных операторов слева направо, он равен

bool value = (a || b) || c;
if (value)
    DoSomething();

Ответ 6

Их эквиваленты VB могут быть более подробными. || - OrElse, а && - AndAlso в VB.
Это условные операторы; что означает, что в вашем случае задание контроля - if - оценивайте условия по мере необходимости, а не все из них всегда.

Например, в if ( a || b ), если a истинно, не имеет значения, что b; результат верен, и поэтому b не будет оцениваться, и это приведет к более быстрому выполнению.

Эта функция также может использоваться в качестве механизма проверки нулей. if ( a != null && a.prop == somevalue ) предотвратит исключение ссылочной ссылки, если a имеет значение null, и если оно не равно null, его свойство prop будет доступно для оценки второго условия.