防止双击双重触发命令

Question

假设您有一个可以触发命令的控件：

<Button Command="New"/>

如果用户双击命令，有没有办法防止命令被触发两次？

编辑：在这种情况下重要的是我在 WPF 中使用Commanding 模型。

似乎只要按下按钮，就会执行命令。除了禁用或隐藏按钮之外，我没有看到任何防止这种情况的方法。

Answer 1

任何包含需要大量处理时间的代码的事件处理程序都可能导致相关按钮的禁用延迟；无论在处理程序中的何处调用禁用代码行。

尝试下面的证明，您会发现禁用/启用与事件注册无关。按钮点击事件仍被注册并仍在处理中。

矛盾证明1

private int _count = 0;
    
private void btnStart_Click(object sender, EventArgs e)
{
    btnStart.Enabled = false;
    
    _count++;
    label1.Text = _count.ToString();

    while (_count < 10)
    {            
        btnStart_Click(sender, e);            
    }           

    btnStart.Enabled = true;
}

矛盾证明 2

private void form1_load(object sender, EventArgs e)
{
    btnTest.Enabled = false;
}

private void btnStart_Click(object sender, EventArgs e)
{
    btnTest.Enabled = false;
    btnTest_click(sender, e);
    btnTest_click(sender, e);
    btnTest_click(sender, e);
    btnTest.Enabled = true;
}

private int _count = 0;

private void btnTest_click(object sender, EventArgs e)
{
    _count++;
    label1.Text = _count.ToString();
}

Answer 2

简单而有效地阻止两次、三次和四次点击

<Button PreviewMouseDown="Button_PreviewMouseDown"/>

private void Button_PreviewMouseDown(object sender, MouseButtonEventArgs e)
{
    if (e.ClickCount >= 2)
    {
        e.Handled = true;
    }
}

Answer 3

我遇到了同样的问题，这对我有用：

<Button>
    <Button.InputBindings>
            <MouseBinding Gesture="LeftClick" Command="New" />
    </Button.InputBindings>
</Button>

Answer 4

假设 WPF Commanding 没有给您足够的控制权来处理单击处理程序，您是否可以在命令处理程序中放置一些代码，以记住命令的最后一次执行时间，如果在给定时间段内请求它则退出? （下面的代码示例）

这个想法是，如果是双击，你会在几毫秒内收到两次事件，所以忽略第二个事件。

类似于：（在命令内部）

// warning: I haven't tried compiling this, but it should be pretty close DateTime LastInvoked = DateTime.MinDate; Timespan InvokeDelay = Timespan.FromMilliseconds(100); { if(DateTime.Now - LastInvoked <= InvokeDelay) return; // do your work }

（注意：如果它只是一个普通的旧点击处理程序，我会说遵循以下建议： http://blogs.msdn.com/oldnewthing/archive/2009/04/29/9574643.aspx)

Answer 5

我们是这样解决的……使用异步我们找不到任何其他方法来有效阻止对调用此 Click 的按钮的额外点击：

private SemaphoreSlim _lockMoveButton = new SemaphoreSlim(1);
private async void btnMove_Click(object sender, RoutedEventArgs e)
{
    var button = sender as Button;
    if (_lockMoveButton.Wait(0) && button != null)
    {
        try
        {                    
            button.IsEnabled = false;
        }
        finally
        {
            _lockMoveButton.Release();
            button.IsEnabled = true;
        }
    }
}

Answer 6

您可以使用MVVMLightToolkit 中的EventToCommand 类来防止这种情况。

处理 Click 事件并将其通过 EventToCommand 从您的视图发送到您的视图模型（您可以使用 EventTrigger 来执行此操作）。
在您的视图中设置MustToggleIsEnabled="True" 并在您的视图模型中实现CanExecute() 方法。
将CanExecute() 设置为在命令开始执行时返回false，并在命令完成时返回true。

这将在处理命令期间禁用按钮。

Answer 7

您会认为它就像使用Command 并让CanExecute() 在命令运行时返回false 一样简单。你会错的。即使你明确提出CanExecuteChanged：

public class TestCommand : ICommand
{
    public void Execute(object parameter)
    {
        _CanExecute = false;
        OnCanExecuteChanged();
        Thread.Sleep(1000);
        Console.WriteLine("Executed TestCommand.");
        _CanExecute = true;
        OnCanExecuteChanged();
    }

