La Force de liaison de mise à jour lorsque la Commande est déclenchée

est-il un moyen de mettre à jour une liaison avant ou lorsqu'une commande est déclenchée? J'ai quelques champs de texte, je peux le modifier et l'enregistrer à l'aide d'une commande, accessible via un raccourci clavier. La liaison est généralement mis à jour uniquement lorsque le champ de texte perd le focus, la dernière modification n'est pas conservée lorsque vous appuyez sur la touche pour enregistrer les données. Au lieu de cela, j'ai à onglet en dehors du champ de texte d'abord à faire la mise à jour et de l'enregistrer.

Est-il un moyen de forcer la mise à jour de façon élégante? Je suis en utilisant MVVM (mais pas n'importe quel framework MVVM), donc j'aimerais garder l'INTERFACE utilisateur spécifique choses sur le code de commande. Aussi je ne veux pas vraiment changer la liaison de mise à jour à chaque changement, c'est bien de l'avoir mise à jour uniquement lorsque le focus est perdu.

OriginalL'auteur poke | 2012-06-18

9

Plutôt que de changer de centre d'intérêt, vous pourriez tout aussi bien la mise à jour de la source de liaison si l'élément courant est un TextBox. Vous pourriez faire quelque chose de similaire pour les autres contrôles, mais dans mon expérience, je n'ai eu ce problème avec TextBox.
```
//if the current focused element is textbox then updates the source.
var focusedElement = Keyboard.FocusedElement as FrameworkElement;

if (focusedElement is TextBox)
{
    var expression = focusedElement.GetBindingExpression(TextBox.TextProperty);
    if (expression != null) expression.UpdateSource();
}
```
Bonne idée, où placeriez-vous que, bien que dans une MVVM l'installation? — Aussi ne savais pas qu'il y a réellement un UpdateSource méthode sur l'expression de liaison, merci pour ça!
Je pense que vous devriez mettre dans votre attaché de propriété - juste pensé que c'est une amélioration sur l'avancement de l'accent. Vous pouvez également regarder à l'aide de quelque chose comme CompositeCommand à partir de la Bibliothèque d'Entreprise pour gérer cette fonctionnalité, mais cela dépend vraiment de la façon dont votre application est structurée.

OriginalL'auteur Kai G
4

Sur votre TextBox, vous devez définir la UpdateSourceTrigger sur votre texte contraignant qui définit quand la source sera mis à jour avec la zone de texte valeur. Par défaut, il LostFocus pour la Text de la propriété, ce qui est exactement ce qui se produit - il uniquement les mises à jour de la source quand il perd le focus. Vous devez définir la valeur de UpdateSourceTrigger à PropertyChanged et il se mettra à jour à chaque fois la zone de texte valeur de changements.

par exemple
```
<TextBox ... Text="{Binding Foo, UpdateSourceTrigger=PropertyChanged}"/>
```
Chemin est la propriété par défaut lors de l'utilisation de la Liaison de commande, de sorte que le ci-dessus est égale à Path=Foo

À partir de la question: “Aussi, je ne veux pas vraiment changer la liaison de mise à jour à chaque changement”.

OriginalL'auteur user3791372
2

Ici, c'est la classe que j'ai utilisé pour une situation similaire:
```
public class TextBoxUpdatesTextBindingOnPropertyChanged : Behavior<TextBox>
{
    protected override void OnAttached()
    {
        base.OnAttached();

        AssociatedObject.TextChanged += TextBox_TextChanged;
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();

        AssociatedObject.TextChanged -= TextBox_TextChanged;
    }

    void TextBox_TextChanged(object sender, TextChangedEventArgs e)
    {
        var bindingExpression = AssociatedObject.GetBindingExpression(TextBox.TextProperty);
        bindingExpression.UpdateSource();
    }
}
```
XAML:
```
<TextBox Text="{Binding UserName,Mode=TwoWay,UpdateSourceTrigger=Explicit}">
    <i:Interaction.Behaviors>
        <h:TextBoxUpdatesTextBindingOnPropertyChanged />
    </i:Interaction.Behaviors>
</TextBox>
```
Appel OnPropertyChanged("YourPropertyName") alerte la vue de mettre à jour la valeur liée.

Sinon, découvrez cette réponse: WPF zone de texte DataBind sur EnterKey de presse.

Le problème, c'est la pas la liaison de données→vue, c'est l'inverse. Je veux forcer une mise à jour sur le côté données.
Ok, le lien que j'ai posté montre comment créer un comportement qui va mettre à jour la liaison (sur le côté données) lorsqu'un certain événement se jette sur le Contrôle. Si vous fil jusqu'à la KeyPressed ou KeyUp d'événements, vous devez obtenir l'effet que vous avez besoin.
Cette solution inclut la définition de la UpdateSourceTrigger à PropertyChanged qui devrait déjà être suffisant, mais est, comme dit dans la question, pas ce que je veux. Je suis à la recherche d'un moyen de le faire sans changer la gâchette.
J'ai ajouté une classe que j'utilise pour ma réponse originale à cette question.
+1, j'ai utiliser le code très similaire au joint de comportement que vous avez lié au bas de votre réponse. Il met à jour la source à chaque fois que la touche Entrée est pressée, et de mettre à jour la source à partir du code, il suffit de soulever la Propriété a Changé de cas, tels que OnPropertyChanged("PropertyName")

OriginalL'auteur Steve Konves
2

J'ai résolu cela en explicitement définir le focus à un autre élément avant de demander les valeurs. Cela rend évidemment l'élément qui a actuellement le focus de la perdre et de mise à jour de la liaison.

Pour définir le focus, j'ai écrit une propriété attachée, inspiré par les réponses aux autres questions. Aussi, en collaboration avec mon autre question j'ai fait un peu automatisé.

Afin de l'utiliser, je n'ai pas joindre ma propriété à un élément, dans ce cas, un contrôle onglet:
```
<TabControl c:Util.ShouldFocus="{Binding ShouldClearFocus}">
```
Dans mon modèle de vue, j'ai une simple propriété booléenne ShouldClearFocus qui est une propriété d'élever un PropertyChangedEvent, de sorte que la liaison de données fonctionne. Ensuite, j'ai simplement mis ShouldClearFocus à true quand je veux réinitialiser le focus. La propriété attachée définit automatiquement le focus et réinitialise la valeur de la propriété à nouveau. De cette façon, je peux continuer à mettre des ShouldClearFocus, sans avoir à mettre à false entre les deux.

La propriété attachée est une norme de mise en œuvre avec ce changement de gestionnaire:
```
public static void ShouldFocusChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
    if (!(bool)e.NewValue || !(obj is FrameworkElement))
        return;

    FrameworkElement element = (FrameworkElement)obj;
    if (element.Focusable)
        element.Focus();

    //reset value
    BindingExpression bindingExpression = BindingOperations.GetBindingExpression(obj, ShouldFocusProperty);
    if (bindingExpression != null)
    {
        PropertyInfo property = bindingExpression.DataItem.GetType().GetProperty(bindingExpression.ParentBinding.Path.Path);
        if (property != null)
            property.SetValue(bindingExpression.DataItem, false, null);
    }
    else
        SetShouldFocus(obj, false);
}
```
OriginalL'auteur poke

j'utilise la suite de mes projets. le problème est que le bouton ne pas recevoir le focus.

dans mon application.xaml.cs

    EventManager.RegisterClassHandler(typeof(Button), ButtonBase.ClickEvent, new RoutedEventHandler(ButtonClick));

    private void ButtonClick(object sender, RoutedEventArgs e)
    {
        if (sender != null && sender is Button)
        {
            (sender as Button).Focus();
        }
    }

Cette solution aurait l'air acceptable, mais je n'ai pas de bouton est cliqué. La commande est invoquée par un KeyBinding.

OriginalL'auteur blindmeis

0

Je pense que la meilleure façon de le faire est de définir la liaison du UpdateSourceTrigger=PropertyChanged, puis à l'aide de Reactive Extensions pour réguler le flux d'événements. De cette façon, la propriété n'est mis à jour après que l'utilisateur a cessé de taper pendant un certain laps de temps (1/2 seconde est une bonne quantité).

C'est bien parce que la propriété ne sera pas mise à jour tout le temps, mais il sera également mise à jour sans avoir besoin de se concentrer pour changer. Exactement ce que vous voulez.

Voici quelques informations vraiment utiles sur le Rx

Il y a un MVVM de la bibliothèque d'extensions qui a bindable IObservables ici. L'exemple qu'ils ont ici est exactement ce que j'ai suggéré.

Vous avez demandé pour l'élégance: c'est ici. Et ce n'est pas que beaucoup de travail.

OriginalL'auteur Jason Ridge

Vous devez vous connecter pour publier un commentaire.