INotifyPropertyChanged property name – hardcode vs reflection?

by

Don’t forget one thing : PropertyChanged event is mainly consumed by components that will use reflection to get the value of the named property.

The most obvious example is databinding.

When you fire PropertyChanged event, passing the name of the property as a parameter, you should know that the subscriber of this event is likely to use reflection by calling, for instance, GetProperty (at least the first time if it uses a cache of PropertyInfo), then GetValue. This last call is a dynamic invocation (MethodInfo.Invoke) of the property getter method, which costs more than the GetProperty which only queries meta data. (Note that data binding relies on the whole TypeDescriptor thing — but the default implementation uses reflection.)

So, of course using hard code property names when firing PropertyChanged is more efficient than using reflection for dynamically getting the name of the property, but IMHO, it is important to balance your thoughts. In some cases, the performance overhead is not that critical, and you could benefit from some kind on strongly typed event firing mechanism.

Here is what I use sometimes in C# 3.0, when performances would not be a concern :

public class Person : INotifyPropertyChanged
{
    private string name;

    public string Name
    {
        get { return this.name; }
        set 
        { 
            this.name = value;
            FirePropertyChanged(p => p.Name);
        }
    }

    private void FirePropertyChanged<TValue>(Expression<Func<Person, TValue>> propertySelector)
    {
        if (PropertyChanged == null)
            return;

        var memberExpression = propertySelector.Body as MemberExpression;
        if (memberExpression == null)
            return;

        PropertyChanged(this, new PropertyChangedEventArgs(memberExpression.Member.Name));
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

Notice the use of the expression tree to get the name of the property, and the use of the lambda expression as an Expression :

FirePropertyChanged(p => p.Name);

More Related Contents:

  1. Can you use reflection to find the name of the currently executing method?
  2. In WPF, what are the differences between the x:Name and Name attributes?
  3. When creating a new GUI, is WPF the preferred choice over Windows Forms? [closed]
  4. Best way to hide a window from the Alt-Tab program switcher?
  5. My images are blurry! Why isn’t WPF’s SnapsToDevicePixels working?
  6. Apply stroke to a textblock in WPF
  7. Making WPF applications look Metro-styled, even in Windows 7? (Window Chrome / Theming / Theme)
  8. There is no ListBox.SelectionMode=”None”, is there another way to disable selection in a listbox?
  9. In MVVM model should the model implement INotifyPropertyChanged interface?
  10. BitmapImage in WPF does lock file
  11. WPF Handedness with Popups
  12. How can I read/write app.config settings at runtime without using user settings?
  13. Enumerating .NET assembly resources at runtime
  14. WPF – How to force a Command to re-evaluate ‘CanExecute’ via its CommandBindings
  15. How to set and change the culture in WPF
  16. Custom MVVM implementation Vs. PRISM
  17. Lazy loading WPF tab content
  18. Going fullscreen on secondary monitor
  19. What does “{x:Static}” mean in XAML?
  20. DataTrigger not firing
  21. How do You Create a Read-Only Dependency Property?
  22. Binding in a WPF data grid text column
  23. Concatenate strings instead of using a stack of TextBlocks
  24. How to read assembly attributes
  25. Getting parent class’ name using Reflection
  26. How does ItemContainerGenerator.ContainerFromItem work with a grouped list?
  27. How to prevent a new WPF form from stealing focus?
  28. How to implement Balloon message in a WPF application
  29. How do I bind a Byte array to an Image in WPF with a value converter?
  30. Validate data using DataAnnotations with WPF & Entity Framework?

Leave a Comment