Given that you have a control that fires a command:
<Button Command="New"/>
Is there a way to prevent the command from being fired twice if the user double clicks on the command?
EDIT: What is significant in this case is that I am using the Commanding model in WPF.
It appears that whenever the button is pressed, the command is executed. I do not see any way of preventing this besides disabling or hiding the button.
It is possible that any event handler that contains code that requires a significant process time, can result in a delay to the disabling of the button at question; regardless to where the disabling line of code is called within the handler.
Try the proofs below and you will see that disable/enable has no correlation to the registration of events. The button click event is still registered and is still handled.
Proof by Contradiction 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;
}
Proof by Contradition 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();
}
Simple & Effective for blocking double, triple, and quadruple clicks
<Button PreviewMouseDown="Button_PreviewMouseDown"/>
private void Button_PreviewMouseDown(object sender, MouseButtonEventArgs e)
{
if (e.ClickCount >= 2)
{
e.Handled = true;
}
}
I had the same issue and this worked for me:
<Button>
<Button.InputBindings>
<MouseBinding Gesture="LeftClick" Command="New" />
</Button.InputBindings>
</Button>
We solved it like this... with async we couldn't find any other way to effectively block extra clicks on the button which invokes this 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;
}
}
}
Assuming that WPF Commanding doesn't give you enough control to mess with the click handler, could you put some code in the command handler that remembers the last time the command was executed and exits if it is requested within a given time period? (code example below)
The idea is that if it's a double-click, you'll receive the event twice within milliseconds, so ignore the second event.
Something like: (inside of the Command)
// 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
}
(note: if it were just a plain old click handler, I'd say follow this advice: http://blogs.msdn.com/oldnewthing/archive/2009/04/29/9574643.aspx )
You can use the EventToCommand class in the MVVMLightToolkit to prevent this.
Handle the Click event and send it through EventToCommand from your view to your viewmodel (you can use EventTrigger to do this).
Set MustToggleIsEnabled="True" in your view and implement a CanExecute() method in your viewmodel.
Set CanExecute() to return false when the command starts to execute and back to true when the command is done.
This will disable the button for the duration of processing the command.
You'd think that it would be as simple as using a Command and making CanExecute() return false while the command is running. You would be wrong. Even if you raise CanExecuteChanged explicitly:
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;
}
I suspect that if this command had a reference to the window's Dispatcher, and used Invoke when it called OnCanExecuteChanged, it would work.
I can think of a couple of ways to solve this problem. One's JMarsch's approach: simply track when Execute is called, and bail out without doing anything if it was called in the last few hundred milliseconds.
A more robust way might be to have the Execute method start a BackgroundWorker to do the actual processing, have CanExecute return (!BackgroundWorker.IsBusy), and raise CanExecuteChanged in when the task is complete. The button should requery CanExecute() as soon as Execute() returns, which it'll do instantly.
A simple and elegant solution is to create a Behavior disabling reaction on second click in double-click scenario. That's pretty easy to use:
<Button Command="New">
<i:Interaction.Behaviors>
<behaviors:DisableDoubleClickBehavior />
</i:Interaction.Behaviors>
</Button>
Behavior (more about behaviors - 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();
}
}
You could set a flag
bool boolClicked = false;
button_OnClick
{
if(!boolClicked)
{
boolClicked = true;
//do something
boolClicked = false;
}
}
Had the same problem, solved it by using attached behavior.
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;
}
}
}
and then just set the property to TRUE either directly in XAML by declaring a style so it can affects all your buttons at once. (don't forget the XAML namespace declaration)
<Style x:Key="styleBoutonPuff" TargetType="{x:Type Button}">
<Setter Property="VLEvaControls:ButtonBehavior.IgnoreDoubleClick" Value="True" />
<Setter Property="Cursor" Value="Hand" />
</Style>
I'm using Xamarin and MVVMCross, although is not WPF I think the following solution applies, I created a solution which is viewmodel specific (doesn't deal with platform specific UI) which I think is very handy, using a helper or base class for the viewmodel create a List that keeps track of the commands, something like this:
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();
}
Add the command in the action like this:
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);
}
});
}
}
The try/finally just ensures the command is always finished.
Tested it by setting the action async and doing a delay, first tap works second one returns in the condition.
Wrap the code in a try-catch-finally or try-finally block. The finally statement will always be called regardless of any error occurring in the try.
Example
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;
}
}
NOTE: the CursorType is a property that the UserControl or Window is bound to
<Window
Cursor = {Binding Path=CursorType}>
The only real solution here is to create a CommandHandler singleton class which uses a ConcurrentQueue of commands. The command handler would need it's own processing loop that is started after the first button press and ended when the queue is empty, this would need to run in it's own thread.
Each click handler then pushes the command to this queue which then executes the command. If the same command appears twice in the queue you can simply ignore processing it (or do something else)
Everything else in this question I have seen will not work as they use non atomic operations to check if the button has been pressed twice in quick succession. This can fail as you can get double entrance before the boolean/timer/semaphore has been set.
I have my button tied to a delegate function which can fire 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;
}
}
If your control derives from System.Windows.Forms.Control, you can use the double click event.
If it doesn't derive from System.Windows.Forms.Control, then wire up mousedown instead and confirm the click count == 2 :
private void Button_MouseDown(object sender, MouseButtonEventArgs e)
{
if (e.ClickCount == 2)
{
//Do stuff
}
}
This checks if validation has passed and if it does then disables the button.
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());
}