    private bool _CanExecute = true;

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

    private void OnCanExecuteChanged()
    {
        EventHandler h = CanExecuteChanged;
        if (h != null)
        {
            h(this, EventArgs.Empty);
        }
    }

    public event EventHandler CanExecuteChanged;
}

我怀疑如果这个命令引用了窗口的Dispatcher，并且在调用OnCanExecuteChanged 时使用了Invoke，它会起作用。

我可以想出几种方法来解决这个问题。一个 JMarsch 的方法：只需跟踪何时调用 Execute，如果在最后几百毫秒内调用它，则无需执行任何操作即可退出。

更强大的方法可能是让Execute 方法启动BackgroundWorker 来进行实际处理，让CanExecute 返回(!BackgroundWorker.IsBusy)，并在任务完成时引发CanExecuteChanged。该按钮应在Execute() 返回后立即重新查询CanExecute()，它会立即执行此操作。

Answer 8

你可以设置一个标志

bool boolClicked = false;
button_OnClick
{
    if(!boolClicked)
    {
        boolClicked = true;
        //do something
        boolClicked = false;
    }
}

Answer 9

一个简单而优雅的解决方案是在双击场景中创建第二次单击时的行为禁用反应。这很容易使用：

  <Button Command="New">
          <i:Interaction.Behaviors>
            <behaviors:DisableDoubleClickBehavior />
          </i:Interaction.Behaviors>
  </Button>

行为（有关行为的更多信息 - https://www.jayway.com/2013/03/20/behaviors-in-wpf-introduction/）

using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Interactivity;

public class DisableDoubleClickBehavior : Behavior<Button>
{
    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.PreviewMouseDoubleClick += AssociatedObjectOnPreviewMouseDoubleClick;
    }

    private void AssociatedObjectOnPreviewMouseDoubleClick(object sender, MouseButtonEventArgs mouseButtonEventArgs)
    {
        mouseButtonEventArgs.Handled = true;
    }

    protected override void OnDetaching()
    {
        AssociatedObject.PreviewMouseDoubleClick -= AssociatedObjectOnPreviewMouseDoubleClick;
        base.OnDetaching();
    }
}

Answer 10

遇到了同样的问题，通过附加行为解决了。

namespace VLEva.Core.Controls
{
    /// <summary></summary>
    public static class ButtonBehavior
    {
        /// <summary></summary>
        public static readonly DependencyProperty IgnoreDoubleClickProperty = DependencyProperty.RegisterAttached("IgnoreDoubleClick",
                                                                                                                  typeof(bool),
                                                                                                                  typeof(ButtonBehavior),
                                                                                                                  new UIPropertyMetadata(false, OnIgnoreDoubleClickChanged));

        /// <summary></summary>
        public static bool GetIgnoreDoubleClick(Button p_btnButton)
        {
            return (bool)p_btnButton.GetValue(IgnoreDoubleClickProperty);
        }

        /// <summary></summary>
        public static void SetIgnoreDoubleClick(Button p_btnButton, bool value)
        {
            p_btnButton.SetValue(IgnoreDoubleClickProperty, value);
        }

        static void OnIgnoreDoubleClickChanged(DependencyObject p_doDependencyObject, DependencyPropertyChangedEventArgs e)
        {
            Button btnButton = p_doDependencyObject as Button;
            if (btnButton == null)
                return;

            if (e.NewValue is bool == false)
                return;

            if ((bool)e.NewValue)
                btnButton.PreviewMouseLeftButtonDown += new MouseButtonEventHandler(btnButton_PreviewMouseLeftButtonDown);
            else
                btnButton.PreviewMouseLeftButtonDown -= btnButton_PreviewMouseLeftButtonDown;
        }

        static void btnButton_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (e.ClickCount >= 2)
                e.Handled = true;
        }

    }
}

然后直接在 XAML 中通过声明样式将属性设置为 TRUE，这样它就可以立即影响所有按钮。 （不要忘记 XAML 命名空间声明）

<Style x:Key="styleBoutonPuff" TargetType="{x:Type Button}">
    <Setter Property="VLEvaControls:ButtonBehavior.IgnoreDoubleClick" Value="True" />
    <Setter Property="Cursor" Value="Hand" />
</Style>

Answer 11

我正在使用 Xamarin 和 MVVMCross，虽然不是 WPF，但我认为以下解决方案适用，我创建了一个特定于视图模型的解决方案（不处理特定于平台的 UI），我认为这非常方便，使用帮助器或视图模型的基类创建一个跟踪命令的列表，如下所示：

