2

在我的 WPF 窗口中，我放置了一个普通的文本框，我希望在按下 Ctrl+F 时将其聚焦。

因为我想尽可能地保持它类似于 MVVM，所以我InputBindings在窗口上使用将该输入事件绑定到 ViewModel 中提供的命令（这已经破坏了 MVVM 模式，因为整个操作只是为了成为视图？我猜不是，因为 Command 是要绑定的对象）。

ViewModel 如何与视图通信以聚焦文本框？我读到这已经打破了 MVVM 模式，但有时只是必要的，否则是不可能的。但是，将焦点设置在 ViewModel 本身将完全打破 MVVM 模式。

我最初打算将窗口中当前的焦点控件绑定到 ViewModel 的一个属性，但甚至很难确定 WPF 中当前的焦点元素（这总是让我怀疑这样做是否真的是正确的方法）。

4

5 回答 5

3

在这种情况下，没有办法不“破坏”纯 MVVM。再说一次，我几乎不会称之为破坏任何东西。我不认为任何大小合适的 MVVM 应用程序都是“纯粹的”。所以，不要太在意打破你使用的任何模式，而是实施一个解决方案。

这里至少有两种方法：

  • 只需在 View 后面的代码中执行所有操作：检查是否按下了键，如果是，则设置焦点。没有比这更简单的了，您可能会争辩说 VM 与真正与 View 相关的东西无关
  • 否则显然VM和View之间必须进行一些通信。这让一切变得更加复杂：假设您使用 InputBinding，您的命令可以设置一个布尔属性，然后视图可以依次绑定到它以设置焦点。这种绑定可以像 Sheridan's answer 中的附加属性一样完成。
于 2013-10-30T10:02:02.683 回答
1

通常，当我们想在遵守 MVVM 方法的同时使用任何 UI 事件时，我们会创建一个附加属性。正如我昨天刚刚回答了同样的问题一样，我建议您查看如何使用 mvvm 将焦点设置到 wpf 控件上，此处为 StackOverflow 上的完整工作代码示例。

该问题与您的问题的唯一区别是您希望将元素集中在按键上...我将假设您知道如何做那部分，但是如果您不能，请告诉我并我也会给你一个例子。

于 2013-10-30T09:58:32.840 回答
1

使用 mvvm 时以及进一步定义视图模型时：

视图模型不应该知道/引用视图

那么你不能通过视图模型设置焦点。

但我在 mvvm 中所做的是 viewmodel 中的以下内容：

将焦点设置到绑定到 viewmodel 属性的元素

为此，我创建了一个简单地遍历可视化树中的所有控件并查找绑定表达式路径的行为。如果我找到一个路径表达式，那么只需关注 uielement。

编辑：

xml 用法

<UserControl>
    <i:Interaction.Behaviors>
    <Behaviors:OnLoadedSetFocusToBindingBehavior BindingName="MyFirstPropertyIWantToFocus" SetFocusToBindingPath="{Binding Path=FocusToBindingPath, Mode=TwoWay}"/>
</i:Interaction.Behaviors>
</UserControl>

任何方法的视图模型

this.FocusToBindingPath = "MyPropertyIWantToFocus";

行为

public class SetFocusToBindingBehavior : Behavior<FrameworkElement>
{
    public static readonly DependencyProperty SetFocusToBindingPathProperty =
      DependencyProperty.Register("SetFocusToBindingPath", typeof(string), typeof(SetFocusToBindingBehavior ), new FrameworkPropertyMetadata(SetFocusToBindingPathPropertyChanged));

    public string SetFocusToBindingPath
    {
        get { return (string)GetValue(SetFocusToBindingPathProperty); }
        set { SetValue(SetFocusToBindingPathProperty, value); }
    }

    private static void SetFocusToBindingPathPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var behavior = d as SetFocusToBindingBehavior;
        var bindingpath = (e.NewValue as string) ?? string.Empty;

        if (behavior == null || string.IsNullOrWhiteSpace(bindingpath))
            return;

