Forcing all WPF bound controls to update with GetBindingExpression().UpdateTarget()

Question

I have a WPF application that includes ~50 controls that are bound to properties on my business object which implements INotifyPropertyChanged. Here's a quick snippet of my business object:

public class MyBusinessObject : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, e);
        }
    }

    // properties begin here
    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name == value)
            {
                return;
            }

            _name = value;
            OnPropertyChanged(new PropertyChangedEventArgs("Name"));
        }
    }

    // constructor, etc. not shown
}

I also have several validation rules that are used to validate the user input in these controls. I'm using command binding to prevent my user from saving the data if there are any validation errors. My application also includes a "Reset default values" button which, obviously, will reset the default value for all of the properties on my business object. This all works exactly as I'd like it to with one exception. If my user enters invalid data into one or more controls and then clicks the "Reset default values" button, the controls that contain invalid data don't always update as I'd expect. This happens because of the following code in my property setters:

if (_name == value)
{
    return;
}

This code exists to prevent unnecessary property changed notifications from occurring when the value entered by my user in the bound UI control is the same value that the property is already set to. As an example, I have an IntegerUpDown control in my UI (this control is part of the Extended WPF Toolkit from Xceed). The default value of the property that my control is bound to is 10. My user deletes the value from the control and my validation rule is triggered which results in a validation error and the UI is updated appropriately with an error adorner, etc. The value of the property that this control is mapped to hasn't been changed so it's still set to 10. Now my user clicks the "Reset default values" button which will result in the default value (10) for the property being reset. However, the value for the property is already set to 10 so the short circuit logic in my setter will return instead of setting the property value.

So now, after my user clicks "Reset default values", I am also forcing an update on my binding target like this:

this.myIntegerUpDown.GetBindingExpression(Xceed.Wpf.Toolkit.IntegerUpDown.ValueProperty).UpdateTarget();

This solves my problem but only for this particular control. Is there any easy way to do this for all of my bound controls without having to specify each one? Thanks.

Answer 1

You've mentioned validation and reset values, and of course the obvious one is to persist it.

Why don't you implement IEditableObject Interface on your entity that has three signature methods. BeginEdit(), CancelEdit() and EndEdit()

That way you can easily roll back your entity to the whatever you want, or validate it and lastly persist it. A good example is found here

Sample code

public class Customer : IEditableObject 
{

    struct CustomerData 
    {
        internal string id ;
        internal string firstName ;
        internal string lastName ;
    }

    private CustomersList parent;
    private CustomerData custData; 
    private CustomerData backupData; 
    private bool inTxn = false;

    // Implements IEditableObject 
    void IEditableObject.BeginEdit() 
    {
        Console.WriteLine("Start BeginEdit");
        if (!inTxn) 
        {
            this.backupData = custData;
            inTxn = true;
            Console.WriteLine("BeginEdit - " + this.backupData.lastName);
        }
        Console.WriteLine("End BeginEdit");
    }

    void IEditableObject.CancelEdit() 
    {
        Console.WriteLine("Start CancelEdit");
        if (inTxn) 
        {
            this.custData = backupData;
            inTxn = false;
            Console.WriteLine("CancelEdit - " + this.custData.lastName);
        }
        Console.WriteLine("End CancelEdit");
    }

    void IEditableObject.EndEdit() 
    {
        Console.WriteLine("Start EndEdit" + this.custData.id + this.custData.lastName);
        if (inTxn) 
        {
            backupData = new CustomerData();
            inTxn = false;
            Console.WriteLine("Done EndEdit - " + this.custData.id + this.custData.lastName);
        }
        Console.WriteLine("End EndEdit");
    }

    public Customer(string ID) : base() 
    {
        this.custData = new CustomerData();
        this.custData.id = ID;
        this.custData.firstName = "";
        this.custData.lastName = "";
    }

    public string ID 
    {
        get 
        {
            return this.custData.id;
        }
    }

    public string FirstName 
    {
        get 
        {
            return this.custData.firstName;
        }
        set 
        {
            this.custData.firstName = value;
            this.OnCustomerChanged();
        }
    }

    public string LastName 
    {
        get 
        {
            return this.custData.lastName;
        }
        set 
        {
            this.custData.lastName = value;
            this.OnCustomerChanged();
        }
    }

    internal CustomersList Parent 
    {
        get 
        {
            return parent;
        }
        set 
        {
            parent = value ;
        }
    }

    private void OnCustomerChanged() 
    {
        if (!inTxn && Parent != null) 
        {
            Parent.CustomerChanged(this);
        }
    }

    public override string ToString() 
    {
        StringWriter sb = new StringWriter();
        sb.Write(this.FirstName);
        sb.Write(" ");
        sb.Write(this.LastName);
        return sb.ToString();
    }   
}

Answer 2

OnPropertyChanged(new PropertyChangedEventArgs(string.Empty));

This is intended to imply that ALL properties on that object have changed.

Answer 3

Could you do one of the following?

1) Reset the DataContext - Either recreate it, or re-set the property

var context = this.DataContext;
this.DataContext = null;
this.DataContext = context;

2) Loop through all properties programmatically via reflection and manually call OnPropertyChanged with the relevant property names.

var properties = typeof(ViewModel).GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var property in properties)
{
    this.OnPropertyChanged(new PropertyChangedEventArgs(property.Name));
}

Answer 4

Wouldn't it be easier to just always call OnPropertyChanged regardless of whether its the same? How much of a performance boost does that give you?