Context menu remains visible during command execution - wpf

Question

I have a long running command that is started via a context menu. The context menu remains open till the command execution ends. I find this awkward. Tow questions:
Is that the way Windows programs should behave?
Is there a way to close the menu before the command is executed?
The application is MVVM and I would not like to program against the UI directly. Below is a simple code showing the behavior.
Please note: In the real application a wait cursor is displayed during command execution. Also, I do not want to run the command execution in a background thread but rather have the user wait till the command is finished.
XAML:
Window x:Class="WpfApp4__Various_Tests_.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:WpfApp4__Various_Tests_"
Title="MainWindow" Height="300" Width="300"
x:Name="root">
<Grid>
<Rectangle
Fill="ForestGreen"
Height="100" Width="200" Margin="10"
VerticalAlignment="Top"
>
<Rectangle.ContextMenu>
<ContextMenu>
<MenuItem
Header="Long running ommand"
Click="MenuItem_Click"
/>
</ContextMenu>
</Rectangle.ContextMenu>
</Rectangle>
</Grid>
Code:
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
DataContext = this;
}
private void MenuItem_Click(object sender, RoutedEventArgs e)
{
Thread.Sleep(3000);
}
}

Answer 1

The menu can't be closed because you block the UI thread with the handler. To fix the example you show here, use this:
private async void MenuItem_Click(object sender, RoutedEventArgs e)
{
await Task.Delay(TimeSpan.FromSeconds(3000));
}
In your actual program, you may or may not be calling code that is inherently async. If it is, you can do the same as above and await the result. If not, you should wrap the code in an async-friendly task. At the bare minimum, that would look something like this:
private async void MenuItem_Click(object sender, RoutedEventArgs e)
{
await Task.Run(() => Thread.Sleep(3000));
}
And I do mean bare minimum. Without knowing more about your long-running task, it's impossible to give anything more specific in the way of advice. However, a couple of important points:
The long-running task may require periodic interaction with objects owned by the UI thread. If you are strictly using data binding, WPF will automatically handle cross-thread notifications that occur via INotifyPropertyChanged. Notifications from INotifyCollectionChanged (e.g. ObserveableCollection<T>) aren't handled by default, but you can enabled that with BindingOperations.EnableCollectionSynchronization.
It is also very helpful if you can recompose your long-running task as sequences of awaitable, non-UI-interacting operations interleaved with the UI-interacting stuff. Then you can just use async/await to manage the cross-thread aspects. This approach is particularly important if you aren't using data binding (but if you aren't, you should be!).