Click here to Skip to main content
15,861,125 members
Articles / Desktop Programming / WPF

Automatic Implementation of INotifyPropertyChanged on POCO Objects

Rate me:
Please Sign up or sign in to vote.
4.92/5 (24 votes)
7 Jan 2011CPOL4 min read 114.5K   2.3K   63   39
Implementing INotifyPropertyChanged automatically using a custom proxy generator

Introduction

Using databinding in WPF obliges to use and implement the INotifyPropertyChanged interface. This task is usually boring, and even unsafe since properties have to be specified by name via simple strings. The property by string issue can be solved using lambda expression, so we can find some helper method that allows us some syntax sugar like...

C#
NotifyPropertyChanged((NotifyPropertyChanged(()=>MyProperty);

...but we need to derive our ViewModel from some special class, and in any case we have to write some boring code every time we set a property. In order to avoid writing such things, we can use AOP to intercept property setters, but this usually involves some 3rd party library to add to our package, and sometimes this is an issue. In this article, we will see a solution to this problem using AOP, but so circumstantial that we will need just a few classes to embed in our solution in order to solve the problem.

Background

Using INotifyPropertyChanged the plain vanilla way:

C#
public class Customer :INotifyPropertyChanged
{
    private string name;

    public string Name
    {
        get { return name; }
        set {
                if(value!=name) 
                    OnPropertyChanged("Name");
                 name = value;
             }
    }
    
    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

With the AutoNotifyPropertyChange helper class, we can reduce the code above to this:

C#
public class Customer 
{
    public virtual string Name
}

Simpler, isn't it?

In order to have the job done with the simple library we are talking about, the following requirements are mandatory to accomplish the result:

  1. ViewModel class has to be public
  2. Property to notify changes on must be public and virtual

Notification will occur only when property is changed through the public interface, proxy does not know anything about internal backing fields.

If a custom implementation of INotifyPropertyChanged is needed, we can pass to the proxy generator a class implementing INotifyPropertyChanged, but in this case we have to ensure the existence of a public or protected function called OnPropertyChanged(string propertyName) firing the event. The proxy generator assumes the function name and supposes the implementation works by firing the PropertyChange event in a proper and consistent way. Below is a model class that already implements INotifyPropertyChanged:

C#
public class ModelSample:INotifyPropertyChanged
{
    public virtual int MyProperty1 { get; set; }
    public virtual double MyProperty2 { get; set; }
    public virtual DateTime MyProperty3 { get; set; }
    public float NoNotify { get; set; }
    #region INotifyPropertyChanged Members
    
    public event PropertyChangedEventHandler PropertyChanged;
    
    #endregion
    
    /* Since this class already implements INotifyPropertyChanged
     * having this function is mandatory
     */
    protected virtual void OnPropertyChanged(string property)
    {
        if (null != PropertyChanged)
            PropertyChanged(this, new PropertyChangedEventArgs(property));
    }
}    

The code below derives a class from Customer and wires the code to fire the PropertyChanged event every time we set a property value with a different value. Please note than the TypeFactory class is in a certain sense fault tolerant. If the interface is implemented, implementing the OnPropertyChanged(string propName) is mandatory. We can leverage fault tolerance in order to avoid notification for certain properties: just declare them as non virtual.

C#
Customer model = Activator.CreateInstance(
                TypeFactory.AutoNotifier<Customer>()
                );

How It Works

The AutoNotifyPropertyChange.TypeFactory class uses CodeDom to internally generate a subclass of the model and wire the code in the property setter. Class is internally compiled and returned as a type.

Let's see this example (POCO) class:

C#
public class ClockViewModel
{
    public virtual int Hour { get; set; }
    public virtual int Minute { get; set; }
    public virtual int Second { get; set; }
    public virtual int Millisecond { get; set; }
    public virtual int Centiseconds { get { return Millisecond / 10; } }        
}

and see the autogenerated class (you will never have to use this code, it is just to show what happens behind the scenes):

C#
namespace @__autonotifypropertychanged
{
    
    
    internal class @__autonotifyClockViewModel : Autonotify.Demo.ClockViewModel, 
		System.ComponentModel.INotifyPropertyChanged
    {
        
        public override int Hour
        {
            get
            {
                return base.Hour;
            }
            set
            {
                if ((false == base.Hour.Equals(value)))
                {
                    base.Hour = value;
                    this.OnPropertyChanged("Hour");
                }
            }
        }
        
        public override int Minute
        {
            get
            {
                return base.Minute;
            }
            set
            {
                if ((false == base.Minute.Equals(value)))
                {
                    base.Minute = value;
                    this.OnPropertyChanged("Minute");
                }
            }
        }
        
        public override int Second
        {
            get
            {
                return base.Second;
            }
            set
            {
                if ((false == base.Second.Equals(value)))
                {
                    base.Second = value;
                    this.OnPropertyChanged("Second");
                }
            }
        }
        
        public override int Millisecond
        {
            get
            {
                return base.Millisecond;
            }
            set
            {
                if ((false == base.Millisecond.Equals(value)))
                {
                    base.Millisecond = value;
                    this.OnPropertyChanged("Millisecond");
                    this.OnPropertyChanged("Centiseconds");
                }
            }
        }
        
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        protected virtual void OnPropertyChanged(string propertyName)
        {
            System.ComponentModel.PropertyChangedEventHandler handler;
            handler = this.PropertyChanged;
            if ((null != handler))
            {
                handler(this, 
		new System.ComponentModel.PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

All the plumbing is done and you obtain a proxy implementing INotifyPropertyChange. You probably noted that the property "Centiseconds" is a read only calculated property, but in the generated code we see the event raising in the correct place: changing the milliseconds force a change to the Centiseconds property too. This is because internally the proxy generator investigates the code for every property getter in order to see if they use other property value, if so the property is considered to be dependent, proper events are fired. The inflector does not look at the code behavior, it simply assumes that if a getter is used then this will influence the result (this is correct while we are not using a property value inside a getter to produce some side effect, in this case a change event will be fired without reason, but in such a situation this will probably not be an issue).

To create the proxy, just write this:

C#
var obj = Activator.CreateInstance( 
AutoNotifyPropertyChange.TypeFactory.AutoNotifier<ClockViewModel>() );

Autogenerated classes are cached internally, so asking many times for the same type does not require the code for the proxy to recreate and rebuild.

Points of Interest

The code is compiled as a DLL, but the classes for the proxy are just a few and can be merged into an existing solution code without any pain, there are no additional dependencies. In the sample application provided, a binding with a simple view is shown, using the ClockViewModel.

History

  • 30th December, 2010: Initial version
  • 4th January, 2011: Article updated

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
Italy Italy
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.

Comments and Discussions

 
QuestionNice Pin
Alen Toma8-Jun-19 6:43
Alen Toma8-Jun-19 6:43 
QuestionNice Pin
jonhy0529-May-16 11:51
jonhy0529-May-16 11:51 
QuestionUsed it in Shielded; Thank you! Pin
Josip Bakić7-Dec-13 12:21
Josip Bakić7-Dec-13 12:21 
SuggestionVery nice work - inside is a markup extension so the DataContext can be easily set in xaml Pin
SBendBuckeye14-Feb-13 10:45
SBendBuckeye14-Feb-13 10:45 
GeneralMy vote of 5 Pin
gjvdkamp22-Feb-11 5:38
gjvdkamp22-Feb-11 5:38 
GeneralHere is my take on it Pin
Siderite13-Jan-11 23:48
Siderite13-Jan-11 23:48 
GeneralPrivate models Pin
Oleg Shilo11-Jan-11 17:44
Oleg Shilo11-Jan-11 17:44 
GeneralRe: Private models Pin
Felice Pollano12-Jan-11 20:33
Felice Pollano12-Jan-11 20:33 
GeneralRe: Private models Pin
Oleg Shilo13-Jan-11 13:04
Oleg Shilo13-Jan-11 13:04 
GeneralIt would be nice if the type could be moved between assemblies. Pin
Siderite10-Jan-11 3:04
Siderite10-Jan-11 3:04 
GeneralRe: It would be nice if the type could be moved between assemblies. Pin
Felice Pollano10-Jan-11 8:12
Felice Pollano10-Jan-11 8:12 
GeneralRe: It would be nice if the type could be moved between assemblies. Pin
Siderite11-Jan-11 0:09
Siderite11-Jan-11 0:09 
GeneralRe: It would be nice if the type could be moved between assemblies. Pin
Felice Pollano11-Jan-11 2:58
Felice Pollano11-Jan-11 2:58 
GeneralRe: It would be nice if the type could be moved between assemblies. Pin
Siderite11-Jan-11 3:40
Siderite11-Jan-11 3:40 
GeneralRe: It would be nice if the type could be moved between assemblies. Pin
Felice Pollano11-Jan-11 4:17
Felice Pollano11-Jan-11 4:17 
GeneralRe: It would be nice if the type could be moved between assemblies. Pin
Siderite11-Jan-11 4:07
Siderite11-Jan-11 4:07 
GeneralRe: It would be nice if the type could be moved between assemblies. Pin
Felice Pollano11-Jan-11 4:18
Felice Pollano11-Jan-11 4:18 
Great,
Thanks for helping improving !
GeneralMy vote of 5 Pin
Siderite10-Jan-11 2:54
Siderite10-Jan-11 2:54 
QuestionProxyGen - How can you create an anonymous delegate statement in CodeDom? Pin
Enrique Albert8-Jan-11 6:01
Enrique Albert8-Jan-11 6:01 
AnswerRe: ProxyGen - How can you create an anonymous delegate statement in CodeDom? Pin
Felice Pollano8-Jan-11 6:44
Felice Pollano8-Jan-11 6:44 
GeneralSuggestion for WPF binding projects Pin
Enrique Albert7-Jan-11 16:09
Enrique Albert7-Jan-11 16:09 
GeneralRe: Suggestion for WPF binding projects Pin
Felice Pollano7-Jan-11 22:00
Felice Pollano7-Jan-11 22:00 
GeneralRe: Suggestion for WPF binding projects Pin
Enrique Albert8-Jan-11 1:17
Enrique Albert8-Jan-11 1:17 
GeneralRe: Suggestion for WPF binding projects Pin
Felice Pollano8-Jan-11 2:15
Felice Pollano8-Jan-11 2:15 
GeneralMy vote of 5 Pin
Rob.mz5-Jan-11 11:01
professionalRob.mz5-Jan-11 11:01 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.