Property / Method inlining and impact on Reflection

My answer to one of the question on SO was commented by Valentin Ku开发者_StackOverflowzub, who argues that inlining a property by JIT compiler will cause the reflection to stop working.

The case is as follows:

class Foo
{
    public string Bar { get; set; }

    public void Fuzz<T>(Expression<Func<T>> lambda)
    {
    }
}

Fuzz(x => x.Bar);

Fuzz function accepts a lambda expression and uses reflection to find the property. It is a common practice in MVC in HtmlHelper extensions.

I don't think that the reflection will stop working even if the Bar property gets inlined, as it is a call to Bar that will be inlined and typeof(Foo).GetProperty("Bar") will still return a valid PropertyInfo.

Could you confirm this please or my understanding of method inlining is wrong?

---

JIT compiler operates at runtime and it can't rewrite metadata information stored in the assembly. And reflection reads assembly to access this metadata. So there are no impact from JIT-compiler to reflection.

EDIT: Actually there are couple of places when C# compiler itself "inlines" some information during compilation. For example, constants, enums and default arguments are "inlined" so you can't access them during reflection. But it definitely not related to your particular case.

---

Yeah when I think about it more I guess only way inlining properties could fail INotifyPropertyChanged interface correct work would be if you were using a reflection based method used like

public Count
{
get {return m_Count;}
 set { m_Count=value;
      GetCurrentPropertyNameUsingReflectionAndNotifyItChanged();}
}

If used like you suggest indeed metadata exists in assembly and property name will be successfully taken from there.

Got us both thinking though.

---

I personally agree with @Sergey:

Considering that inlining happens on JIT compiler side, but metadata generated before, it shouldn't inpact on reflection in any way. By the way, good question, like it +1

---

Expression trees can't be in-lined anyway since they are a representation of the expression (abstract syntax tree) rather than the expression itself.

Delegates, even if they can be in-lined, will still carry the data about the method and target being called in their properties.