Raising PropertyChanged for all properties

When working with WPF (Windows Presentation Foundation) you will often face the need to update the user interface based on some changes that took place in your view model. This is most of the time achieved by implementing the INotifyPropertyChanged interface and raising the PropertyChanged event every time your data-bound properties change their value.

You are most likely to find code that looks something like this:

public class PersonViewModel : INotifyPropertyChanged
{
   public event PropertyChangedEventHandler PropertyChanged;

   private string _firstName;
   public string FirstName
   {
      get { return _firstName; }
      set
          {
            _firstName = value;

            if (PropertyChanged != null)
               PropertyChanged(this, new PropertyChangedEventArgs("FirstName"));
           }
   }
}

Note: there are nicer ways of achieving this, but they fall out of the scope of this post.

Depending on your scenario, the above pattern can become less elegant if most of the properties of your view model change at once. In this case, polluting the view model with code that raises the PropertyChanged event for each property is undesirable, and a better way to notify that all properties have changed their value is needed. This is the case when you can use a documented obscurity of WPF: raising the PropertyChanged event and supplying null or string.Empty for the propertyName constructor parameter of PropertyChangedEventArgs.

private void NotifyAllPropertiesHaveChanged()
{
   if (PropertyChanged != null)
      PropertyChanged(this, new PropertyChangedEventArgs(null));
}

The readability of the above code sample is astonishing, what on earth new PropertyChangedEventArgs(null) is supposed to mean? When code reviewing such code, my “bug-detecting” sensors would go wild (ArgumentNullException, NullReferenceException, etc), however, luckily the whole thing is wrapped around a NotifyAllPropertiesHaveChanged method, which would help calm things down a bit, but it would still fall short in convincing a non-believer that the above implementation is finished, or it is just a stub.

A nicer implementation would be to create a new class AllPropertiesChangedEventArgs  that inherits the PropertyChangedEventArgs class.

public class AllPropertiesChangedEventArgs : PropertyChangedEventArgs
{
   public AllPropertiesChangedEventArgs()
      : base(null)
   { }
}

The new class will isolate the obscure way of raising the PropertyChanged event, and will also make the code more readable and explicit.

public void NotifyAllPropertiesHaveChanged()
{
   if (PropertyChanged != null)
         PropertyChanged(this, new AllPropertiesChangedEventArgs());
}