Bind TextBox po naciśnięciu klawisza Enter

Domyślne wiązanie danych TextBoxjest włączone TwoWayi zatwierdza tekst do właściwości tylko wtedy, gdyTextBox utracił fokus.

Czy istnieje prosty sposób XAML na wykonanie powiązania danych po naciśnięciu Enterklawisza TextBox?. Wiem, że w kodzie znajdującym się za nim jest to dość łatwe, ale wyobraź sobie, że TextBoxjest to wewnątrz jakiegoś złożonego kodu DataTemplate.

Możesz stworzyć podejście oparte na czystym XAML, tworząc dołączone zachowanie .

Coś takiego:

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();
        }
    }
}

Następnie w XAML ustawiasz InputBindingsManager.UpdatePropertySourceWhenEnterPressedPropertywłaściwość na tę, którą chcesz zaktualizować po Enternaciśnięciu klawisza. Lubię to

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

(Musisz tylko upewnić się, że zawiera odwołanie do przestrzeni nazw clr xmlns dla „b” w elemencie głównym pliku XAML, wskazując na przestrzeń nazw, w której umieścisz InputBindingsManager).

W ten sposób rozwiązałem ten problem. Stworzyłem specjalny program obsługi zdarzeń, który wszedł do kodu za:

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(); }
    }
}

Następnie właśnie dodałem to jako program obsługi zdarzeń KeyUp w XAML:

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

Procedura obsługi zdarzeń używa swojego senderodwołania, aby spowodować zaktualizowanie własnego powiązania. Ponieważ program obsługi zdarzeń jest niezależny, powinien działać w złożonym DataTemplate. Ten jeden program obsługi zdarzeń można teraz dodać do wszystkich pól tekstowych, które wymagają tej funkcji.

Nie wierzę, że istnieje „czysty XAML” sposób na zrobienie tego, co opisujesz. Możesz skonfigurować powiązanie, aby było aktualizowane za każdym razem, gdy zmieni się tekst w TextBox (zamiast gdy TextBox utraci fokus), ustawiając właściwość UpdateSourceTrigger , na przykład:

<TextBox Name="itemNameTextBox"
    Text="{Binding Path=ItemName, UpdateSourceTrigger=PropertyChanged}" />

Jeśli ustawisz UpdateSourceTrigger na „Explicit”, a następnie obsłużysz zdarzenie PreviewKeyDown TextBox (szukając klawisza Enter), możesz osiągnąć to, co chcesz, ale wymagałoby to użycia kodu. Może jakiś załączonym własności (podobny do mojego EnterKeyTraversal mienia) pracy woudld dla Ciebie.

Możesz łatwo utworzyć własną kontrolkę dziedziczącą po TextBox i używać jej ponownie w całym projekcie.

Coś podobnego powinno działać:

public class SubmitTextBox : TextBox
{
    public SubmitTextBox()
        : base()
    {
        PreviewKeyDown += new KeyEventHandler(SubmitTextBox_PreviewKeyDown);
    }

    void SubmitTextBox_PreviewKeyDown(object sender, KeyEventArgs e)
    {
        if (e.Key == Key.Enter)
        {
            BindingExpression be = GetBindingExpression(TextBox.TextProperty);
            if (be != null)
            {
                be.UpdateSource();
            }
        }
    }
}

Może istnieć sposób na obejście tego kroku, ale w przeciwnym razie powinieneś połączyć się w ten sposób (używając jawnego):

<custom:SubmitTextBox
    Text="{Binding Path=BoundProperty, UpdateSourceTrigger=Explicit}" />

Jeśli połączysz rozwiązania Bena i ausadmin, otrzymasz rozwiązanie bardzo przyjazne dla MVVM:

<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>

... co oznacza, że ​​przekazujesz TextBoxsiebie jako parametr do Command.

Prowadzi to do tego, że Commandwyglądasz tak (jeśli używasz DelegateCommandimplementacji w stylu A w swojej maszynie wirtualnej):

    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();
        }
    }

Ta Commandimplementacja może być używana dla dowolnego, TextBoxa co najważniejsze, bez kodu w kodzie, chociaż możesz chcieć umieścić to w swojej własnej klasie, aby nie było żadnych zależności na System.Windows.ControlsTwojej maszynie wirtualnej. Zależy to od tego, jak surowe są wytyczne dotyczące kodu.

