@Frank--> It's pretty straight forward. Imagine if you could write something in VB that looked like this:
Dim lookupList As New List(Of Integer) From {1, 2, 3, 4, 5}
Dim value As Integer = 3
Dim result As String = Nothing
If value > 0 AndAlso value < 6 Then
' <<<<< The following line will not compile >>>>>>>
GoTo lookupList(value)
Else
GoTo 6
End If
1:
result = "1" : GoTo 6
2:
result = "2" : GoTo 6
3:
result = "3" : GoTo 6
4:
result = "4" : GoTo 6
5:
result = "5" : GoTo 6
6:
' Either done or skipping the scenarios.
Return result
Now, before you try... this code ***will not*** work in VB. The reason being that you can't use a variable as a goto "jump point". However, as you can see, the value is evaluated and it is then applied to the lookup table to determine where it needs to jump
to. It doesn't work through all the items in the jump table until it finds it, it just knows that it needs to go to the third one in the list.
When the compiler builds the IL for an "optimized" Select Case, it can attempt to do something very similar to this. The "switch" (IL version, not C# version) is a jump table just like this. The contents are the address points of where it will
jump to depending on the "indexer" value that is available. This requires that the items be "close together". If there are gaps, the compiler will make a determination if filling the gaps is better than just abandoning this approach alltogether
and going the "if/then" route you are already aware of. However, as you can see, if this can be done, the performance can be improved greatly, especially if you have a lot of Cases to work through. Again, you have to follow some very specific rules
to get this to happen; but depending on the circumstances, it's well worth it.
So intead of:
Select Case keyword
Case "PRINT"
Case "END"
' and so on...
Case Else
End Select
Modified the approach to use an enum and convert the keyword (string) to a value in the enumerator so I get:
Select Case ToKeywordEnum(keyword)
Case Keyword.Print
Case Keyword.End
' and so on...
Case Else
End Select
This turns the string values in to a value between 0 and n where n is the number of keywords. By doing this, a jump table (IL "switch") can be utilized which will now just jump (goto) the correct section of the Select Case bypassing the testing for all items
prior to it since it can jump directly.
This is a powerful tool if you a) are aware of it, b) need it and c) know how to code for it.
This is why I am saying it can't be answered in an easy manner; since the answer is really "it depends". If it's not optimized in this manner, them it's going to be either a combination of this way and the "if" way or it will just be like doing it
the "if" way. So you really have three different outcomes when using Select Case.
In most cases, I'd recommend using Select Case for anything that is more than If, ElseIf, Else. Once you get past that, use Select Case; however, there are many times that a single line, or three line, or even 6 line If statement makes a perfect choice and
should not be denied. They are tools in your tool chest; use them how you want... however, learn all you can about them (over time) so you can use them to their best potential.
Cory Smith http://addressof.com
boolean
