For logging purposes, some methods in our application include the following line:
Dim Log As ILog = GetLog(Reflection.MethodBase.GetCurrentMethod().DeclaringType)
I have what might be described as an irrational fear of reflection, which I try to keep in check. However, calls like this in methods that are executed potentially a hundred times a second concern me. I don't know as much as I should about reflection; but from looking briefly over the documentation, it looks to me like I could replace the following with:
Dim Log As ILog = GetLog(Me.GetType())
My question is three-fold:
Me.GetType()
actually return the same Type
as GetCurrentMethod().DeclaringType
? Me.GetType()
actually do anything differently from GetCurrentMethod().DeclaringType
, or is it doing the same thing under the hood?It depends. Me.GetType will always return the actual type of an object. GetCurrentMethod().DeclaringType will return the type in which the method was declared. These values can be different in inheritance scenarios.
Consider the following
Class C1
Public Sub Foo()
..
End Sub
End Class
Class C2
Inherits C1
..
End Class
Inside method Foo the two expressions would be equal if you were dealing with an instance of C1. But if it was C2 they would be different.
Yes these are very different functions. Me.GetType determines the runtime type of the current instance of the class. GetCurrentMethod.DeclaringType determines in what type was this method declared.
If this is a performance critical scenario then yes you make sure you profile APIs you do not understand. Especially those that appear to involve reflection. But only a profiler will tell you which is definitively faster. My money is on Me.GetType though.