DialogManager idea

[aboehmCT]

I created some simple classes to show dialogs in my MVVM app. I wanted to run it by the community to see what yall thoughts were.

This is how I am handling opening and responding to sub windows, I call them dialog in our library.
I created a derived class from the ViewModelBase that is part of the avalonia template called DialogViewModel base.

public enum DialogResult { Ok, Cancel, Yes, No, None };

public abstract partial class DialogViewModelBase : ViewModelBase
{
    public event EventHandler? CloseRequested;

    public DialogResult Result { get; private set; } = DialogResult.None;

    [RelayCommand]
    private void CloseDialog()
    {
        CloseRequested?.Invoke(this, new EventArgs());
    }

    [RelayCommand]
    private void CloseDialogWithResult(DialogResult result)
    {
        Result = result;
        CloseRequested?.Invoke(this, new EventArgs());
    }
}

It has an event called CloseRequested as well as some RelayCommands to close the dialog with or without a result.

I then created a Window as a generic host for dialogs. It contains a single ContentControl bound to a DialogContent property. In order for this window to show the correct view you need a ViewLocator data template set up to provide views based on viewmodels. I am using the reflection based one from the examples.

<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
	xmlns:local="clr-namespace:DialogUtils"
        mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
	x:Class="DialogUtils.DialogHost"
        x:DataType="local:DialogHost">
  <Border BorderBrush="Black" BorderThickness="2" CornerRadius="2" Background="White">
	  <ContentControl Content="{Binding UserContent}"/>
  </Border>
</Window>

In the code behind of this Window I connect the click event to the CloseRequested? event of the DialogVeiwModelBase.

    public partial class DialogHost : Window
    {
        public DialogViewModelBase UserContent { get; }

        public DialogHost(DialogViewModelBase dialogViewModel)
        {
            UserContent = dialogViewModel;

            InitializeComponent();
            DataContext = this;

            DialogContentCloseRequested += DialogViewModel_CloseRequested;
        }

        private void DialogViewModel_CloseRequested(object? sender, System.EventArgs e)
        {
            DialogContent.CloseRequested -= DialogViewModel_CloseRequested;
            Close();
        }
    }

To manage opening the dialogs from the parent view model I have a DialogManager class. I just made it a property of the my App but you could use a service if you wanted to go more MVVM.

    public class DialogManager
    {
        private Window Window { get; init; }

        public DialogManager(Window window)
        {
            Window = window;
        }

        public async Task ShowDialog<T>(T dialogViewModel) where T : DialogViewModelBase
        { 
            var dialogHost = new DialogHost(dialogViewModel);
            await dialogHost.ShowDialog(Window);
        }
    }

So all together the way this works is, a command in a parent viewmodel will use the DialogManager to open a dialog with the supplied DialogViewModelBase. Then that dialog binds to one of the provided Close RelayCommands. The DialogHost window (or flyout base) that is showing the dialog then responds to the event and closes the window when requested. The parent viewmodel can then check the response of the dialog's result property.

Here's an example of using it in a parent viewmodel to open a window to select a file to open.

        [RelayCommand]
        private async Task OpenDocument()
        {
            var docLibraryVM = new DocumentLibraryViewModel();
            await App.Current.DialogManager.ShowDialog(docLibraryVM);
            if (docLibraryVM.Result == DialogResult.Ok && docLibraryVM.SelectedDoc != null)
            {
                ActiveDocument = docLibraryVM.SelectedDoc;
            }
        }

With this approach the viewmodels do not know anything about the views and I limit the view interaction with the view model to within the DialogHost class.

I didn't include it for clarity but I have a little more logic to align this window to a supplied control or with a specific edge of the parent window.

[stevemonaco]

It's a bit minimal, but works well enough. My dialog service, which I call an (user) interaction service, has 3 flows:

1. Alert. Shows some informational text and an ok to dismiss. This could be integrated into an in-app or native toast system.
2. Prompt. Presents a question and some actions (Yes, No, Cancel).
3. Request. Shows a ViewModel (via UserControl lookup) where the data, presentation, and validation can be completely customized.