Added DialogHost.DialogClosed event (#2767)

* Added DialogHost.DialogClosed event

Works the same way as DialogClosing, except it cannot be cancelled, and it is only fired once IsOpen changes to False.

* Removed possibly ambiguous ShowDialog()/Show() overloads

* Fixed failing unit test

nulls allowed for local test run, but fails in CI chain.

Author: nicolaihenriksen

MainDemo.Wpf/Dialogs.xaml

@@ -64,6 +64,7 @@
                 Grid.Row="1">
                 <materialDesign:DialogHost
                     DialogClosing="Sample1_DialogHost_OnDialogClosing"
+                    DialogClosed="Sample1_DialogHost_OnDialogClosed"
                     DialogTheme="Inherit">
                     <materialDesign:DialogHost.DialogContent>
                         <StackPanel Margin="16">
@@ -160,6 +161,7 @@
                     <Button
                         Command="{x:Static materialDesign:DialogHost.OpenDialogCommand}"
                         materialDesign:DialogHost.DialogClosingAttached="Sample2_DialogHost_OnDialogClosing"
+                        materialDesign:DialogHost.DialogClosedAttached="Sample2_DialogHost_OnDialogClosed"
                         Width="128"
                         Content="PASS VIEW">
                         <Button.CommandParameter>
@@ -283,6 +285,7 @@
                 Margin="8 8 0 0">
                 <materialDesign:DialogHost
                     DialogClosing="Sample5_DialogHost_OnDialogClosing"
+                    DialogClosed="Sample5_DialogHost_OnDialogClosed"
                     Style="{StaticResource MaterialDesignEmbeddedDialogHost}"
                     DialogMargin="8">
                     <materialDesign:DialogHost.DialogContent>

MainDemo.Wpf/Dialogs.xaml.cs

@@ -26,10 +26,27 @@ private void Sample1_DialogHost_OnDialogClosing(object sender, DialogClosingEven
                 FruitListBox.Items.Add(FruitTextBox.Text.Trim());
         }
 
+        private void Sample1_DialogHost_OnDialogClosed(object sender, DialogClosedEventArgs eventArgs)
+        {
+            Debug.WriteLine($"SAMPLE 1: Closed dialog with parameter: {eventArgs.Parameter ?? string.Empty}");
+
+            //you can cancel the dialog close:
+            //eventArgs.Cancel();
+
+            if (!Equals(eventArgs.Parameter, true))
+                return;
+
+            if (!string.IsNullOrWhiteSpace(FruitTextBox.Text))
+                FruitListBox.Items.Add(FruitTextBox.Text.Trim());
+        }
+
         // Used for DialogHost.DialogClosingAttached
         private void Sample2_DialogHost_OnDialogClosing(object sender, DialogClosingEventArgs eventArgs)
             => Debug.WriteLine($"SAMPLE 2: Closing dialog with parameter: {eventArgs.Parameter ?? string.Empty}");
 
+        private void Sample2_DialogHost_OnDialogClosed(object sender, DialogClosedEventArgs eventArgs)
+            => Debug.WriteLine($"SAMPLE 2: Closed dialog with parameter: {eventArgs.Parameter ?? string.Empty}");
+
         private void Sample5_DialogHost_OnDialogClosing(object sender, DialogClosingEventArgs eventArgs)
         {
             Debug.WriteLine($"SAMPLE 5: Closing dialog with parameter: {eventArgs.Parameter ?? string.Empty}");
@@ -43,5 +60,16 @@ private void Sample5_DialogHost_OnDialogClosing(object sender, DialogClosingEven
             if (!string.IsNullOrWhiteSpace(AnimalTextBox.Text))
                 AnimalListBox.Items.Add(AnimalTextBox.Text.Trim());
         }
+
+        private void Sample5_DialogHost_OnDialogClosed(object sender, DialogClosedEventArgs eventArgs)
+        {
+            Debug.WriteLine($"SAMPLE 5: Closed dialog with parameter: {eventArgs.Parameter ?? string.Empty}");
+
+            if (!Equals(eventArgs.Parameter, true))
+                return;
+
+            if (!string.IsNullOrWhiteSpace(AnimalTextBox.Text))
+                AnimalListBox.Items.Add(AnimalTextBox.Text.Trim());
+        }
     }
 }

MainDemo.Wpf/Domain/DialogsViewModel.cs

@@ -31,7 +31,7 @@ private async void ExecuteRunDialog(object? _)
             };
 
             //show the dialog
-            var result = await DialogHost.Show(view, "RootDialog", ClosingEventHandler);
+            var result = await DialogHost.Show(view, "RootDialog", null, ClosingEventHandler, ClosedEventHandler);
 
             //check the result...
             Debug.WriteLine("Dialog was closed, the CommandParameter used to close it was: " + (result ?? "NULL"));
@@ -40,6 +40,9 @@ private async void ExecuteRunDialog(object? _)
         private void ClosingEventHandler(object sender, DialogClosingEventArgs eventArgs)
             => Debug.WriteLine("You can intercept the closing event, and cancel here.");
 
+        private void ClosedEventHandler(object sender, DialogClosedEventArgs eventArgs)
+            => Debug.WriteLine("You can intercept the closed event here (1).");
+
         private async void ExecuteRunExtendedDialog(object? _)
         {
             //let's set up a little MVVM, cos that's what the cool kids are doing:
@@ -49,17 +52,18 @@ private async void ExecuteRunExtendedDialog(object? _)
             };
 
             //show the dialog
-            var result = await DialogHost.Show(view, "RootDialog", ExtendedOpenedEventHandler, ExtendedClosingEventHandler);
+            var result = await DialogHost.Show(view, "RootDialog", ExtendedOpenedEventHandler, ExtendedClosingEventHandler, ExtendedClosedEventHandler);
 
             //check the result...
             Debug.WriteLine("Dialog was closed, the CommandParameter used to close it was: " + (result ?? "NULL"));
         }
 
