Detailed description of the INotifyPropertyChanged interface

In Windows Phone Development 8.1: Data Binding, we learned the basics of data binding. In the next few articles, we will continue to learn more about data binding. Today, we will look at the implementation of the INotifyPropertyChanged interface, which is very important in data binding.
When to implement the INotifyPropertyChanged interface

Official explanation: The INotifyPropertyChanged interface is used to notify the client (usually the client that performs the binding) that a property value has changed. The official explanation is very vague, and I guess I don’t know when I need to implement the INotifyPropertyChanged interface. Xiao Meng gave a clear conclusion through actual testing:

First: OneTime mode: It is meaningless, because its binding is only once at the beginning, and there is no change at all! Naturally, there is no implementation of the INotifyPropertyChanged interface.

Then there is the OneWay mode: We know that the meaning of the OneWay mode is that every change in the binding source will notify the binding target, but the change of the binding target will not change the binding source. When the data entity class of the binding source does not implement the INotifyPropertyChanged interface, when we change the data source, we will find that the corresponding data on the UI of the binding target will not change immediately. So at this time we need to implement the INotifyPropertyChanged interface.

*** is the TwoWay mode: In the TwoWay mode, when the data entity class of the binding source does not implement the INotifyPropertyChanged interface, we find that the change of the control will cause the data source to change immediately, but the change of the data source will not change the binding target control immediately! So when we need the corresponding UI to change immediately when the data source changes, we need to implement the INotifyPropertyChanged interface.

In short: when the data source changes and the UI needs to change immediately, we need to implement the INotifyPropertyChanged interface.

We can clearly see this through this example:

 <StackPanel> 
 
       <TextBox Header= "Number" Text= "{Binding ID,Mode=OneTime}" Name= "tbxID" ></TextBox> 
 
        <TextBox Header= "Book Title" Text= "{Binding Title,Mode=OneWay}" Name= "tbxTitle" ></TextBox> 
 
       <TextBox Header= "Price" Text= "{Binding Price,Mode=TwoWay}" Name= "tbxPrice" ></TextBox> 
 
 <Button Content= "Modify the value of the control through the data source" Click= "Button_Click" ></Button> 
 
 <Button Content= "Modify the value of the control directly" Click= "Button_Click_1" /> 
 
 <Button Content= "Modify the value of the data source through the control" Click= "Button_Click_2" /> 
 
 </StackPanel>

Background code

 namespace INotifyPropertyChangedDEMO
 {
 /// <summary>  
 /// Can be used by itself or to navigate to a blank page inside a Frame.  
 /// </summary>   
 
 public sealed partial class MainPage : Page
 {
        Book book = new Book();
 public MainPage()
 {
 this .InitializeComponent(); 
 
 this .NavigationCacheMode = NavigationCacheMode.Required;
 book.ID = 0 ;
 book.Title = "ASP.NET Development Manual" ;
 book.Price = 40 ;
            st.DataContext = book;
 }
 private   void Button_Click(object sender, RoutedEventArgs e) //Modify the value of the control by modifying the data source  
 {
 book.ID = 100 ;
 book.Price = 50 ;
 book.Title = "SL Development Manual" ;
 } 
 
 private async void Button_Click_1(object sender, RoutedEventArgs e) //Display the value of the data source  
 {
            await new MessageDialog(book.ID.ToString() + " " + book.Title.ToString() + " " + book.Price.ToString()).ShowAsync();
 } 
 
 public   class Book: INotifyPropertyChanged
 //The INotifyPropertChanged interface defines an event that is executed when a property value changes. The event name is PropertyChanged.  
 //This is an event that must be implemented by the class that inherits this interface   
 
 {
 private   int _id;
 public   int ID
 {
                get { return _id; }
 set
 {
                    _id = value;
 //NotifyPropertyChange("ID");  
 }
 }
 private string _title;
 public string Title
 {
                get { return _title; }
 set
 {
                    _title = value;
 //NotifyPropertyChange("Title");  
 }
 }
 private   double _price;
 public   double price
 {
                get { return _price; }
 set
 {
                    _price = value;
 //NotifyPropertyChange("Price");  
 }
 }
 public event PropertyChangedEventHandler PropertyChanged;
 //PropertyChangedEventArgs type, this class is used to pass the name of the property whose value has changed, and to send a change notification to the client for the property that has changed. The name of the property is a string type.  
 private   void NotifyPropertyChange(string propertyName)
 {
 if (PropertyChanged != null )
 {
 //According to the delegate class of the PropertyChanged event, implement the PropertyChanged event:  
                    PropertyChanged( this , new PropertyChangedEventArgs(propertyName));
 }
 }
 }
 }
 }

You can clearly experience the role of the INotifyPropertyChanged interface by running this example.
How to implement INotifyPropertyChanged interface

The implementation of the INotifyPropertyChanged interface in the above example is the most common and universal one.

We can simplify this by using the CallerMemberNameAttribute attribute, which determines which attribute name to pass in based on the caller:

 protected   void OnPropertyChanged([CallerMemberName] string propertyName = null )
 {
            var eventHandler = this .PropertyChanged;
 if (eventHandler != null )
                eventHandler( this , new PropertyChangedEventArgs(propertyName));
 }

So we can call it like this:

NotifyPropertyChange("ID") is changed to:OnPropertyChanged();

The best implementation of the INotifyPropertyChanged interface:

This so-called *** implementation method is mentioned in the video of channel 9. The implementation method is as follows:

 public   class ModelBase : INotifyPropertyChanged
 {
 public event PropertyChangedEventHandler PropertyChanged;
 protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] String propertyName = null )
 {
 if (object.Equals(storage, value)) return   false ;
 storage = value;
 this .OnPropertyChanged(propertyName);
 return   true ;
 } 
 
 protected   void OnPropertyChanged([CallerMemberName] string propertyName = null )
 {
            var eventHandler = this .PropertyChanged;
 if (eventHandler != null )
                eventHandler( this , new PropertyChangedEventArgs(propertyName));
 }
 }

The corresponding calling method is further simplified:

 private string name; 
 
 public string Name
 {
           get { return name; }
 set
           { this .SetProperty(ref this .name, value); }
 }

Link to this article: http://www.cnblogs.com/bcmeng/p/3966931.html