从控件的代码更新XAML控件属性值但保持绑定

Question

I have written a control with a bindable property. This control also has a method to modify that property's value:

public class MyControl : ContentView // WPF: inherited from UserControl
{
  // Xamarin:
  public static readonly BindableProperty MyValueProperty = ...
  // WPF:
  // public static readonly DependencyProperty MyValueProperty = ...

  public int MyValue
  {
     get { return (int) GetValue(MyValueProperty); }
     set { SetValue(MyValueProperty, value); }
  }

  public void Reset()
  {
    MyValue = 0;
  }
}

I am using that control in a normal XAML page and update MyValue via binding:

<local:MyControl x:Name="TheControl"
                 MyValue="{Binding MyValueSource, Mode=OneWay}" />

The binding initially propagates changes from MyValueSource to MyValue . But as soon as I call the Reset() method once, the binding is overwritten by the 0 and updates to MyValueSource are no longer pulled.

I suppose any direct assignment of MyValue is intended to replace a OneWay binding. With a TwoWay binding, the change is just propagated back to MyValueSource and the binding remains functional.

If Reset() was in the view model, I could do this:

public void Reset()
{
  // TheControl.MyValue = 0; // Bad practice, destroys the binding
  MyValueSource = 0; // Good practice, preserves the binding
}

I don't want to implement the reset logic (which is more complex than in this reduced example) in every VM though, so it's located in the view/control.

So I wonder - can you assign a bindable property's value from the control's code behind and still preserve a possible OneWay binding? I know this means the VM does not get the changed value; binding OneWay is likely not correct if the control updates the property as well; you should rather use a TwoWay binding then.

But if someone says OneWay in XAML, I'd rather have it behave that way down to the wire than implement some " OneWay until you call Reset() " behavior.

Side note: I am working in Xamarin, but I guess the behavior is the same for WPF.

Answer 1

Taken and fleshed out from @Clemens' comment :

WPF

You can use the SetCurrentValue method on an DependencyObject (ie the control) to change the current effective value of a DependencyProperty . Unlike SetValue , with SetCurrentValue any triggers, data bindings and styles to that property remain intact.

public void Reset()
{
  // this.SetValue(MyValueProperty, 0); // Replaces the binding
  this.SetCurrentValue(MyValueProperty, 0); // Keeps the binding
}

Remember that if you defined a OneWay binding, the view model will not be notified about the changed value, and that any change to the VM's MyValueSource property will override the control's value again (if the property is implemented correctly).

---

Xamarin

There is currently no proper way to assign a BindableProperty 's value without replacing a OneWay binding attached to it. BindableObject (the control's base class) does not have any method comparable to WPF's SetCurrentValue and SetValue will allways replace the binding.

However, if you change the binding to BindingMode.TwoWay , the internal value change is propagated back to the view model. You should probably do this anyway to keep the control and the VM synchronized.

public void Reset()
{
  // Replaces any OneWay bindings
  // Updates MyValueSource for TwoWay bindings
  this.SetValue(MyValueProperty, 0);
}

Answer 2

Here is the Hacky WPF equivalent for Xamarin, for OneWay binding:

public static class BindingObjectExtensions
{
public static Binding GetBinding(this BindableObject self, BindableProperty property)
        {
            if (self == null)
            {
                throw new ArgumentNullException(nameof(self));
            }
            if (property == null)
            {
                throw new ArgumentNullException(nameof(property));
            }
            var methodInfo = typeof(BindableObject).GetTypeInfo().GetDeclaredMethod("GetContext");
            var context = methodInfo?.Invoke(self, new object[] { property });

            var propertyInfo = context?.GetType().GetTypeInfo().GetDeclaredField("Binding");
            return propertyInfo?.GetValue(context) as Binding;
        }

public static void SetCurrentValue(this BindableObject self, BindableProperty property, object value)
        {
            if (self == null)
            {
                throw new ArgumentNullException(nameof(self));
            }
            if (property == null)
            {
                throw new ArgumentNullException(nameof(property));
            }
            var backupBinding = self.GetBinding(property);//backup binding
            var backupConverter = backupBinding.Converter;//backup orig. converter
            self.SetValue(property,value);//removes the binding.
            backupBinding.Converter = new DefaultValueConverter {DefaultValue = value};//change the converter
            self.SetBinding(property, backupBinding);//target should be updated to the default value
            var converterField = backupBinding.GetType().GetTypeInfo().GetDeclaredField("_converter");
            converterField.SetValue(backupBinding, backupConverter);//restore the converter
        }
}

//the default value converter class

[ContentProperty(nameof(DefaultValue))]
    public class DefaultValueConverter : BindableObject, IValueConverter, IMarkupExtension<DefaultValueConverter>
    {
        public object DefaultValue
        {
            get => GetValue(DefaultValueProperty);
            set => SetValue(DefaultValueProperty, value);
        }

        public static readonly BindableProperty DefaultValueProperty =
            BindableProperty.Create(nameof(DefaultValue), typeof(object), typeof(DefaultValueConverter));

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return DefaultValue;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return DefaultValue;
        }


        public DefaultValueConverter ProvideValue(IServiceProvider serviceProvider)
        {
            return this;
        }

        object IMarkupExtension.ProvideValue(IServiceProvider serviceProvider)
        {
            return ((IMarkupExtension<DefaultValueConverter>) this).ProvideValue(serviceProvider);
        }
    }