Update binding without DependencyProperty

Question

I have a lot of existing business objects with many properties and collections inside which I want to bind the userinterface to. Using DependencyProperty or ObservableCollections inside these objects is not an option. As I know exactly when I modify these objects, I would like to have a mechanism to update all UI controls when I do this. As an extra I also don't know which UI controls bind to these objects and to what properties.

Here is a simplified code of what I tried to do by now:

public class Artikel
{
   public int MyProperty {get;set;}
}

public partial class MainWindow : Window
{
    public Artikel artikel
    {
        get { return (Artikel)GetValue(artikelProperty); }
        set { SetValue(artikelProperty, value); }
    }

    public static readonly DependencyProperty artikelProperty =
        DependencyProperty.Register("artikel", typeof(Artikel), typeof(MainWindow), new UIPropertyMetadata(new Artikel()));

    public MainWindow()
    {
        InitializeComponent();
        test.DataContext = this;
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
         artikel.MyProperty += 1;
         // What can I do at this point to update all bindings?
         // What I know at this point is that control test or some of it's 
         // child controls bind to some property of artikel.
    }
}

<Grid Name="test">
    <TextBlock Text="{Binding Path=artikel.MyProperty}" />
</Grid>

This is, I tried to pack my object into a DependencyProperty and tried to call UpdateTarget on this, but didn't succeed.

What could I do to update the corresponding UI controls?

I hope I described my situation good enough.

Answer 1

Using INotifyPropertyChanged is a good alternative to DependencyProperties.

If you implement the interface you can raise the PropertyChanged event with null as parameter to notify the UI that all properties changed.

Answer 2

(I'm going to assume you can't add INotifyPropertyChanged to your business objects either, and that you don't want to add another "view of the data model" layer of wrapper objects a la MVVM.)

You can manually update bound properties from their data source by calling BindingExpression.UpdateTarget().

myTextBlock.GetBindingExpression(TextBlock.TextProperty).UpdateTarget();

To update all bindings on a control or window, you could use something like this:

using System.Windows.Media;
...
static void UpdateBindings(this DependencyObject obj)
{
    for (var i=0; i<VisualTreeHelper.GetChildrenCount(obj); ++i)
    {
        var child = VisualTreeHelper.GetChild(obj, i);
        if (child is TextBox)
        {
            var expression = (child as TextBox).GetBindingExpression(TextBox.TextProperty);
            if (expression != null)
            {
                expression.UpdateTarget();
            }
        }
        else if (...) { ... }
        UpdateBindings(child);        
    }
}

If you're binding a diverse set of properties then rather than handling them individually as above, you could combine the above with this approach to enumerate all dependency properties on a control and then get any BindingExpression from each; but that relies on reflection which will not be particularly performant.

As a footnote, you can also use BindingExpression.UpdateSource() if you want to explicitly write back to the data source. Controls usually do this anyway when their value changes or when they lose focus, but you control this and do it by hand with {Binding Foo, UpdateSourceTrigger=Explicit}.

Answer 3

As I know exactly when I modify these objects, I would like to have a mechanism to update all UI controls when I do this.

You will find that the most straightforward and maintainable way to deal with this is to implement view model classes for each class you want to present in the UI. This is probably true if you can modify the underlying classes, and almost certainly true if you can't.

You don't need to be using dependency properties for this. Dependency properties are only necessary on the targets of binding, which is to say the controls in the UI. Your view model objects are the source; they need only implement INotifyPropertyChanged.

Yes, this means that you will need to build classes that contain a property for each property exposed in the UI, and that those classes will need to contain observable collections of child view models, and you'll have to instantiate and populate those classes and their collections at runtime.

This is generally not as big a deal as it sounds, and it may be even less of one in your case. The traditional way to build a view model that's bound to a data model is to build properties like this:

public string Foo
{
   get { return _Model.Foo; }
   set
   {
      if (value != _Model.Foo)
      {
         _Model.Foo = value;
         OnPropertyChanged("Foo");
      }
   }
}

But if, as you've claimed, you know when the objects are being updated, and you just want to push the updates out to the UI, you can implement read-only properties, and when the underlying data model gets updated make the view model raise PropertyChanged with the PropertyName property of the event args set to null, which tells binding, "Every property on this object has changed; update all binding targets."