Performance of Array#Contain vs OR logic vs switch statement

Question

Which of these is the fastest and which is the slowest (C#)?

// Array#Contain
int i = ...;
if ((new int[] { 0, 1, 3, 7, ... }).Contains(i))
{
  ...
}

// OR logic
int i = ...;
if (i == 0 || i == 1 || i == 3 || i == 7  || ...)
{
  ...
}

// switch statement
int i = ...;
switch(i)
{
  case 0:
  case 1:
  case 3:
  case 7:
  ...
    ...
    break;
}

Answer 1

Performance of these things depends on the target machine architecture and maybe OS.
For the x86/x64 machines, I believe the code above should be translated by JIT to the following assembler equivalents:

1. Array.Contains method

   lea    EDI, [...]
   mov    ECX, sizeof(...)
   repne  scasd
   

2. Sequental ORs in if statement

   mov    EAX, ...
   cmp    EAX, 0
   jz     iftrue
   cmp    EAX, 1
   jz     iftrue
   cmp    EAX, 3
   jz     iftrue
   ...
   jmp    endif
   iftrue:
   ...
   endif:
   

3. switch statement

   lea    EBX, [case_values_table]
   xor    EAX, EAX
   mov    AL, case_index
   xlat
   mov    ESI, EAX
   jmp    [case_codeblocks_table][ESI * 4 or 8]
   

The only thing you need is to sum timings of the ASM instructions for each option, including potential disadvantage of any jmps due to the positive probability of clearing the opcode prefetching queue.

But I believe, that the much better advice is to choose the most supportable C# code.

Answer 2

I do not know for sure, but I would expect the switch-statement to be the fastest for the reason explained here, i.e. constant lookup time through implementation as a hashtable (for case statements with more than 5 items, that is).

Creating a new int[] for one .Contains seems very inefficient, but you might work around that with a constant field. Also, the method will have to iterate over all elements (worst case), so it is probably the least favorable option performance wise.

The if cascade might beat switch if in almost every case the first condition is correct, since it won't have to evaluate anything after that has been determined.

That being said, I'd usually go with an array, just because it reads nicely and is easily changed. The performance gains are usually moot.