I’ve developed an IDialogWindow within a C# application to prompt users for input, such as “OK” or “Cancel,” and it currently operates synchronously, halting any further thread execution until the user interacts with the dialog or closes it. However, I’m seeking to implement a solution where the dialog operates asynchronously, allowing concurrent threads to continue while it awaits a specific event before closing. Here’s the code:

namespace FW.Common.Utilities
{
public interface IDialogWindow
{
    bool? DialogResult { get; set; }
    object DataContext { get; set; }
    void Close();
    bool? ShowDialog();
    void Show();
}

public interface IDialogService
{
    void Register<TViewModel, TView>() where TViewModel : IDialogRequestClose
        where TView : IDialogWindow;

    bool? ShowDialog<TViewModel>(TViewModel viewModel) where TViewModel : IDialogRequestClose;
    void SetOwner(object owner);
}

public class DialogCloseRequestedEventArgs : EventArgs
{
    public bool? DialogResult { get; }

    public DialogCloseRequestedEventArgs(bool? dialogResult)
    {
        DialogResult = dialogResult;
    }
}

public interface IDialogRequestClose
{
    event EventHandler<DialogCloseRequestedEventArgs> CloseRequested;
}

public class DialogService: IDialogService
{
    public IDictionary<Type, Type> Mappings { get; }
    private object _owner;
    IDialogWindow dialogWindow;
    Type viewType;
    public DialogService()
    {
        Mappings = new Dictionary<Type, Type>();
    }

    public void Register<TViewModel, TView>()
        where TViewModel : IDialogRequestClose
        where TView : IDialogWindow
    {
        if (Mappings.ContainsKey(typeof(TViewModel)))
        {
            throw new ArgumentException($"Type {typeof(TViewModel)} is already mapped to type {typeof(TView)}");
        }
        Mappings.Add(typeof(TViewModel), typeof(TView));
        viewType = Mappings[typeof(TViewModel)];
    }

    /// <summary>
    /// To set the owner of the dialog
    /// </summary>
    /// <param name="owner">Owner object</param>
    public void SetOwner(object owner)
    {
        this._owner = owner;
    }

    /// <summary>
    /// To show a dialog
    /// </summary>
    /// <typeparam name="TViewModel"></typeparam>
    /// <param name="viewModel">The dialog viewmodel</param>
    /// <returns>Status</returns>
    public bool? ShowDialog<TViewModel>(TViewModel viewModel) where TViewModel : IDialogRequestClose
    {
        dialogWindow = (IDialogWindow)Activator.CreateInstance(viewType,_owner);

        void handler(object sender, DialogCloseRequestedEventArgs e)
        {
            viewModel.CloseRequested -= handler;

            if (e.DialogResult.HasValue)
            {
                dialogWindow.DialogResult = e.DialogResult;
            }
            dialogWindow.Close();
        }

        viewModel.CloseRequested += handler;
        dialogWindow.DataContext = viewModel;
        return dialogWindow.ShowDialog();
    }

To create a dialog window, the following code line is used:

var cancelingMessageBox = new MessageBoxViewModel("Cancelling step...", "Cancel");
_ = _dialogService.ShowDialog(cancelingMessageBox);

Any guidance or insights on achieving this asynchronous behavior would be greatly appreciated.