Области призмы c # в модальных диалогах

Question

В настоящее время я занимаюсь разработкой приложения с использованием C # WPF + PRISM 6.0.Сейчас я хочу реализовать помощник по импорту данных в виде модального диалога.Это диалоговое окно должно быть удобным, поэтому я определил область внутри него, где страницы помощника будут отображаться после того, как пользователь нажимает «следующий» или «предыдущий».

Модальное диалоговое окно будет отображаться с помощьюиспользуя IDialogService.

Моя проблема в том, что модальная область диалога не разрешена, поэтому я не могу добавить к ней вспомогательные виды.Вот что я пытаюсь

в моем модуле. Я регистрирую виды приложений и модели представления и пытаюсь добавить виды в регионы

Container.RegisterType<IAppView, AppView>();
Container.RegisterType<IAppViewModel, AppViewModel>();

IViewModel viewModel = Container.Resolve<IViewModel>();
var region = RegionManager.Regions.FirstOrDefault(r => r.Name == "MainAppRegion");
if (region != null)
{
    region.Add(viewModel.View);
}

Container.RegisterType<IModalDialogView, ModalDialogView>();
Container.RegisterType<IModalDialogViewModel, ModalDialogViewModel>();

# here the region is null, and i can't add the ModalDialogView to it
IViewModel viewModel = Container.Resolve<IModalDialogViewModel>();
region = RegionManager.Regions.FirstOrDefault(r => r.Name == "ModalDialogCenterRegion");
if (region != null)
{
    region.Add(viewModel.View);
}

Модальное диалоговое окно - это окно,потому что IDialogService требует окна.

Это правильный подход для реализации такого помощника?

Спасибо и всего наилучшего,

Майкл

Answer 1

Здесь источник для моих IModalDialogView (ImportDialogView) и IModalDialogViewModel (ImportDialogViewModel)

Определение интерфейса, приведенное ниже, немного похоже на строительную площадку.Я получаю из двух интерфейсов (IModalDialogViewModel и IInteractionRequestAware), потому что я не уверен, какой шаблон для модальных диалогов я буду использовать или какой шаблон лучше для моих нужд.До сих пор производная от обоих, не нарушает функциональность.

IImportDialogViewModel.cs

using System.Collections.Generic;
using Infrastructure.Interfaces;
using Model;
using MvvmDialogs;
using Prism.Interactivity.InteractionRequest;
using Prism.Regions;

namespace Modules.Interfaces.ImportAssistant
{
    public interface IImportDialogViewModel : IViewModel, IModalDialogViewModel, IInteractionRequestAware
    {
        IEnumerable<Data> ImportedData { get; set; }
        IRegionManager RegionManager { get; set; }
    }
}

importdialogview.xaml

<UserControl x:Class="Modules.View.ImportAssistant.ImportDialogView" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
             xmlns:inf="clr-namespace:Infrastructure;assembly=Infrastructure" xmlns:local="clr-namespace:Modules.View.ImportAssistant"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:md="https://github.com/fantasticfiasco/mvvm-dialogs"
             xmlns:prism="http://prismlibrary.com/" xmlns:ImportAssistant="clr-namespace:Modules.ViewModel.ImportAssistant"
             Width="1200" Height="600"
             mc:Ignorable="d" Loaded="ImportDialogView_OnLoaded"
             d:DataContext="{d:DesignInstance d:Type=ImportAssistant:ImportDialogViewModel}"
             md:DialogServiceViews.IsRegistered="True">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="80" />
            <RowDefinition Height="*" />
            <RowDefinition Height="40" />
        </Grid.RowDefinitions>
        <Label Grid.Row="0"
               Content="{Binding Title, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
               FontSize="24"
               Style="{StaticResource TitleLabelStyle}" />
        <ContentControl x:Name="AssistantDialogContentControl" Grid.Row="1"
                        prism:RegionManager.RegionName="{x:Static inf:RegionNames.ImportAssistantMain}" />
        <Grid Grid.Row="2">
            <Grid.ColumnDefinitions>
                <ColumnDefinition />
                <ColumnDefinition />
            </Grid.ColumnDefinitions>
            <StackPanel Grid.Column="0" HorizontalAlignment="Left"
                        Orientation="Vertical">
                <Button Command="{Binding AbortAssistantCommand}"
                        Content="Abort"
                        Style="{StaticResource DefaultDialogButton}" />
            </StackPanel>
            <StackPanel Grid.Column="1" HorizontalAlignment="Right"
                        Orientation="Horizontal">
                <Button Command="{Binding PreviousCommand}"
                        Content="Previous"
                        Style="{StaticResource DefaultDialogButton}" />
                <Button Command="{Binding NextCommand}"
                        Content="Next"
                        Style="{StaticResource DefaultDialogButton}" />
                <Button Command="{Binding FinishCommand}"
                        Content="Finish"
                        Style="{StaticResource DefaultDialogButton}" />
            </StackPanel>
        </Grid>
    </Grid>