-        private void ExtendedOpenedEventHandler(object sender, DialogOpenedEventArgs eventargs)
+        private void ExtendedOpenedEventHandler(object sender, DialogOpenedEventArgs eventArgs)
             => Debug.WriteLine("You could intercept the open and affect the dialog using eventArgs.Session.");
 
         private void ExtendedClosingEventHandler(object sender, DialogClosingEventArgs eventArgs)
         {
+            Debug.WriteLine("You can intercept the closing event, cancel it, and do our own close after a little while.");
             if (eventArgs.Parameter is bool parameter &&
                 parameter == false) return;
 
@@ -76,6 +80,9 @@ private void ExtendedClosingEventHandler(object sender, DialogClosingEventArgs e
                     TaskScheduler.FromCurrentSynchronizationContext());
         }
 
+        private void ExtendedClosedEventHandler(object sender, DialogClosedEventArgs eventArgs)
+            => Debug.WriteLine("You could intercept the closed event here (2).");
+
         #endregion
 
         #region SAMPLE 4

MaterialDesignThemes.Wpf.Tests/DialogHostTests.cs

@@ -1,9 +1,4 @@
-using System;
-using System.ComponentModel;
-using System.Threading.Tasks;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Input;
+using System.ComponentModel;
 using Xunit;
 
 namespace MaterialDesignThemes.Wpf.Tests
@@ -189,6 +184,34 @@ void ClosingHandler(object s, DialogClosingEventArgs e)
             Assert.Equal(2, closeInvokeCount);
         }
 
+        [StaFact]
+        public async Task WhenCancellingClosingEventClosedEventHandlerIsNotInvoked()
+        {
+            int closingInvokeCount = 0;
+            void ClosingHandler(object s, DialogClosingEventArgs e)
+            {
+                closingInvokeCount++;
+                if (closingInvokeCount == 1)
+                {
+                    e.Cancel();
+                }
+            }
+            int closedInvokeCount = 0;
+            void ClosedHandler(object s, DialogClosedEventArgs e)
+            {
+                closedInvokeCount++;
+            }
+
+            var dialogTask = DialogHost.Show("Content", null, ClosingHandler, ClosedHandler);
+            _dialogHost.CurrentSession?.Close("FirstResult");
+            _dialogHost.CurrentSession?.Close("SecondResult");
+            object? result = await dialogTask;
+
+            Assert.Equal("SecondResult", result);
+            Assert.Equal(2, closingInvokeCount);
+            Assert.Equal(1, closedInvokeCount);
+        }
+
         [StaFact]
         [Description("Issue 1328")]
         public async Task WhenDoubleClickAwayDialogCloses()
@@ -256,6 +279,21 @@ public async Task WhenClosingDialogReturnValueCanBeSpecifiedInClosingEventHandle
             Assert.Equal(closeParameter, await showTask);
         }
 
+        [StaFact]
+        public async Task WhenClosingDialogReturnValueCanBeSpecifiedInClosedEventHandler()
+        {
+            Guid closeParameter = Guid.NewGuid();
+
+            Task<object?> showTask = _dialogHost.ShowDialog("Content", (sender, args) => { }, (sender, args) => { }, (object sender, DialogClosedEventArgs args) =>
+            {
+                args.Session.CloseParameter = closeParameter;
+            });
+
+            DialogHost.CloseDialogCommand.Execute(null, _dialogHost);
+
+            Assert.Equal(closeParameter, await showTask);
+        }
+
         [StaFact]
         [Description("Pull Request 2029")]
         public void WhenClosingDialogItThrowsWhenNoInstancesLoaded()
@@ -306,17 +344,25 @@ public void WhenClosingDialogWithParameterItPassesParameterToHandlers()
         {
             object parameter = Guid.NewGuid();
             object? closingParameter = null;
+            object? closedParameter = null;
             _dialogHost.DialogClosing += DialogClosing;
+            _dialogHost.DialogClosed += DialogClosed;
             _dialogHost.IsOpen = true;
 
             DialogHost.Close(null, parameter);
 
             Assert.Equal(parameter, closingParameter);
+            Assert.Equal(parameter, closedParameter);
 
             void DialogClosing(object sender, DialogClosingEventArgs eventArgs)
             {
                 closingParameter = eventArgs.Parameter;
             }
+
+            void DialogClosed(object sender, DialogClosedEventArgs eventArgs)
+            {
+                closedParameter = eventArgs.Parameter;
+            }
         }
 
         [StaFact]

MaterialDesignThemes.Wpf/DialogClosedEventArgs.cs

@@ -0,0 +1,18 @@
+namespace MaterialDesignThemes.Wpf;
+
+public class DialogClosedEventArgs : RoutedEventArgs
+{
+    public DialogClosedEventArgs(DialogSession session, RoutedEvent routedEvent)
+        : base(routedEvent)
+        => Session = session ?? throw new ArgumentNullException(nameof(session));
+
+    /// <summary>
+    /// Gets the parameter originally provided to <see cref="DialogHost.CloseDialogCommand"/>/
+    /// </summary>
+    public object? Parameter => Session.CloseParameter;
+
+    /// <summary>
+    /// Allows interaction with the current dialog session.
+    /// </summary>
+    public DialogSession Session { get; }
+}

MaterialDesignThemes.Wpf/DialogClosedEventHandler.cs

@@ -0,0 +1,3 @@
+namespace MaterialDesignThemes.Wpf;
+
+public delegate void DialogClosedEventHandler(object sender, DialogClosedEventArgs eventArgs);