Lier la zone de texte sur la touche Entrée appuyez sur

Vous pouvez vous faire un pur XAML approche par la création d'un attaché comportement.

Quelque chose comme ceci:

public static class InputBindingsManager
{
public static readonly DependencyProperty UpdatePropertySourceWhenEnterPressedProperty = DependencyProperty.RegisterAttached(
"UpdatePropertySourceWhenEnterPressed", typeof(DependencyProperty), typeof(InputBindingsManager), new PropertyMetadata(null, OnUpdatePropertySourceWhenEnterPressedPropertyChanged));
static InputBindingsManager()
{
}
public static void SetUpdatePropertySourceWhenEnterPressed(DependencyObject dp, DependencyProperty value)
{
dp.SetValue(UpdatePropertySourceWhenEnterPressedProperty, value);
}
public static DependencyProperty GetUpdatePropertySourceWhenEnterPressed(DependencyObject dp)
{
return (DependencyProperty)dp.GetValue(UpdatePropertySourceWhenEnterPressedProperty);
}
private static void OnUpdatePropertySourceWhenEnterPressedPropertyChanged(DependencyObject dp, DependencyPropertyChangedEventArgs e)
{
UIElement element = dp as UIElement;
if (element == null)
{
return;
}
if (e.OldValue != null)
{
element.PreviewKeyDown -= HandlePreviewKeyDown;
}
if (e.NewValue != null)
{
element.PreviewKeyDown += new KeyEventHandler(HandlePreviewKeyDown);
}
}
static void HandlePreviewKeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter)
{
DoUpdateSource(e.Source);
}
}
static void DoUpdateSource(object source)
{
DependencyProperty property =
GetUpdatePropertySourceWhenEnterPressed(source as DependencyObject);
if (property == null)
{
return;
}
UIElement elt = source as UIElement;
if (elt == null)
{
return;
}
BindingExpression binding = BindingOperations.GetBindingExpression(elt, property);
if (binding != null)
{
binding.UpdateSource();
}
}
}

Puis dans votre XAML, vous définissez la InputBindingsManager.UpdatePropertySourceWhenEnterPressedProperty bien à celui que vous voulez lors de la mise à jour de l' Entrée touche est enfoncée. Comme ce

<TextBox Name="itemNameTextBox"
Text="{Binding Path=ItemName, UpdateSourceTrigger=PropertyChanged}"
b:InputBindingsManager.UpdatePropertySourceWhenEnterPressed="TextBox.Text"/>

(Vous avez juste besoin de assurez-vous d'inclure un xmlns clr-namespace de référence pour le "b" dans l'élément racine de votre fichier XAML de pointage pour qui jamais de noms, vous mettez le InputBindingsManager dans).

C'est comment j'ai résolu ce problème. J'ai créé un gestionnaire d'événements qui allaient dans le code behind:

private void TextBox_KeyEnterUpdate(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter)
{
TextBox tBox = (TextBox)sender;
DependencyProperty prop = TextBox.TextProperty;
BindingExpression binding = BindingOperations.GetBindingExpression(tBox, prop);
if (binding != null) { binding.UpdateSource(); }
}
}

Alors je viens d'ajouter ce que un événement KeyUp gestionnaire dans le code XAML:

<TextBox Text="{Binding TextValue1}" KeyUp="TextBox_KeyEnterUpdate" />
<TextBox Text="{Binding TextValue2}" KeyUp="TextBox_KeyEnterUpdate" />

Le gestionnaire d'événement utilise son sender de référence à cause de sa propre liaison de mise à jour. Depuis le gestionnaire d'événements est autonome alors, il faut travailler dans un complexe DataTemplate. Ce un gestionnaire d'événement peut maintenant être ajouté à toutes les zones de texte qui ont besoin de cette fonctionnalité.

Si vous combinez les deux et Ben ausadmin solutions, vous vous retrouvez avec un très MVVM solution à l'amiable:

<TextBox Text="{Binding Txt1, Mode=TwoWay, UpdateSourceTrigger=Explicit}">
<TextBox.InputBindings>
<KeyBinding Gesture="Enter" 
Command="{Binding UpdateTextBoxBindingOnEnterCommand}"
CommandParameter="{Binding RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type TextBox}}}" />
</TextBox.InputBindings>
</TextBox>

...ce qui signifie que vous êtes de passage le TextBox lui-même en tant que paramètre à la Command.

Cela conduit à votre Command qui ressemble à ceci (si vous utilisez un DelegateCommand-mise en œuvre de style dans votre VM):

    public bool CanExecuteUpdateTextBoxBindingOnEnterCommand(object parameter)
{
return true;
}
public void ExecuteUpdateTextBoxBindingOnEnterCommand(object parameter)
{
TextBox tBox = parameter as TextBox;
if (tBox != null)
{
DependencyProperty prop = TextBox.TextProperty;
BindingExpression binding = BindingOperations.GetBindingExpression(tBox, prop);
if (binding != null) 
binding.UpdateSource();
}
}

Ce Command mise en œuvre peut être utilisé pour tout TextBox et le meilleur de tous, pas de code dans le code-behind bien que vous voudrez peut-être mettre cela dans sa propre classe, donc il n'y a pas de dépendances sur System.Windows.Controls dans votre VM. Il dépend de la rigueur de votre code de lignes directrices.

De plus simple, il suffit de définir UpdateSourceTrigger à PropertyChanged dans votre TextBox's liaison sans rien ajouter dans le code-behind.
Juste comme ça:

<TextBox Text="{Binding Path=BoundProperty, UpdateSourceTrigger=PropertyChanged}"/>

Cela fonctionne pour moi.

Dans le cas où vous utilisez MultiBinding avec votre zone de texte, vous devez utiliser BindingOperations.GetMultiBindingExpression méthode au lieu de BindingOperations.GetBindingExpression.

//Get the correct binding expression based on type of binding
//(simple binding or multi binding.
BindingExpressionBase binding = 
BindingOperations.GetBindingExpression(element, prop);
if (binding == null)
{
binding = BindingOperations.GetMultiBindingExpression(element, prop);
}
if (binding != null)
{
object value = element.GetValue(prop);
if (string.IsNullOrEmpty(value.ToString()) == true)
{
binding.UpdateTarget();
}
else
{
binding.UpdateSource();
}
}

Répondu ici assez élégamment à l'aide de comportements attachés, ma méthode de prédilection pour presque rien.

WPF comment faire de la zone de texte perdre le focus après avoir appuyer sur la touche enter