Comment puis-je faire respecter la contrainte de liaison valeur DependencyProperty?
-
21-08-2019 - |
Question
J'ai un contrôle avec un DependencyProperty avec un CoerceValueCallback. Cette propriété est liée à une propriété sur un objet modèle.
Lors de la mise la propriété de contrôle à une valeur qui provoque la contrainte de la liaison pousse le sans contrainte valeur à l'objet modèle. La valeur de la propriété sur le contrôle est correctement sous la contrainte.
Comment puis-je obtenir la liaison à pousser la sous la contrainte valeur à l'objet modèle?
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;
}
}
}
La solution
Je ne pense pas que le rappel coerce est censé être une rue à deux voies. Une solution serait de mettre à jour la valeur du modèle à l'intérieur de la fonction de rappel coerce.
Autres conseils
Je pense que c'est l'idée de la contrainte - valeur correcte à la volée sans déclencher la modification de toutes les autres dépendances. Vous pouvez utiliser le code ci-dessous au lieu de mécanismes de coercition indigènes:
OnPChanged(/* ... */)
{
// ...
var coercedP = CoerceP(P);
if (P != coercedP)
P = coercedP;
// ...
}
HTH.
Voici la méthode d'extension où vous définissez la valeur sur l'objet cible
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);
}
}
}
Ainsi, dans cette méthode, en utilisant la liaison, vous pouvez définir la valeur à la source. De source cource chemin peut avoir beaucoup de noms - Property1.Property2.Property3 et etc. Dans la méthode coerce vous suffit d'appeler cette méthode:
private static object CoerceProperty(DependencyObject d, object baseValue)
{
if (!Check)
{
var sender = (FrameworkElement)d;
sender.SetTargetValue(MyPropertyProperty, myValue);
return needValue;
}
return baseValue;
}