How can I temporarily disable DependencyProperty constraints when changing DataContext - wpf

Question

I've built a WPF UserControl which is a slider that permits selecting a range of values. It has four properties for the limits with the constraint
MinValue <= RangeMinValue <= RangeMaxValue <= MaxValue
On the basis of YAGNI I currently have MinValue forced to 0, and the other three use dependency properties with a PropertyChangedCallback to enforce the constraints:
public static readonly DependencyProperty MaxValueProperty = DependencyProperty.Register(nameof(MaxValue), typeof(int), typeof(RangeTrack),
new FrameworkPropertyMetadata(default(int), FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.AffectsMeasure, _EnforceConstraints));
public int MaxValue { get { return (int)GetValue(MaxValueProperty); } set { SetValue(MaxValueProperty, value); } }
public static readonly DependencyProperty RangeMinValueProperty = DependencyProperty.Register(nameof(RangeMinValue), typeof(int), typeof(RangeTrack),
new FrameworkPropertyMetadata(default(int), FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, _EnforceConstraints));
public int RangeMinValue { get { return (int)GetValue(RangeMinValueProperty); } set { SetValue(RangeMinValueProperty, value); } }
public static readonly DependencyProperty RangeMaxValueProperty = DependencyProperty.Register(nameof(RangeMaxValue), typeof(int), typeof(RangeTrack),
new FrameworkPropertyMetadata(default(int), FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, _EnforceConstraints));
public int RangeMaxValue { get { return (int)GetValue(RangeMaxValueProperty); } set { SetValue(RangeMaxValueProperty, value); } }
// Enforce the constraints MinValue <= RangeMinValue <= RangeMaxValue <= MaxValue
private static void _EnforceConstraints(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var track = (RangeTrack)d;
var newValue = (int)e.NewValue;
// We work on the basis that property changes will cascade, so if the constraints
// are violated we make one change which will cascade to tidy up the rest.
if (e.Property == MaxValueProperty)
{
// This should be the only test which doesn't involve adjacent values.
if (newValue < track.MinValue) { track.MaxValue = track.MinValue; return; }
if (newValue < track.RangeMaxValue) { track.RangeMaxValue = newValue; return; }
}
if (e.Property == RangeMaxValueProperty)
{
if (newValue > track.MaxValue) { track.RangeMaxValue = track.MaxValue; return; }
if (newValue < track.RangeMinValue) { track.RangeMinValue = newValue; return; }
}
if (e.Property == RangeMinValueProperty)
{
if (newValue < track.MinValue) { track.RangeMinValue = track.MinValue; return; }
if (newValue > track.RangeMaxValue) { track.RangeMaxValue = newValue; return; }
}
}
The control works perfectly in isolation, but there's a problem with "real life" usage:
<my:RangeSlider MaxValue="{Binding NumFoos}"
RangeMinValue="{Binding StartFoo}"
RangeMaxValue="{Binding EndFoo}" />
When the (inherited) DataContext changes, the bindings update, but not simultaneously. Result: the _EnforceConstraints callback will be called at a point where some of the values are obtained from binding against the old DataContext and some from the new DataContext, resulting in undesired changes.
Both DataContextProperty.OverrideMetadata and the FrameworkElement.DataContextChanged event fire before the bindings update, so in principle I could disable the constraints, but I'm not sure on what condition I could safely re-enable them.
Rejected attempts at a workaround
I'm willing to assume that the initial bound values of the DataContexts used will respect the constraints, and if a context is bound which doesn't then I don't mind the constraints changing its values to be consistent with itself. But even with those assumptions, I haven't found a satisfactory workaround.
I think the order of the properties in the XAML affects the order in which they're updated. But whatever order I put them in, there's a potential problem. If MaxValue updates first then the constraints can change RangeMaxValue on the old DataContext; if RangeMaxValue updates first then the constraints can clip it to the old context's MaxValue, changing the new DataContext.
I could remove the constraints entirely from the control and enforce them in the DataContext. This works, but in my opinion the logically correct place for the constraints is in the control.
I could remove the direct enforcement from the callback and instead apply the constraints in ArrangeOverride (since all of the DependencyProperties have FrameworkPropertyMetadataOptions.AffectsArrange). The control isn't rearranged until all of the properties have changed, so in principle this should work (although it means tracking some extra state to see whether the violation of RangeMinValue <= RangeMaxValue is because the min value was increased or the max value was decreased), but it feels very hacky.
Use CoerceValueCallbacks in conjunction with PropertyChangedCallbacks to trigger manual re-coercion.
private static void _MaxValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs evt)
{
// Cascade: MaxValue directly impacts on RangeMaxValue, which directly impacts on RangeMinValue, so they must be coerced in that order.
d.CoerceValue(RangeMaxValueProperty);
d.CoerceValue(RangeMinValueProperty);
}
private static object _CoerceMaxValue(DependencyObject d, object baseValue)
{
var track = (RangeTrack)d;
ValueType value = (ValueType)baseValue;
if (value < track.MinValue) value = track.MinValue;
return value;
}
private static void _RangeMaxValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs evt)
{
d.CoerceValue(RangeMinValueProperty);
}
private static object _CoerceRangeMaxValue(DependencyObject d, object baseValue)
{
var track = (RangeTrack)d;
ValueType value = (ValueType)baseValue;
// NB We might have track.RangeMinValue > track.MaxValue at certain points in the coercion cascade.
if (value < track.RangeMinValue) value = track.RangeMinValue;
if (value > track.MaxValue) value = track.MaxValue;
return value;
}
private static void _RangeMinValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs evt)
{
d.CoerceValue(RangeMaxValueProperty);
}
private static object _CoerceRangeMinValue(DependencyObject d, object baseValue)
{
var track = (RangeTrack)d;
ValueType value = (ValueType)baseValue;
if (value > track.RangeMaxValue) value = track.RangeMaxValue;
if (value < track.MinValue) value = track.MinValue;
return value;
}
The problem here is that if I try to "push" the thumb for RangeMaxValue by dragging the thumb for RangeMinValue, neither moves, but if I then move the RangeMaxValue thumb then the RangeMinValue jumps to catch up with it.
Is workaround 3 the best option going, or is there something I've missed?