INotifyPropertyChange – notifying about change of all properties at once

2014-08-242016-01-30 TPodolakINotifyPropertyChanged, MVVM, Silverlight, WPF1 Comment

Today, working on a new feature for my pet project, I realized that I have to notify the view, that all properties in view model have changed. The most obvious way to achieve that would, of course be to rise PropertyChange event a bunch of times.

protected virtual void OnPropertyChanged(Expression<Func<object>> propertyExpression)
{
   //..
   //implementation
   //..
}

protected virtual void OnPropertyChanged(string propertyName)
{
   //..
   //implementation
   //..
}

public void Refresh()
{
   OnPropertyChanged(() => FirstProperty);
   OnPropertyChanged(() => SecondProperty);
   OnPropertyChanged(() => ThirdProperty);
   //and so on ...
}

protected virtual void OnPropertyChanged(Expression<Func<object>> propertyExpression)

{

//..

//implementation

//..

}

protected virtual void OnPropertyChanged(string propertyName)

{

//..

//implementation

//..

}

public void Refresh()

{

OnPropertyChanged(() => FirstProperty);

OnPropertyChanged(() => SecondProperty);

OnPropertyChanged(() => ThirdProperty);

//and so on ...

}

This is good solution for one time usage, however I was interested in something more general, something which could be extracted to base view model. Fortunately, it turns out that there is a simple trick to do that. All You have to do is use an empty string or null as a property name. So in my case this comes down to this one-liner

public void Refresh()
{
   OnPropertyChanged(string.Empty);
}

public void Refresh()

{

OnPropertyChanged(string.Empty);

}

Implementing INotifyPropertyChanged without lambda expressions and “magic” strings

2014-01-192016-01-30 TPodolak.NET 4.5, c#, CallerMemberName, INotifyPropertyChanged1 Comment

I think almost every .NET developer is familiar with INotifyPropertyChanged interface. Typical implementation of this interface looks more or less like that:

public class NotifyPropertyBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged( Expression<Func<object>> propertyExpression )
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler( this, new PropertyChangedEventArgs( GetPropertyName( propertyExpression ) ) );
    }

    private string GetPropertyName( Expression<Func<object>> propertyExpression )
    {
        var unaryExpression = propertyExpression.Body as UnaryExpression;
        var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;
        var propertyName = memberExpression.Member.Name;
        return propertyName;
    }
}

public class NotifyPropertyBase : INotifyPropertyChanged

{

public event PropertyChangedEventHandler PropertyChanged;

protected virtual void OnPropertyChanged( Expression<Func<object>> propertyExpression )

{

PropertyChangedEventHandler handler = PropertyChanged;

if (handler != null) handler( this, new PropertyChangedEventArgs( GetPropertyName( propertyExpression ) ) );

}

private string GetPropertyName( Expression<Func<object>> propertyExpression )

{

var unaryExpression = propertyExpression.Body as UnaryExpression;

var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;

var propertyName = memberExpression.Member.Name;

return propertyName;

}

Thanks to lambda expressions we can get rid of so called “magic” strings when rising PorpertyChange event.

private int _myProperty;
public int MyProperty
{
    get { return _myProperty; }
    set
    {
        if (_myProperty == value) return;
        _myProperty = value;
        OnPropertyChanged( ( ) => MyProperty );
    }
}

private int _myProperty;

public int MyProperty

{

get { return _myProperty; }

set

{

if (_myProperty == value) return;

_myProperty = value;

OnPropertyChanged( ( ) => MyProperty );

}

However, with .NET 4.5 we can even get rid of lambda expressions itself. Everything thanks to CallerMemberNameAttribute, which provides us information about caller of given method. Now we can rewrite NotifyPropertyBase class as follows

public class NotifyPropertyBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged( [CallerMemberName] string propertyName = null )
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler( this, new PropertyChangedEventArgs( propertyName));
    }
}

public class NotifyPropertyBase : INotifyPropertyChanged