        behavior.SetFocusTo(behavior.AssociatedObject, bindingpath);
        //wenn alles vorbei ist dann binding path zurücksetzen auf string.empty, 
        //ansonsten springt PropertyChangedCallback nicht mehr an wenn wieder zum gleichen Propertyname der Focus gesetzt werden soll
        behavior.SetFocusToBindingPath = string.Empty;
    }

    private void SetFocusTo(DependencyObject obj, string bindingpath)
    {
        if (string.IsNullOrWhiteSpace(bindingpath)) 
            return;

        var ctrl = CheckForBinding(obj, bindingpath);

        if (ctrl == null || !(ctrl is IInputElement))
            return;

        var iie = (IInputElement) ctrl;

        ctrl.Dispatcher.BeginInvoke((Action)(() =>
            {
                if (!iie.Focus())
                {
                    //zb. bei IsEditable=true Comboboxen funzt .Focus() nicht, daher Keyboard.Focus probieren
                    Keyboard.Focus(iie);

                    if (!iie.IsKeyboardFocusWithin)
                    {
                        Debug.WriteLine("Focus konnte nicht auf Bindingpath: " + bindingpath + " gesetzt werden.");
                        var tNext = new TraversalRequest(FocusNavigationDirection.Next);
                        var uie = iie as UIElement;

                        if (uie != null)
                        {
                            uie.MoveFocus(tNext);
                        } 
                    }
                }
            }), DispatcherPriority.Background);
    }

    public string BindingName { get; set; }

    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.Loaded += AssociatedObjectLoaded;
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
        AssociatedObject.Loaded -= AssociatedObjectLoaded;
    }

    private void AssociatedObjectLoaded(object sender, RoutedEventArgs e)
    {
        SetFocusTo(AssociatedObject, this.BindingName);
    }

    private DependencyObject CheckForBinding(DependencyObject obj, string bindingpath)
    {
        var properties = TypeDescriptor.GetProperties(obj, new Attribute[] { new PropertyFilterAttribute(PropertyFilterOptions.All) });

        if (obj is IInputElement && ((IInputElement) obj).Focusable)
        {
            foreach (PropertyDescriptor property in properties)
            {
                var prop = DependencyPropertyDescriptor.FromProperty(property);

                if (prop == null) continue;

                var ex = BindingOperations.GetBindingExpression(obj, prop.DependencyProperty);
                if (ex == null) continue;

                if (ex.ParentBinding.Path.Path == bindingpath)
                    return obj;

            }
        }

        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
        {
            var result = CheckForBinding(VisualTreeHelper.GetChild(obj, i),bindingpath);
            if (result != null)
                return result;
        }

        return null;
    }
}
于 2013-10-30T10:22:31.197 回答
0

（这是否已经破坏了 MVVM 模式，因为整个操作只是视图的一部分？我猜不是，因为 Command 是要绑定的对象）

WPF 中的命令系统实际上不是围绕数据绑定设计的，而是 UI —— 使用 RoutedCommands，单个命令将根据调用命令的元素在 UI 结构中的物理位置具有不同的实现。

指挥概述

您的流程将是：

  • Ctrl+F 被按下
  • 命令事件被引发并冒泡
  • 事件到达窗口，该窗口具有对命令的 CommandBinding
  • 窗口上的事件处理程序聚焦文本框

如果当前元素位于想要以不同方式处理命令的容器内，它将在到达窗口之前停在那里。

这可能更接近您想要的。如果在blindmeis的回答中有一些“活动属性”的概念，那么涉及视图模型可能是有意义的，但否则我认为你最终会得到一个冗余/循环的信息流，例如按键 - >视图通知视图模型of keypress -> viewmodel 通过通知按键视图来响应。

于 2013-10-30T20:19:10.833 回答
0

经过几天更好地掌握所有这些，考虑和评估所有选项后，我终于找到了解决问题的方法。我在我的窗口标记中添加了一个命令绑定： 

<Window.InputBindings>
    <KeyBinding Command="{Binding Focus}" CommandParameter="{Binding ElementName=SearchBox}" Gesture="CTRL+F" />
</Window.InputBindings>

我的 ViewModel 中的命令（我将课程缩减到在这种情况下重要的内容）： 

class Overview : Base
{
    public Command.FocusUIElement Focus
    {
        get;
        private set;
    }

    public Overview( )
    {
        this.Focus = new Command.FocusUIElement();
    }
}

最后是命令本身： 

class FocusUIElement : ICommand
{
    public event EventHandler CanExecuteChanged;

    public bool CanExecute ( object parameter )
    {
        return true;
    }

    public void Execute ( object parameter )
    {
        System.Windows.UIElement UIElement = ( System.Windows.UIElement ) parameter;
        UIElement.Focus();
    }
}

这可能不是 straigt MVVM - 但 stijn 的回答有一个好点：

所以，不要太在意打破你使用的任何模式，而是实施一个解决方案。

通常情况下，我会注意按照惯例组织东西，尤其是当我对某事还是陌生的时候，但我认为这没有任何问题。

于 2013-11-11T09:00:29.063 回答