Short-circuit evaluation is an optimization technique automatically adopted by most modern compilers, including all flavors of C++, Borland Delphi and many others. Unfortunately, the Visual Basic compiler is not in this group. This optimization cuts down the time needed to evaluate a boolean expression, such as:

```
If x > 0 And y ^ 2 < x Then Call DoIt
If x = 0 Or Log(y) = z Then Call DoIt
```

In the first expression, if x is less than or equal to zero, the "Then" block is skipped over without evaluating the "y^2" sub-expression, because even if it were True the combined ANDed result would be False anyway. Similarly, in the second expression "Log(y)=x" is not evaluated if the X variable happens to be zero.

Even if the VB compiler doesn't support short-circuit evaluation, you can manually enforce it by using nested If statements, as in:

```
If x > 0 Then
If y ^ 2 < x Then Call DoIt
End If
...
If x = 0 Then
Call DoIt
ElseIf Log(y) = z Then
Call DoIt
End If
```

However, things gets quickly complex when there are more than just two sub-expressions tied with a boolean operator. Here's is an unorthodox way to use Select Case to enforce short-circuit evaluation:

```
' If x > 0 And y <= 0 And z = 0 Then DoIt
Select Case False
Case x > 0, y <= 0, z = 0
Case Else
Call DoIt
End Select
...
' If x > 0 Or y <= 0 Or z = 0 Then DoIt
Select Case True
Case x > 0, y <= 0, z = 0
Call DoIt
End Select
```

Surprisingly, the Select Case conditional block does short-circuit evaluation! The above Select Case blocks are about three times faster than the equivalent If statements when the first sub-expression is enough to decide if the compound boolean expression will be False (And) or True (Or). The Select Case approach is still 30% faster when it is necessary to evaluate two sub-expressions. On the other hand it is slightly slower, by about 20%, if all three sub-expressions must be evaluated. However, relative timing might differ - and make the Select Case technique even more advantageous, if the sub-expressions after the first one are more complex, include math operations (especially and transcendental functions such as Sin or Log), string function, etc.

For the best results of this method, stick to the following rules:

- Place first the simplest sub-expressions, and keep the most complex ones at the end of the list
- if you have sub-expressions of similar complexity, place first those that are more likely to return False (in case of ANDed expressions) or True (in case of ORed ones)

At any rate, I strongly suggest you to resort to this trick only if you have more than two sub-expressions and you're within a time-critical loop, and - above all - to add a remark that clearly shows what you're doing, otherwise it would be very difficult to understand your own code after a few weeks, or even days.