{

public event PropertyChangedEventHandler PropertyChanged;

protected virtual void OnPropertyChanged( [CallerMemberName] string propertyName = null )

{

PropertyChangedEventHandler handler = PropertyChanged;

if (handler != null) handler( this, new PropertyChangedEventArgs( propertyName));

}

From this moment we can call OnPropertyChanged method without any arguments

private int _myProperty;
public int MyProperty
{
    get { return _myProperty; }
    set 
    {
      if (_myProperty == value) return;
      _myProperty = value;
      OnPropertyChanged();
    }
}

private int _myProperty;

public int MyProperty

{

get { return _myProperty; }

set

{

if (_myProperty == value) return;

_myProperty = value;

OnPropertyChanged();

}

and thanks to CallerMemberName attribute, argument propertyName will be filled with appropriate value.

Source code for this post can be found here

INotifyPropertyChanged oraz Expresssion Trees

2011-11-272016-01-31 TPodolakExpressionTree, INotifyPropertyChanged, LambdaExpression

Interfejs INotifyPropertyChangedPropertyChanged znany jest prawdopodobnie każdemu programiście C#. Interfejs ten zawiera jedynie jedno zdarzenie

public event PropertyChangedEventHandler PropertyChanged;

1	public event PropertyChangedEventHandler PropertyChanged;

które powinniśmy odpalić w momencie gdy dana właściwość zostanie przez nas zmieniona. Dzięki temu dowolny obiekt, który będzie nasłuchiwał zmian danej właściwości zostanie o tym poinformowany. Przykładowa klasa implementująca ten interfejs może wyglądać w następujący sposób:

public class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    public void NotifyPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
    
    private string viewModelName;
    public string ViewModelName
    {
        get { return viewModelName; }
        set
        {
            viewModelName = value;
            NotifyPropertyChanged("ViewModelName");
        }
    }
}

public class ViewModelBase : INotifyPropertyChanged

{

public event PropertyChangedEventHandler PropertyChanged;

public void NotifyPropertyChanged(string propertyName)

{

if (PropertyChanged != null)

PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

}

private string viewModelName;

public string ViewModelName

{

get { return viewModelName; }

set

{

viewModelName = value;

NotifyPropertyChanged("ViewModelName");

}

Jak widać została stworzona funkcja pomocniczna

public void NotifyPropertyChanged(string propertyName)

1	public void NotifyPropertyChanged(string propertyName)

którą wywołujemy w setterze danej właściwości, podając w parametrze nazwę tej właściwości.
Niestety podejście takie jest bardzo podatne na błędy. Po pierwsze bardzo łatwo można przekręcić nazwę właściwości, a co gorsze rozwiązanie takie nie jest uwzględniane podczas refactoringu. Dlatego też w celu poprawienia naszego rozwiązania skorzystamy z mechanizmów dostarczanych przez Expression Trees.
Po pierwsze zmieniamy funkcję

public void NotifyPropertyChanged(string propertyName)

1	public void NotifyPropertyChanged(string propertyName)

public void NotifyPropertyChanged(Expression<Func<object>> propertyExpression)
{
    if(PropertyChanged == null) return;
    
    PropertyChanged(this, new PropertyChangedEventArgs(GetPropertyName(propertyName)));
}

public void NotifyPropertyChanged(Expression<Func<object>> propertyExpression)

{

if(PropertyChanged == null) return;

PropertyChanged(this, new PropertyChangedEventArgs(GetPropertyName(propertyName)));

}

funkcja pomocnicza GetPropertyName ma następującą postać

private string GetPropertyName(Expression<Func<object>> propertyExpression)
{
    var unaryExpression = propertyExpression.Body as UnaryExpression;
    var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;
    var propertyName = memberExpression.Member.Name;
    return propertyName;
}

private string GetPropertyName(Expression<Func<object>> propertyExpression)

{

var unaryExpression = propertyExpression.Body as UnaryExpression;

var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;

var propertyName = memberExpression.Member.Name;

return propertyName;

}

Teraz wystarczy prosty zapis

NotifyPropertyChanged(()=> ViewModelName)

1	NotifyPropertyChanged(()=> ViewModelName)

który odwołuje się bezpośrednio do właściwości a nie jej nazwy. Dzięki temu kod w całości zostanie zrefaktoryzowany. Rozwiązanie to jest teoretycznie odrobinę wolniejsze od używania stringów, jednak w praktyce jest to niezauważalne.
Można również funkcję

string GetPropertyName(Expression<Func<object>> propertyExpression)

1	string GetPropertyName(Expression<Func<object>> propertyExpression)

wyciągnąc do osobnej klasy i zrobić z tej funkcji extension method.

public static string GetPropertyName(this object obj, Expression<Func<object>> propertyExpression)
{
    var unaryExpression = propertyExpression.Body as UnaryExpression;
    var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;
    var propertyName = memberExpression.Member.Name;
    return propertyName;
}

public static string GetPropertyName(this object obj, Expression<Func<object>> propertyExpression)

{

var unaryExpression = propertyExpression.Body as UnaryExpression;

var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;

var propertyName = memberExpression.Member.Name;

return propertyName;

}

Od teraz wystarczy, że zaimportujemy odpowiedni namespace i możemy wykorzystać naszą funkcję w każdej klasie.

.NET BLOG

.NET, C# blog

INotifyPropertyChanged

INotifyPropertyChange – notifying about change of all properties at once

Implementing INotifyPropertyChanged without lambda expressions and “magic” strings

INotifyPropertyChanged oraz Expresssion Trees