private readonly List<string> Commands = new List<string>();

        public bool IsCommandRunning(string command)
        {
            return Commands.Any(c => c == command);
        }

        public void StartCommand(string command)
        {
            if (!Commands.Any(c => c == command)) Commands.Add(command);
        }

        public void FinishCommand(string command)
        {
            if (Commands.Any(c => c == command))  Commands.Remove(command);
        }

        public void RemoveAllCommands()
        {
            Commands.Clear();
        }

像这样在动作中添加命令：

public IMvxCommand MyCommand
        {
            get
            {
                return new MvxCommand(async() =>
                {
                    var command = nameof(MyCommand);
                    if (IsCommandRunning(command)) return;

                    try
                    {
                        StartCommand(command);

                        await Task.Delay(3000);
                       //click the button several times while delay
                    }
                    finally
                    {
                        FinishCommand(command);
                    }
                });
            }
        }

try/finally 只是确保命令始终完成。

通过设置动作异步和延迟进行测试，第一次点击有效，第二次在条件下返回。

Answer 12

如果您的控件派生自 System.Windows.Forms.Control，则可以使用double click event。

如果它不是从 System.Windows.Forms.Control 派生的，则改为 wire up mousedown 并确认点击次数 == 2：

private void Button_MouseDown(object sender, MouseButtonEventArgs e)
{
    if (e.ClickCount == 2)
    {
       //Do stuff
    }
 }

Answer 13

将代码包装在 try-catch-finally 或 try-finally 块中。无论 try 中是否发生任何错误，都会始终调用 finally 语句。

示例

    private Cursor _CursorType;
    // Property to set and get the cursor type
    public Cursor CursorType
    {
      get {return _CursorType; }
      set
      {
        _CursorType = value;
        OnPropertyChanged("CursorType");
      }
    }


    private void ExecutedMethodOnButtonPress()
    {
       try
       {
         CursorType = Cursors.Wait;
         // Run all other code here
       }
       finally
       {
         CursorType = Cursors.Arrow;
       }
    }

注意：CursorType 是 UserControl 或 Window 绑定到的属性

<Window 
Cursor = {Binding Path=CursorType}>

Answer 14

这里唯一真正的解决方案是创建一个使用 ConcurrentQueue 命令的 CommandHandler 单例类。命令处理程序需要它自己的处理循环，该循环在第一次按下按钮后启动并在队列为空时结束，这需要在它自己的线程中运行。

然后每个点击处理程序将命令推送到该队列，然后该队列执行该命令。如果同一命令在队列中出现两次，您可以简单地忽略处理它（或执行其他操作）

我看到的这个问题中的其他所有内容都不起作用，因为他们使用非原子操作来检查按钮是否已连续快速按下两次。这可能会失败，因为您可以在设置布尔值/计时器/信号量之前获得双重入口。

Answer 15

我的按钮绑定到一个可以触发 Run() 的委托函数：

private const int BUTTON_EVENT_DELAY_MS = 1000; //1 second. Setting this time too quick may allow double and triple clicking if the user is quick.
private bool runIsRunning = false;

private void Run()
{
    try
    {
        if (runIsRunning) //Prevent Double and Triple Clicking etc. We just want to Run run once until its done!
        {
            return;
        }
        runIsRunning = true;

        EventAggregator.GetEvent<MyMsgEvent>().Publish("my string");

        Thread.Sleep(BUTTON_EVENT_DELAY_MS);  
        runIsRunning = false;
    }
    catch  //catch all to reset runIsRunning- this should never happen.
    {
        runIsRunning = false;
    }
}

Answer 16

这会检查验证是否通过，如果通过则禁用按钮。

private void checkButtonDoubleClick(Button button)
    {
        System.Text.StringBuilder sbValid = new System.Text.StringBuilder();
        sbValid.Append("if (typeof(Page_ClientValidate) == 'function') { ");
        sbValid.Append("if (Page_ClientValidate() == false) { return false; }} ");
        sbValid.Append("this.value = 'Please wait...';");
        sbValid.Append("this.disabled = true;");
        sbValid.Append(this.Page.ClientScript.GetPostBackEventReference(button, ""));
        sbValid.Append(";");
        button.Attributes.Add("onclick", sbValid.ToString());
    }