Oto podejście, które wydaje mi się dość proste i łatwiejsze niż dodanie AttachedBehaviour (które jest również prawidłowym rozwiązaniem). Używamy domyślnego UpdateSourceTrigger (LostFocus for TextBox), a następnie dodajemy InputBinding do klawisza Enter, powiązanego z poleceniem.

XAML wygląda następująco

       <TextBox Grid.Row="0" Text="{Binding Txt1}" Height="30" Width="150">
        <TextBox.InputBindings>
            <KeyBinding Gesture="Enter" 
                        Command="{Binding UpdateText1Command}"
                        CommandParameter="{Binding RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type TextBox}},Path=Text}" />
        </TextBox.InputBindings>
    </TextBox>

Następnie metody Command są

Private Function CanExecuteUpdateText1(ByVal param As Object) As Boolean
    Return True
End Function
Private Sub ExecuteUpdateText1(ByVal param As Object)

    If TypeOf param Is String Then
        Txt1 = CType(param, String)
    End If
End Sub

TextBox jest powiązany z Property

 Public Property Txt1 As String
    Get
        Return _txt1
    End Get
    Set(value As String)
        _txt1 = value
        OnPropertyChanged("Txt1")
    End Set
End Property

Jak dotąd wydaje się, że działa to dobrze i przechwytuje zdarzenie Enter Key w TextBox.

To nie jest odpowiedź na pierwotne pytanie, ale raczej rozszerzenie zaakceptowanej odpowiedzi @Samuel Jack. Zrobiłem co następuje we własnej aplikacji i byłem pod wrażeniem elegancji rozwiązania Samuela. Jest bardzo czysty i nadaje się do wielokrotnego użytku, ponieważ można go używać na dowolnym sterowaniu, nie tylkoTextBox . Pomyślałem, że należy się tym podzielić ze społecznością.

Jeśli masz okno z tysiącem, TextBoxesktóre wszystkie wymagają zaktualizowania źródła powiązania w Enter, możesz dołączyć to zachowanie do wszystkich, włączając poniższy kod XAML do swojego, Window Resourceszamiast dołączać go do każdego TextBox. Najpierw musisz oczywiście zaimplementować załączone zachowanie zgodnie z postem Samuela .

<Window.Resources>
    <Style TargetType="{x:Type TextBox}" BasedOn="{StaticResource {x:Type TextBox}}">
        <Style.Setters>
            <Setter Property="b:InputBindingsManager.UpdatePropertySourceWhenEnterPressed" Value="TextBox.Text"/>
        </Style.Setters>
    </Style>
</Window.Resources>

W razie potrzeby zawsze możesz ograniczyć zakres, umieszczając styl w zasobach jednego z elementów potomnych okna (tj. A Grid), który zawiera docelowe pola tekstowe.

Jeśli używasz MultiBinding z TextBox, musisz użyć BindingOperations.GetMultiBindingExpressionmetody zamiast 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();
     }
}

To działa dla mnie:

        <TextBox                 
            Text="{Binding Path=UserInput, UpdateSourceTrigger=PropertyChanged}">
            <TextBox.InputBindings>
                <KeyBinding Key="Return" 
                            Command="{Binding Ok}"/>
            </TextBox.InputBindings>
        </TextBox>

Odpowiedziałem tutaj dość elegancko, używając przywiązanych zachowań, mojej preferowanej metody na prawie wszystko.

WPF, jak sprawić, by pole tekstowe straciło fokus po naciśnięciu klawisza Enter

Osobiście uważam, że posiadanie rozszerzenia znaczników jest czystszym podejściem.

public class UpdatePropertySourceWhenEnterPressedExtension : MarkupExtension
{
    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return new DelegateCommand<TextBox>(textbox => textbox.GetBindingExpression(TextBox.TextProperty).UpdateSource());
    }
}

<TextBox x:Name="TextBox"
             Text="{Binding Text}">
        <TextBox.InputBindings>
            <KeyBinding Key="Enter"
                        Command="{markupExtensions:UpdatePropertySourceWhenEnterPressed}" 
                        CommandParameter="{Binding ElementName=TextBox}"/>
        </TextBox.InputBindings>
</TextBox>

Inne rozwiązanie (nie używam xaml, ale myślę, że nadal jest całkiem czysty).

class ReturnKeyTextBox : TextBox
{
    protected override void OnKeyUp(KeyEventArgs e)
    {
        base.OnKeyUp(e);
        if (e.Key == Key.Return)
            GetBindingExpression(TextProperty).UpdateSource();
    }
}