typesafe NotifyPropertyChanged using linq expressions

Question

Form Build your own MVVM I have the following code that lets us have typesafe NotifyOfPropertyChange calls:

public void NotifyOfPropertyChange<TProperty>(Expression<Func<TProperty>> property)
{
    var lambda = (LambdaExpression)property;
    MemberExpression memberExpression;
    if (lambda.Body is UnaryExpression)
    {
        var unaryExpression = (UnaryExpression)lambda.Body;
        memberExpression = (MemberExpression)unaryExpression.Operand;
    }
    else memberExpression = (MemberExpression)lambda.Body;
    NotifyOfPropertyChange(memberExpression.Member.Name);
 }

How does this approach compare to standard simple strings approach performancewise? Sometimes I have properties that change at a very high frequency. Am I safe to use this typesafe aproach? After some first tests it does seem to make a small difference. How much CPU an memory load does this approach potentially induce?

You might be interested in this discussion: [**Best Practices: How to implement INotifyPropertyChanged right?**](http://compositeextensions.codeplex.com/Thread/View.aspx?ThreadId=53731) — jbe, Apr 30 '10 at 16:54

score 5 · Accepted Answer · answered Apr 26 '10 at 06:35

What does the code that raises this look like? I'm guessing it is something like:

NotifyOfPropertyChange(() => SomeVal);

which is implicitly:

NotifyOfPropertyChange(() => this.SomeVal);

which does a capture of this, and pretty-much means that the expression tree must be constructed (with Expression.Constant) from scratch each time. And then you parse it each time. So the overhead is definitely non-trivial.

Is is too much though? That is a question only you can answer, with profiling and knowledge of your app. It is seen as OK for a lot of MVC usage, but that isn't (generally) calling it in a long-running tight loop. You need to profile against a desired performance target, basically.

perf comparisons http://www.pochet.net/blog/2010/06/25/inotifypropertychanged-implementations-an-overview/ — Simon, Dec 01 '12 at 04:40
@Simon of course, in c# 5 the new caller-name attributes make it almost a redundant question — Marc Gravell, Dec 01 '12 at 07:20

score 2 · Answer 2 · answered Jul 27 '10 at 11:00

Emiel Jongerius has a good performance comparrison of the various INotifyPropertyChanged implementations.

http://www.pochet.net/blog/2010/06/25/inotifypropertychanged-implementations-an-overview/

The bottom line is if you are using INotifyPropertyChanged for databinding on a UI then the performance differences of the different versions is insignificant.

score 1 · Answer 3 · answered Oct 12 '12 at 14:48

How about using the defacto standard

if (propName == value) return;
propName = value;
OnPropertyChanged("PropName");

and then create a custom tool that checks and refactors the code file according to this standard. This tool could be a pre-build task, also on the build server. Simple, reliable, performs.

score 0 · Answer 4 · answered Aug 29 '12 at 23:34

I use the following method in a base class implementing INotifyPropertyChanged and it is so easy and convenient:

public void NotifyPropertyChanged()
    {
        StackTrace stackTrace = new StackTrace();

        MethodBase method = stackTrace.GetFrame(1).GetMethod();

        if (!(method.Name.StartsWith("get_") || method.Name.StartsWith("set_")))
        {
            throw new InvalidOperationException("The NotifyPropertyChanged() method can only be used from inside a property");
        }

        string propertyName = method.Name.Substring(4);

        RaisePropertyChanged(propertyName);
    }

I hope you find it useful also. :-)

PLease do not spam the same answer across multiple questions. If the question is a duplicate, leave a comment indicating such (or flag if you have enough reputation). If it's not a duplicate, please tailor your answer to the question asked. — George Stocker, Aug 30 '12 at 00:35

score 0 · Answer 5 · answered Nov 29 '12 at 15:32

0

Typesafe and no performance loss: NotifyPropertyWeaver extension. It adds in all the notification automatically before compiling...

answered Nov 29 '12 at 15:32

Marc

12,706
7
61
97

score 0 · Answer 6 · answered Mar 26 '11 at 20:29

0

Stack walk is slow and lambda expression is even slower. We have solution similar to well known lambda expression but almost as fast as string literal. See http://zamboch.blogspot.com/2011/03/raising-property-changed-fast-and-safe.html

answered Mar 26 '11 at 20:29

Pavel Savara

3,427
1
30
35

typesafe NotifyPropertyChanged using linq expressions

6 Answers6

Linked

Related