Perché utilizzare INotifyPropertyChanged con i binding in WPF?

Question

Ho notato che praticamente ogni esempio che trovo su Internet riguardo i binding ha una classe (che si lega a un'altra proprietà) che eredita l'interfaccia INotifyPropertyChanged e usa un metodo nella parte set della proprietà della classe.

Ho provato a rimuovere quella parte dall'esempio di collegamento e ha funzionato come con il metodo.

Ecco l'esempio. L'ho modificato in modo che fosse una modalità di binding TwoWay e mostri la proprietà modificata in una messagebox.

l'ho fatto solo per giocare in giro un po 'con attacchi, ma ora davvero non so perché viene utilizzata l'interfaccia

EDIT

XAML:

<Window x:Class="WpfApplication1.MainWindow" 
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
     Title="MainWindow" Height="350" Width="525"> 
    <Grid> 
     <Grid.RowDefinitions> 
      <RowDefinition Height="30"/> 
      <RowDefinition Height="30"/> 
      <RowDefinition Height="30"/> 
      <RowDefinition Height="30"/> 
      <RowDefinition Height="30"/> 
      <RowDefinition Height="40"/> 
      <RowDefinition Height="30"/> 
      <RowDefinition Height="30"/> 
      <RowDefinition Height="30"/> 
      <RowDefinition Height="30"/> 
     </Grid.RowDefinitions> 
     <Grid.ColumnDefinitions> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="100"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
      <ColumnDefinition Width="30"/> 
     </Grid.ColumnDefinitions> 
     <Button Grid.Row="5" Grid.Column="5" Name="btnBinding" Click="btnBinding_Click" Width="100" Height="30"> 
      <Grid HorizontalAlignment="Left" VerticalAlignment="Center"> 
       <Grid.RowDefinitions> 
        <RowDefinition Height="25"/> 
       </Grid.RowDefinitions> 
       <Grid.ColumnDefinitions> 
        <ColumnDefinition Width="50"/> 
        <ColumnDefinition Width="50"/> 
       </Grid.ColumnDefinitions> 
       <TextBox Name="txtBinding" Width="30" Height="25" HorizontalAlignment="Left"/> 
       <Label Grid.Column="1" Content="Bind"/> 
      </Grid> 
     </Button> 
     <Button Grid.Column="5" Grid.Row="6" Name="btnMessage" Click="btnMessage_Click" Content="MessageBox"/> 
     <Button Grid.Column="5" Grid.Row="4" Name="btnChangeproperty" Click="btnChangeproperty_Click" Content="Change Property"/> 
    </Grid> 
</Window> 

Main.cs:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Data; 
using System.Windows.Documents; 
using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Imaging; 
using System.Windows.Navigation; 
using System.Windows.Shapes; 

namespace WpfApplication1 
{ 
    /// <summary> 
    /// Interaction logic for MainWindow.xaml 
    /// </summary> 
    public partial class MainWindow : Window 
    { 
     Binding bind; 
     MyData mydata; 
     public MainWindow() 
     { 
      InitializeComponent(); 
     } 

     private void btnBinding_Click(object sender, RoutedEventArgs e) 
     { 
      mydata = new MyData("T"); 
      bind = new Binding("MyDataProperty") 
      { 
       Source = mydata, 
       Mode = BindingMode.TwoWay 
      }; 

      txtBinding.SetBinding(TextBox.TextProperty, bind); 
     } 

     private void btnMessage_Click(object sender, RoutedEventArgs e) 
     { 
      MessageBox.Show(mydata.MyDataProperty); 
     } 

     private void btnChangeproperty_Click(object sender, RoutedEventArgs e) 
     { 
      mydata.MyDataProperty = "New Binding"; 
     } 
    } 
} 

MyData cla ss:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.ComponentModel; 

namespace WpfApplication1 
{ 
    public class MyData 
    { 
     private string myDataProperty; 

     public MyData() { } 

     public MyData(DateTime dateTime) 
     { 
      myDataProperty = "Last bound time was " + dateTime.ToLongTimeString(); 
     } 

     public MyData(string teste) 
     { 
      myDataProperty = teste; 
     } 

     public String MyDataProperty 
     { 
      get { return myDataProperty; } 
      set 
      { 
       myDataProperty = value; 
       OnPropertyChanged("MyDataProperty"); 
      } 
     } 

     public event PropertyChangedEventHandler PropertyChanged; 

     private void OnPropertyChanged(string info) 
     { 
      PropertyChangedEventHandler handler = PropertyChanged; 
      if (handler != null) 
      { 
       handler(this, new PropertyChangedEventArgs(info)); 
      } 
     } 
    } 
} 

Answer 1

Non è necessario INotifyPropertyChanged se si intende utilizzare solo il legame con scrittura alla proprietà (come avete scoperto), ma si ha bisogno in modo che si può dire che qualcun altro ha scritto alla proprietà e aggiorna il valore visualizzato di conseguenza.

Per vedere di cosa sto parlando, aggiungi un pulsante alla finestra che, quando viene fatto clic, modifica direttamente il valore della proprietà associata (non l'attributo corrispondente dell'elemento dell'interfaccia utente associato a tale proprietà). Con INotifyPropertyChanged, vedrai l'interfaccia utente aggiornarsi al nuovo valore quando fai clic sul pulsante; senza di esso, l'interfaccia utente mostrerà ancora il valore "vecchio".

Answer 2

Dalle discussioni qui, credo vi siete persi attuazione

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(“Propety Name”)) 

Una volta che viene implementato si può vedere che l'interfaccia utente è l'aggiornamento automatico. È possibile visualizzare i dettagli su MSDN o una versione breve a my blog here.