UI not getting change update when working with LIST and INotifyPropertyChanged

Question

i was trying to know two way data binding. i have simple car class which extend INotifyPropertyChanged for notify the change to update UI. bind List object to few textboxes and notice when one textbox value change then other textbox value not updated. all
textboxes bind to same property. so one's value change should propagate to other textboxes.
this is my code
public class Car : INotifyPropertyChanged
private string _make;
private string _model;
private int _year;
public event PropertyChangedEventHandler PropertyChanged;
public Car(string make, string model, int year)
_make = make;
_model = model;
_year = year;
public string Make
get { return _make; }
set
_make = value;
this.NotifyPropertyChanged("Make");
public string Model
get { return _model; }
set
_model = value;
this.NotifyPropertyChanged("Model");
public int Year
get { return _year; }
set
_year = value;
this.NotifyPropertyChanged("Year");
private void NotifyPropertyChanged(string name)
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(name));
This way i bind
Car carTest;
private void Form1_Load(object sender, EventArgs e)
carTest = new Car("Ford", "Mustang", 1967);
List<Car> ol = new List<Car>();
ol.Add(carTest);
this.textBox1.DataBindings.Add("Text", ol, "Make", true, DataSourceUpdateMode.OnPropertyChanged);
this.textBox2.DataBindings.Add("Text", ol, "Make", true, DataSourceUpdateMode.OnPropertyChanged);
this.textBox3.DataBindings.Add("Text", ol, "Make");
when run the code then Ford was showing as make name but when change value in any textbox then that change is not shown in other textboxes.
the moment i change this line List<Car> ol = new List<Car>(); to
BindingList<Car> ol = new BindingList<Car>(); then code started to work fine.
My Question
1) what is the difference between List and BindingList class ?
2) can't we use List<> for my situation instead of BindingList
3)
this.textBox2.DataBindings.Add("Text", ol, "Make", true, DataSourceUpdateMode.OnPropertyChanged);
this.textBox3.DataBindings.Add("Text", ol, "Make");
see the above code and tell me what is the advantage of using DataSourceUpdateMode.OnPropertyChanged because i have seen if we do not use this code
DataSourceUpdateMode.OnPropertyChanged then also data change is propagated to other textbox when cursor focus change.

Answer 1

I would have thought that'd work with List<t>, in fact I think there must be something wrong in your code there.  I can't spot it though.
I recommend use of ObservableCollection rather than BindingList.
The default on bindings is that changes are propagated from the target ( view ) to source ( vm ) when the control loses focus.
If you want to do the equivalent to a keydown event handler in a viewmodel then onpropertychanged is the way to go.
You want to avoid creating bindings in code unless you really really have to, it's way easier to put them in xaml.
Even if your ui is dynamic, you can build xaml and use that to create the ui objects:
http://social.technet.microsoft.com/wiki/contents/articles/28797.aspx
The difference between BindingList and List is, literally, iBindingList.
See
https://msdn.microsoft.com/en-us/library/system.componentmodel.ibindinglist%28v=vs.110%29.aspx?f=255&MSPPError=-2147217396
What probably isn't very obvious is that BindingList fires an event - iirc  itemchanged when properties on objects in it change.
Maybe you did something wrong in your implementation of inotifypropertychanged.  I must admit, I can't see anything there though.
You don't really need those magic strings since .net4.5 and you also don't need to explicitly implement inotifypropertychanged you could use:
public event PropertyChangedEventHandler PropertyChanged;
public void RaisePropertyChanged([CallerMemberName] String propertyName = "")
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
As used in this:
https://gallery.technet.microsoft.com/WPF-Dynamic-Fonts-ad3741ca
If you try that sample you can have:
public class FontDetails : INotifyPropertyChanged
or
public class FontDetails
And you can see it still notifies change successfully to both windows.
Most wpf devs will use observablecollection rather than List or bindinglist.
Observablecollection notifies addition or removal of entries.  It can be used to notify an entry has changed, but does not detect change of property.  You would have to raise the event in code if you want to tell it an item changed.
Hope that helps.
Technet articles: Uneventful MVVM;
All my Technet Articles