</UserControl>

Importdialogview.xaml.cs

using System.Windows;
using System.Windows.Controls;
using Infrastructure.Interfaces;
using Modules.Interfaces.ImportAssistant;
using Prism.Regions;
using Infrastructure;
using Microsoft.Practices.ServiceLocation;
using System.Linq;

namespace Modules.View.ImportAssistant
{
    /// <summary>
    /// Interaction logic for ImportDialogView.xaml
    /// </summary>
    public partial class ImportDialogView : UserControl, IImportDialogView
    {
        public ImportDialogView(IImportDialogViewModel viewModel)
        {
            InitializeComponent();

            ViewModel = viewModel;
            viewModel.View = this;

            var regionManager = ServiceLocator.Current.GetInstance<IRegionManager>();

            if (regionManager.Regions.Any(r => r.Name == RegionNames.ImportAssistantMain) == false)
            {
                RegionManager.SetRegionName(AssistantDialogContentControl, RegionNames.ImportAssistantMain);
                RegionManager.SetRegionManager(AssistantDialogContentControl, regionManager);
            }
        }

        public IViewModel ViewModel
        {
            get { return (IImportDialogViewModel)DataContext; }
            set { DataContext = value; }
        }

        private void ImportDialogView_OnLoaded(object sender, RoutedEventArgs e)
        {

        }
    }
}

importdialogviewmodel.cs

using Model;
using Modules.View.ImportAssistant;
using Prism.Commands;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Input;
using Infrastructure.Interfaces;
using Modules.Interfaces.ImportAssistant;
using Infrastructure;
using Prism.Interactivity.InteractionRequest;

namespace Modules.ViewModel.ImportAssistant
{
    public class ImportDialogViewModel : BindableBase, IImportDialogViewModel
    {
        public IRegionManager RegionManager { get; set; }

        private string _title;
        public string Title
        {
            get { return _title; }
            set
            {
                SetProperty(ref _title, value, nameof(Title));
            }
        }
        public IView View { get; set; }

        public IEnumerable<Data> ImportedData { get; set; }



        private INotification _notification;
        public INotification Notification
        {
            get { return _notification; }
            set
            {
                var confirmation = value as ImportConfirmation;
                if (confirmation != null)
                {
                    //SetProperty(ref _notification, value, nameof(Notification));
                    _notification = confirmation;
                    RaisePropertyChanged(nameof(Notification));
                }
            }
        }


        public Action FinishInteraction { get; set; }


        private bool? _dialogResult;
        public bool? DialogResult
        {
            get { return _dialogResult; }
            set
            {
                if (_dialogResult != value)
                {
                    SetProperty(ref _dialogResult, value, nameof(DialogResult));
                }
            }
        }


        public ICommand AbortAssistantCommand { get; set; }
        public ICommand NextCommand { get; set; }
        public ICommand PreviousCommand { get; set; }
        public ICommand FinishCommand { get; set; }

        public ImportDialogViewModel(IImportDialogView view, IRegionManager r)
        {
            RegionManager = r;

            View = view;
            View.ViewModel = this;

            InitializeCommands();
        }

        private void InitializeCommands()
        {
            AbortAssistantCommand = new DelegateCommand(() => { DialogResult = false; });

            NextCommand = new DelegateCommand(() =>
            {
                var importDialogMainRegion = RegionManager.Regions.FirstOrDefault(r => r.Name == RegionNames.ImportAssistantMain);
                if (importDialogMainRegion != null)
                {
                    var firstActiveView = importDialogMainRegion.ActiveViews.FirstOrDefault();
                    string viewType = null;
                    if (firstActiveView is IImportStartView)
                    {
                        viewType = typeof(FileSelectionView).FullName;
                    }
                    else if (firstActiveView is FileSelectionView)
                    {
                        viewType = typeof(DataSelectionView).FullName;
                    }


                    if (string.IsNullOrEmpty(viewType) == false)
                    {
                        RegionManager?.RequestNavigate(RegionNames.ImportAssistantMain, viewType); 
                    }
                }
            });

            PreviousCommand = new DelegateCommand(() =>
            {
                var importDialogMainRegion = RegionManager.Regions.FirstOrDefault(r => r.Name == RegionNames.ImportAssistantMain);
                if (importDialogMainRegion != null)
                {
                    var firstActiveView = importDialogMainRegion.ActiveViews.FirstOrDefault();

                }
            });

            FinishCommand = new DelegateCommand(() => 
            {
                DialogResult = true;
                FinishInteraction?.Invoke();
            });
        }


    }
}