Prism dialog service

Continue with the code in the previous section , Delete the redundant part of the code .

Dialogue service , It's a pop-up prompt ,prism It was packaged .

Business ： Click button , Pass the value to the pop-up box , Pop up box prompt , Select OK or cancel in the pop-up box , Then send the value back to the main interface

1. The code structure

2.MainViewModel.cs

using Prism.Commands;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WPFPrism.Views;

namespace WPFPrism.ViewModels
{
    public class MainViewModel : BindableBase
    {
        private readonly IDialogService dialogService;

        public DelegateCommand<string> OpenCommand { get; set; }// Create command ,string Used to receive parameters , for example ViewA
        public MainViewModel(IDialogService dialogService)// Click here for quick operation . Take the area defined by the interface Content
        {

            OpenCommand = new DelegateCommand<string>(Open);

            this.dialogService = dialogService;
        }

        private void Open(string obj)
        {
            DialogParameters keys = new DialogParameters();
            keys.Add("title", " Test cartridge ");// Click the button in the main interface to transfer the parameters to the pop-up interface 
            dialogService.ShowDialog(obj, keys, callback =>
              {
                  if (callback.Result == ButtonResult.OK)
                  {
                      string result = callback.Parameters.GetValue<string>("value");// Receive the value passed 
                  }
              });
        }
    }
}

 3.ViewDViewModel.cs

using Prism.Commands;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WPFPrism.ViewModels
{
    public class ViewDViewModel : IDialogAware
    {
        public DelegateCommand CancelComm { get; set; }
        public DelegateCommand OkComm { get; set; }

        public string Title { get; set; }

        public event Action<IDialogResult> RequestClose;


        public ViewDViewModel()
        {
            CancelComm = new DelegateCommand(Cancel);
            OkComm = new DelegateCommand(Ok);
        }

        /// <summary>
        ///  determine 
        /// </summary>
        private void Ok()
        {
            //RequestClose?.Invoke(new DialogResult(ButtonResult.OK));// Or return OK
            OnDialogClosed();
        }

        /// <summary>
        ///  close 
        /// </summary>
        private void Cancel()
        {
            RequestClose?.Invoke(new DialogResult(ButtonResult.No));
        }

        public bool CanCloseDialog()
        {
            return true;
        }

        public void OnDialogClosed()
        {
            DialogParameters keys = new DialogParameters();
            keys.Add("value", "hello");// Pass the value to the main interface 
            RequestClose?.Invoke(new DialogResult(ButtonResult.OK, keys));
        }

        public void OnDialogOpened(IDialogParameters parameters)
        {
            // First enter this 
            // Receive the parameters passed from the main interface 
            Title = parameters.GetValue<string>("title");
        }
    }
}

4. main interface

5. Popup interface

6.App.xaml.cs, In fact, this is just a sentence RegisterDialog, Register the pop-up box

using ModuleA;
using ModuleB;
using Prism.DryIoc;
using Prism.Ioc;
using Prism.Modularity;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using WPFPrism.ViewModels;
using WPFPrism.Views;

namespace WPFPrism
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : PrismApplication
    {
        protected override Window CreateShell()
        {
            // Get it through the container MainView, It is also the place to start 
            return Container.Resolve<MainView>();
        }

        protected override void RegisterTypes(IContainerRegistry containerRegistry)
        {
            // The function of dependency injection , Add the content to be realized by dependency injection 
            //containerRegistry.RegisterForNavigation<ViewA>(); //containerRegistry.RegisterForNavigation<ViewA>("ViewA The specific name of ") Customize , It can be written like this ;
            //containerRegistry.RegisterForNavigation<ViewB>();
            //containerRegistry.RegisterForNavigation<ViewC>();// We still use C modular ,C The module is of the current program .

            // Register the pop-up prompt interface 
            containerRegistry.RegisterDialog<ViewD, ViewDViewModel>();
        }

        protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
        {
            // Here is the code 
            //moduleCatalog.AddModule<ModuleAfile>();// load A modular 
            //moduleCatalog.AddModule<ModuleBfile>();// load B modular 
            base.ConfigureModuleCatalog(moduleCatalog);
        }
        protected override IModuleCatalog CreateModuleCatalog()
        {
            // Here is the configuration 
            //return new DirectoryModuleCatalog()
            //{
            //    ModulePath = @"Modules"// Here is the main program exe Same as... Under the folder Modules Folder 
            //};
            return base.CreateModuleCatalog();
        }

    }
}

What you should pay attention to is 2 spot ：

Receive the information of the main interface when opening the dialog box , To deal with .

When closing the dialog box, pass the information to the main interface .