I saw some code that piqued my interest a few days ago. Basically, this code compared object types instead of the name for the object type. Being the developer that I am, it set me thinking about which way is faster. Here are a couple of routines that do the exact same thing. Which one do you think will run faster? This code is targeted for .NET 4 Client, but should also work in .NET 2 and later.
The StopWatch
objects (oStopWatchA
and oStopWatchB
) are defined as Class level private
System.Diagnostics.Stopwatch
objects and initialized before the call to the Sub
s. The Object
object (oObject
) is defined as a Class level private
System.Object
object and initialized before the call to the Sub
s. Each routine was run 1,000 times, swapping with each execution to eliminate external factors to the timing.
Private Sub CompareA()
Dim iLoop As Integer
oStopWatchA.Start()
For iLoop = 1 To 1000000
Select Case oObject.GetType().Name
Case "Object"
Case "Exception"
Case Else
End Select
Next
oStopWatchA.Stop()
End Sub
Private Sub CompareB()
Dim iLoop As Integer
oStopWatchB.Start()
For iLoop = 1 To 1000000
Select Case oObject.GetType()
Case GetType(Object)
Case GetType(Exception)
Case Else
End Select
Next
oStopWatchB.Stop()
End Sub
The elapsed time for each is listed below (lower numbers are better):
Routine |
Elapsed Time (seconds) |
CompareA |
32.9136874 |
CompareB |
7.7228856 |
Were you surprised? I was!
Edit: The whole point of this tip is to not just do the same thing the same way you always have. Look at other methods to accomplish your goal. I was surprised by the speed difference of changing the comparison from a string
to a type reference, mainly because I expected the compiler to be able to generate code that pulled the type's name once for the comparison. I was also expecting the GetType()
calls to be executed on every comparison (each Case
statement).