How do I make Binding respect DependencyProperty value coercion?

Question

I have a control with a DependencyProperty with a CoerceValueCallback. This property is bound to a property on a model object.

When setting the control property to a value that causes coercion the Binding pushes the uncoerced value to the model object. The property value on the control is coerced correctly.

How do I get the Binding to push the coerced value to the model object?

void Initialize()
{
    UIObject ui = new UIObject();
    ModelObject m = new ModelObject();
    m.P = 4;

    Binding b = new Binding("P");
    b.Source = m;
    b.Mode = BindingMode.TwoWay;
    Debug.WriteLine("SetBinding");
    // setting the binding will push the model value to the UI
    ui.SetBinding(UIObject.PProperty, b);

    // Setting the UI value will result in coercion but only in the UI.
    // The value pushed to the model through the binding is not coerced.
    Debug.WriteLine("Set to -4");
    ui.P = -4;

    Debug.Assert(ui.P == 0);
    // The binding is TwoWay, the DP value is coerced to 0.
    Debug.Assert(m.P == 0); // Not true. This will be -4. Why???
}

class UIObject : FrameworkElement
{
    public static readonly DependencyProperty PProperty =
        DependencyProperty.Register("P", typeof(int), typeof(UIObject), 
        new FrameworkPropertyMetadata(
            new PropertyChangedCallback(OnPChanged), 
            new CoerceValueCallback(CoerceP)));

    public int P
    {
        get { return (int)GetValue(PProperty); }
        set { SetValue(PProperty, value); }
    }

    private static void OnPChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        Debug.WriteLine(typeof(UIObject) + ".P changed from " + e.OldValue + " to " + e.NewValue);
    }

    private static object CoerceP(DependencyObject sender, object value)
    {
        int p = (int)value;
        if (p < 0)
        {
            Debug.WriteLine(typeof(UIObject) + ".P coerced from " + p + " to 0");
            p = 0;
        }
        return p;
    }
}

class ModelObject
{
    private int p;
    public int P
    {
        get
        {
            Debug.WriteLine(this + ".P returned " + this.p);
            return this.p;
        }
        set
        {
            Debug.WriteLine(this + ".P changed from +" + this.p + " to " + value);
            this.p = value;
        }
    }
}

score 2 · Answer 1 · answered Nov 03 '09 at 04:38

2

I think that that's the whole idea of the coercion - correct value on the fly without triggering modification of any other dependencies. You can use the code below instead of native coercion mechanisms:

OnPChanged(/* ... */)
{
    // ...
    var coercedP = CoerceP(P);
    if (P != coercedP)
        P = coercedP;
    // ...
}

HTH.

answered Nov 03 '09 at 04:38

HolisticElastic

937
8
17

3

I'm a bit confused.. why would you want to coerce a value but still have e.g. GUI elements bound to the property display a non-coerced value? The GUI will then display something that is not true... – Isak Savo Feb 10 '10 at 14:54
The think is that if you enforce the coercion on both sides of the binding, then there would be nothing wrong with bound GUI or whatever it's bounded to. Topicstarter is trying to coerce the value on receiving side (e.g. on the GUI side). – HolisticElastic Feb 10 '10 at 15:29

score 1 · Accepted Answer · answered Mar 20 '09 at 17:04

1

I don't think the coerce callback is meant to be a two-way street. One workaround would be to update the model's value inside of the coerce callback.

answered Mar 20 '09 at 17:04

Steven

4,826
3
35
44

Smagin Alexey · Answer 3 · 2017-04-12T06:36:07.287

Here is extension method where you set value on target object

public static void SetTargetValue<T>(this FrameworkElement element, DependencyProperty dp, T value)
    {
        var binding = BindingOperations.GetBinding(element, dp);
        if (binding == null) return;
        var name = binding.Path.Path;
        var splits = name.Split('.');
        var target = element.DataContext;
        for (var i = 0; i < splits.Length; i++)
        {
            PropertyInfo property;
            if (i == splits.Length - 1)
            {
                property = target.GetType().GetProperty(splits[i]);
                property.SetValue(target, value);
            }
            else
            {
                property = target.GetType().GetProperty(splits[i]);
                target = property.GetValue(target);
            }
        }
    }

So, in this method, using binding, you can set value to source. Of cource source Path can have a lot of names - Property1.Property2.Property3 and etc. In coerce method you need only call this method:

private static object CoerceProperty(DependencyObject d, object baseValue)
    {
        if (!Check)
        {
            var sender = (FrameworkElement)d;
            sender.SetTargetValue(MyPropertyProperty, myValue);
            return needValue;
        }
        return baseValue;
    }

How do I make Binding respect DependencyProperty value coercion?

3 Answers3

Linked