Я предлагаю отказаться от модальных диалогов 1990-х годов и вместо этого реализовать элемент управления в виде наложения (холст + абсолютное позиционирование) с видимостью, привязанной к логическому значению в виртуальной машине. Ближе к элементу управления типа ajax.

Это очень полезно:

<BooleanToVisibilityConverter x:Key="booltoVis" />

as in:

<my:ErrorControl Visibility="{Binding Path=ThereWasAnError, Mode=TwoWay, Converter={StaticResource booltoVis}, UpdateSourceTrigger=PropertyChanged}"/>

Вот как я реализовал его как пользовательский элемент управления. Нажатие на 'x' закрывает элемент управления в строке кода в коде пользовательского элемента управления позади. (Поскольку у меня есть представления в .exe и ViewModels в dll, я не чувствую себя плохо из-за кода, который управляет пользовательским интерфейсом.)

РЕДАКТИРОВАТЬ: Спустя более 10 лет я могу сказать, что использование Посредника или любого другого шаблона обмена сообщениями - действительно плохая идея на многих уровнях. Не делайте этого, просто реализуйте ответ Джеффри или IDialogService, внедренный в вашу модель представления.

Для этого вам следует использовать посредника. Посредник - это распространенный шаблон проектирования, также известный как Messenger в некоторых его реализациях. Это парадигма типа Register / Notify, которая позволяет вашей модели ViewModel и представлениям обмениваться данными через механизм обмена сообщениями с низкой связью.

Вы должны проверить группу Google WPF Disciples и просто поискать Mediator. Вы будете очень довольны ответами ...

Однако вы можете начать с этого:

http://joshsmithonwpf.wordpress.com/2009/04/06/a-mediator-prototype-for-wpf-apps/

Наслаждаться !

Изменить: вы можете увидеть ответ на эту проблему с помощью MVVM Light Toolkit здесь:

http://mvvmlight.codeplex.com/Thread/View.aspx?ThreadId=209338

Хороший диалог MVVM должен:

1. Объявляться только с помощью XAML.
2. Получите все его поведение из привязки данных.

К сожалению, WPF не предоставляет этих функций. Для отображения диалогового окна требуется вызов кода программной части для ShowDialog(). Класс Window, который поддерживает диалоги, не может быть объявлен в XAML, поэтому его нелегко привязать к DataContext.

Чтобы решить эту проблему, я написал элемент управления-заглушку XAML, который находится в логическом дереве и передает привязку данных к Window и обрабатывает отображение и скрытие диалогового окна. Вы можете найти его здесь: http://www.codeproject.com/KB/WPF/XAMLDialog.aspx

Его действительно просто использовать, он не требует каких-либо странных изменений в вашей модели просмотра и не требует событий или сообщений. Базовый вызов выглядит так:

<dialog:Dialog Content="{Binding Path=DialogViewModel}" Showing="True" />

Вероятно, вы захотите добавить стиль, устанавливающий Showing. Объясняю это в своей статье. Я надеюсь, это поможет вам.

Я использую этот подход для диалогов с MVVM. .

Все, что мне нужно сделать сейчас, это вызвать следующее из моей модели представления.

var result = this.uiDialogService.ShowDialog("Dialogwindow title goes here", dialogwindowVM);

Мое текущее решение решает большинство проблем, о которых вы упомянули, но оно полностью абстрагируется от конкретных вещей платформы и может быть использовано повторно. Также я не использовал привязку кода программной части только с DelegateCommands, которые реализуют ICommand. Диалог - это, по сути, представление - отдельный элемент управления, который имеет собственную модель представления и отображается из модели представления основного экрана, но запускается из пользовательского интерфейса через привязку DelagateCommand.

См. Полное решение Silverlight 4 здесь Модальные диалоги с MVVM и Silverlight 4

Я действительно некоторое время боролся с этой концепцией, когда изучал (все еще изучаю) MVVM. Что я решил, и что, как мне кажется, уже решили другие, но что мне было непонятно, так это:

Моя первоначальная мысль заключалась в том, что ViewModel не следует позволять напрямую вызывать диалоговое окно, поскольку она не имеет никакого отношения к решению, как должно отображаться диалоговое окно. Из-за этого я начал думать о том, как я могу передавать сообщения так же, как в MVP (например, View.ShowSaveFileDialog ()). Однако я считаю, что это неправильный подход.

Для ViewModel нормально вызывать диалог напрямую. Однако, когда вы тестируете ViewModel, это означает, что диалоговое окно либо появится во время вашего теста, либо полностью завершится неудачно (никогда не пробовал этого).

Итак, во время тестирования необходимо использовать «тестовую» версию вашего диалога. Это означает, что для любого диалога, который у вас есть, вам необходимо создать интерфейс и либо смоделировать ответ диалога, либо создать тестовый макет, который будет иметь поведение по умолчанию.

Вы уже должны использовать своего рода Service Locator или IoC, который вы можете настроить, чтобы предоставить вам правильную версию в зависимости от контекста.

Используя этот подход, ваша ViewModel по-прежнему тестируется, и в зависимости от того, как вы имитируете свои диалоги, вы можете управлять поведением.

Надеюсь это поможет.

Есть два хороших способа сделать это: 1) служба диалога (простой, понятный) и 2) поддержка просмотра. Поддержка просмотра предоставляет некоторые полезные функции, но, как правило, того не стоит.

ДИАЛОГ-СЕРВИС

а) интерфейс диалогового сервиса, например, через конструктор или какой-либо контейнер зависимостей:

interface IDialogService { Task ShowDialogAsync(DialogViewModel dlgVm); }

б) Ваша реализация IDialogService должна открывать окно (или вводить некоторый элемент управления в активное окно), создавать представление, соответствующее имени данного типа dlgVm (используйте регистрацию контейнера или соглашение, или ContentPresenter со связанным типом DataTemplates). ShowDialogAsync должен создать TaskCompletionSource и вернуть его свойство .Task. Самому классу DialogViewModel требуется событие, которое вы можете вызвать в производном классе, когда хотите закрыть, и наблюдать в диалоговом окне, чтобы фактически закрыть / скрыть диалоговое окно и завершить TaskCompletionSource.

б) Для использования просто вызовите await this.DialogService.ShowDialog (myDlgVm) в вашем экземпляре некоторого производного класса DialogViewModel. После того, как ожидание вернется, посмотрите на свойства, которые вы добавили в свою диалоговую виртуальную машину, чтобы определить, что произошло; вам даже не нужен обратный звонок.

ПОМОЩЬ ПО ПРОСМОТРУ

Это ваше представление, которое слушает событие на модели просмотра. Все это можно было бы обернуть в Blend Behavior, чтобы избежать использования кода и ресурсов, если вы так склонны (FMI, создайте подкласс класса «Behavior», чтобы увидеть своего рода присоединенное свойство Blendable на стероидах). На данный момент мы сделаем это вручную для каждого представления:

a) Создайте OpenXXXXXDialogEvent с настраиваемой полезной нагрузкой (производный класс DialogViewModel).

б) Попросите представление подписаться на событие в его событии OnDataContextChanged. Обязательно скройте и откажитесь от подписки, если старое значение! = Null и в событии Window Unloaded.

c) При возникновении события откройте представление, которое может быть в ресурсе на вашей странице, или вы можете найти его по соглашению в другом месте (например, в подходе службы диалогов).

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

Это позволяет диалоговым окнам быть близко к месту, где они фактически используются, затемнять только ту часть приложения, которая связана с текущим действием, и позволять пользователю перемещаться внутри приложения без необходимости вручную отталкивать диалоговые окна, даже иметь несколько квази- модальные диалоги открываются на разных вкладках или под-представлениях.

Используйте команду freezable

<Grid>
        <Grid.DataContext>
            <WpfApplication1:ViewModel />
        </Grid.DataContext>


        <Button Content="Text">
            <Button.Command>
                <WpfApplication1:MessageBoxCommand YesCommand="{Binding MyViewModelCommand}" />
            </Button.Command>
        </Button>

</Grid>

public class MessageBoxCommand : Freezable, ICommand
{
    public static readonly DependencyProperty YesCommandProperty = DependencyProperty.Register(
        "YesCommand",
        typeof (ICommand),
        typeof (MessageBoxCommand),
        new FrameworkPropertyMetadata(null)
        );


    public static readonly DependencyProperty OKCommandProperty = DependencyProperty.Register(
        "OKCommand",
        typeof (ICommand),
        typeof (MessageBoxCommand),
        new FrameworkPropertyMetadata(null)
        );


    public static readonly DependencyProperty CancelCommandProperty = DependencyProperty.Register(
        "CancelCommand",
        typeof (ICommand),
        typeof (MessageBoxCommand),
        new FrameworkPropertyMetadata(null)
        );


    public static readonly DependencyProperty NoCommandProperty = DependencyProperty.Register(
        "NoCommand",
        typeof (ICommand),
        typeof (MessageBoxCommand),
        new FrameworkPropertyMetadata(null)
        );


    public static readonly DependencyProperty MessageProperty = DependencyProperty.Register(
        "Message",
        typeof (string),
        typeof (MessageBoxCommand),
        new FrameworkPropertyMetadata("")
        );

    public static readonly DependencyProperty MessageBoxButtonsProperty = DependencyProperty.Register(
        "MessageBoxButtons",
        typeof(MessageBoxButton),
        typeof(MessageBoxCommand),
        new FrameworkPropertyMetadata(MessageBoxButton.OKCancel)
        );

    public ICommand YesCommand
    {
        get { return (ICommand) GetValue(YesCommandProperty); }
        set { SetValue(YesCommandProperty, value); }
    }

    public ICommand OKCommand
    {
        get { return (ICommand) GetValue(OKCommandProperty); }
        set { SetValue(OKCommandProperty, value); }
    }

    public ICommand CancelCommand
    {
        get { return (ICommand) GetValue(CancelCommandProperty); }
        set { SetValue(CancelCommandProperty, value); }
    }

    public ICommand NoCommand
    {
        get { return (ICommand) GetValue(NoCommandProperty); }
        set { SetValue(NoCommandProperty, value); }
    }

    public MessageBoxButton MessageBoxButtons
    {
        get { return (MessageBoxButton)GetValue(MessageBoxButtonsProperty); }
        set { SetValue(MessageBoxButtonsProperty, value); }
    }

    public string Message
    {
        get { return (string) GetValue(MessageProperty); }
        set { SetValue(MessageProperty, value); }
    }

    public void Execute(object parameter)
    {
        var messageBoxResult = MessageBox.Show(Message);
        switch (messageBoxResult)
        {
            case MessageBoxResult.OK:
                OKCommand.Execute(null);
                break;
            case MessageBoxResult.Yes:
                YesCommand.Execute(null);
                break;
            case MessageBoxResult.No:
                NoCommand.Execute(null);
                break;
            case MessageBoxResult.Cancel:
                if (CancelCommand != null) CancelCommand.Execute(null); //Cancel usually means do nothing ,so can be null
                break;

        }
    }

    public bool CanExecute(object parameter)
    {
        return true;
    }

    public event EventHandler CanExecuteChanged;


    protected override Freezable CreateInstanceCore()
    {
        throw new NotImplementedException();
    }
}

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

Если вы измените взаимодействие ViewModel - View для обработки диалогов, тогда ViewModel будет зависеть от этой реализации. Самый простой способ справиться с этой проблемой - сделать View ответственным за выполнение задачи. Если это означает отображение диалогового окна, тогда нормально, но это также может быть статусное сообщение в строке состояния и т. Д.

Я хочу сказать, что весь смысл шаблона MVVM состоит в том, чтобы отделить бизнес-логику от графического интерфейса пользователя, поэтому вам не следует смешивать логику графического интерфейса (для отображения диалогового окна) с бизнес-уровнем (ViewModel).

Интересной альтернативой является использование контроллеров, которые отвечают за отображение представлений (диалогов).

Как это работает, показывает WPF Application Framework (WAF).

Почему бы просто не вызвать событие в виртуальной машине и не подписаться на событие в представлении? Это сохранит логику приложения и представление отдельно и по-прежнему позволит вам использовать дочернее окно для диалогов.

Я реализовал поведение, которое прослушивает сообщение от ViewModel. Он основан на решении Laurent Bugnion, но, поскольку он не использует код и его можно использовать повторно, я считаю его более элегантным.

Как заставить WPF вести себя так, как будто MVVM поддерживается "из коробки"

Я думаю, что в представлении может быть код для обработки события из модели представления.

В зависимости от события / сценария он также может иметь триггер события, который подписывается на просмотр событий модели, и одно или несколько действий, вызываемых в ответ.

У меня была такая же ситуация, и я заключил MessageBox в невидимый дизайнерский элемент управления. Подробности в моем блоге

http://geekswithblogs.net/mukapu/archive/2010/03/12/user-prompts-messagebox-with-mvvm.aspx

То же самое можно распространить на любые модальные диалоги, управление просмотром файлов и т. Д.

Стандартный подход

Потратив годы на решение этой проблемы в WPF, я наконец понял стандартный способ реализации диалогов в WPF. Вот преимущества этого подхода:

1. ЧИСТЫЙ
2. Не нарушает шаблон проектирования MVVM
3. ViewModal никогда не ссылается ни на одну из библиотек пользовательского интерфейса (WindowBase, PresentationFramework и т. Д.).
4. Идеально подходит для автоматизированного тестирования
5. Диалоги можно легко заменить.

Так в чем же ключ. Это DI + IoC.

Вот как это работает. Я использую MVVM Light, но этот подход можно распространить и на другие фреймворки:

1. Добавьте в решение проект приложения WPF. Назовите это Приложение.
2. Добавьте библиотеку классов ViewModal. Назовите это ВМ.
3. Приложение ссылается на проект виртуальной машины. Проект виртуальной машины ничего не знает о приложении.
4. Добавьте ссылку NuGet на MVVM Light в оба проекта. Сейчас я использую MVVM Light Standard, но вы тоже можете использовать полную версию Framework.

5. Добавьте интерфейс IDialogService в проект ВМ:

   public interface IDialogService
   {
     void ShowMessage(string msg, bool isError);
     bool AskBooleanQuestion(string msg);
     string AskStringQuestion(string msg, string default_value);
   
     string ShowOpen(string filter, string initDir = "", string title = "");
     string ShowSave(string filter, string initDir = "", string title = "", string fileName = "");
     string ShowFolder(string initDir = "");
   
     bool ShowSettings();
   }
   

6. Предоставьте общедоступное статическое свойство типа IDialogService в вашем ViewModelLocator, но оставьте часть регистрации для выполнения слоя View. Это ключ.:

   public static IDialogService DialogService => SimpleIoc.Default.GetInstance<IDialogService>();
   

7. Добавьте реализацию этого интерфейса в проект приложения.

   public class DialogPresenter : IDialogService
   {
       private static OpenFileDialog dlgOpen = new OpenFileDialog();
       private static SaveFileDialog dlgSave = new SaveFileDialog();
       private static FolderBrowserDialog dlgFolder = new FolderBrowserDialog();
   
       /// <summary>
       /// Displays a simple Information or Error message to the user.
       /// </summary>
       /// <param name="msg">String text that is to be displayed in the MessageBox</param>
       /// <param name="isError">If true, Error icon is displayed. If false, Information icon is displayed.</param>
       public void ShowMessage(string msg, bool isError)
       {
               if(isError)
                       System.Windows.MessageBox.Show(msg, "Your Project Title", MessageBoxButton.OK, MessageBoxImage.Error);
               else
                       System.Windows.MessageBox.Show(msg, "Your Project Title", MessageBoxButton.OK, MessageBoxImage.Information);
       }
   
       /// <summary>
       /// Displays a Yes/No MessageBox.Returns true if user clicks Yes, otherwise false.
       /// </summary>
       /// <param name="msg"></param>
       /// <returns></returns>
       public bool AskBooleanQuestion(string msg)
       {
               var Result = System.Windows.MessageBox.Show(msg, "Your Project Title", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes;
               return Result;
       }
   
       /// <summary>
       /// Displays Save dialog. User can specify file filter, initial directory and dialog title. Returns full path of the selected file if
       /// user clicks Save button. Returns null if user clicks Cancel button.
       /// </summary>
       /// <param name="filter"></param>
       /// <param name="initDir"></param>
       /// <param name="title"></param>
       /// <param name="fileName"></param>
       /// <returns></returns>
       public string ShowSave(string filter, string initDir = "", string title = "", string fileName = "")
       {
               if (!string.IsNullOrEmpty(title))
                       dlgSave.Title = title;
               else
                       dlgSave.Title = "Save";
   
               if (!string.IsNullOrEmpty(fileName))
                       dlgSave.FileName = fileName;
               else
                       dlgSave.FileName = "";
   
               dlgSave.Filter = filter;
               if (!string.IsNullOrEmpty(initDir))
                       dlgSave.InitialDirectory = initDir;
   
               if (dlgSave.ShowDialog() == DialogResult.OK)
                       return dlgSave.FileName;
               else
                       return null;
       }
   
   
       public string ShowFolder(string initDir = "")
       {
               if (!string.IsNullOrEmpty(initDir))
                       dlgFolder.SelectedPath = initDir;
   
               if (dlgFolder.ShowDialog() == DialogResult.OK)
                       return dlgFolder.SelectedPath;
               else
                       return null;
       }
   
   
       /// <summary>
       /// Displays Open dialog. User can specify file filter, initial directory and dialog title. Returns full path of the selected file if
       /// user clicks Open button. Returns null if user clicks Cancel button.
       /// </summary>
       /// <param name="filter"></param>
       /// <param name="initDir"></param>
       /// <param name="title"></param>
       /// <returns></returns>
       public string ShowOpen(string filter, string initDir = "", string title = "")
       {
               if (!string.IsNullOrEmpty(title))
                       dlgOpen.Title = title;
               else
                       dlgOpen.Title = "Open";
   
               dlgOpen.Multiselect = false;
               dlgOpen.Filter = filter;
               if (!string.IsNullOrEmpty(initDir))
                       dlgOpen.InitialDirectory = initDir;
   
               if (dlgOpen.ShowDialog() == DialogResult.OK)
                       return dlgOpen.FileName;
               else
                       return null;
       }
   
       /// <summary>
       /// Shows Settings dialog.
       /// </summary>
       /// <returns>true if User clicks OK button, otherwise false.</returns>
       public bool ShowSettings()
       {
               var w = new SettingsWindow();
               MakeChild(w); //Show this dialog as child of Microsoft Word window.
               var Result = w.ShowDialog().Value;
               return Result;
       }
   
       /// <summary>
       /// Prompts user for a single value input. First parameter specifies the message to be displayed in the dialog 
       /// and the second string specifies the default value to be displayed in the input box.
       /// </summary>
       /// <param name="m"></param>
       public string AskStringQuestion(string msg, string default_value)
       {
               string Result = null;
   
               InputBox w = new InputBox();
               MakeChild(w);
               if (w.ShowDialog(msg, default_value).Value)
                       Result = w.Value;
   
               return Result;
       }
   
       /// <summary>
       /// Sets Word window as parent of the specified window.
       /// </summary>
       /// <param name="w"></param>
       private static void MakeChild(System.Windows.Window w)
       {
               IntPtr HWND = Process.GetCurrentProcess().MainWindowHandle;
               var helper = new WindowInteropHelper(w) { Owner = HWND };
       }
   }
   

8. Хотя некоторые из этих функций являются общими (ShowMessage, AskBooleanQuestion и т. Д.), Другие специфичны для этого проекта и используют пользовательские Windows. Таким же образом вы можете добавить дополнительные окна. Ключ состоит в том, чтобы сохранить элементы, специфичные для пользовательского интерфейса, на уровне представления и просто предоставлять возвращаемые данные с помощью POCO на уровне виртуальной машины.

9. Выполните регистрацию IoC вашего интерфейса на слое просмотра с помощью этого класса. Вы можете сделать это в конструкторе основного представления (после вызова InitializeComponent()):

   SimpleIoc.Default.Register<IDialogService, DialogPresenter>();
   

10. Вот и все. Теперь у вас есть доступ ко всем функциям диалогов как на уровне виртуальной машины, так и на уровне просмотра. Уровень виртуальной машины может вызывать эти функции следующим образом:

    var NoTrump = ViewModelLocator.DialogService.AskBooleanQuestion("Really stop the trade war???", "");
    

11. Так чисто, видите ли. Слой виртуальной машины ничего не знает о том, как вопрос «Да / Нет» будет представлен пользователю уровнем пользовательского интерфейса, и может успешно работать с результатом, возвращаемым из диалогового окна.

Другие бесплатные льготы

1. Для написания модульного теста вы можете предоставить пользовательскую реализацию IDialogService в своем тестовом проекте и зарегистрировать этот класс в IoC в конструкторе вашего тестового класса.
2. Вам нужно будет импортировать некоторые пространства имен, например Microsoft.Win32, для доступа к диалоговым окнам «Открыть» и «Сохранить». Я оставил их, потому что есть также версия этих диалоговых окон WinForms, плюс кто-то может захотеть создать свою собственную версию. Также обратите внимание, что некоторые идентификаторы, используемые в DialogPresenter, являются именами моих собственных окон (например, SettingsWindow). Вам нужно будет либо удалить их как из интерфейса, так и из реализации, либо предоставить свои собственные окна.
3. Если ваша виртуальная машина выполняет многопоточность, вызовите DispatcherHelper.Initialize() MVVM Light на ранней стадии жизненного цикла вашего приложения.

4. За исключением DialogPresenter, который вводится на уровне представления, другие ViewModals должны быть зарегистрированы в ViewModelLocator, а затем публичное статическое свойство этого типа должно быть предоставлено для использования слоем представления. Что-то вроде этого:

   public static SettingsVM Settings => SimpleIoc.Default.GetInstance<SettingsVM>();
   

5. По большей части в ваших диалогах не должно быть кода программной части для таких вещей, как привязка или установка DataContext и т. Д. Вы даже не должны передавать вещи в качестве параметров конструктора. XAML может сделать все это за вас, например:

   <Window x:Class="YourViewNamespace.SettingsWindow"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:local="clr-namespace:YourViewProject"
     xmlns:vm="clr-namespace:YourVMProject;assembly=YourVMProject"
     DataContext="{x:Static vm:ViewModelLocator.Settings}"
     d:DataContext="{d:DesignInstance Type=vm:SettingsVM}" />
   

6. Установка DataContext таким образом дает вам все виды преимуществ во время разработки, такие как Intellisense и автозаполнение.

Надеюсь, это поможет всем.

Накатил собственный оконный загрузчик, описанный в ответе на этот вопрос:

Управление несколькими представлениями WPF в приложении

Карл Шиффлетт создал образец приложения для отображения диалоговых окон с использованием сервисного подхода и подхода Prism InteractionRequest.

Мне нравится сервисный подход - он менее гибкий, поэтому пользователи с меньшей вероятностью что-то сломают :) Он также согласуется с частью WinForms моего приложения (MessageBox.Show). Но если вы планируете показывать много разных диалогов, тогда InteractionRequest - это лучший способ пойти.

http://karlshifflett.wordpress.com/2010/11/07/in-the-box-ndash-mvvm-training/

Я знаю, что это старый вопрос, но когда я провел этот поиск, я нашел много связанных вопросов, но я не нашел действительно четкого ответа. Поэтому я делаю свою собственную реализацию диалогового окна / сообщения / попина и делюсь ею!
Я думаю, что это «доказательство MVVM», и я стараюсь сделать его простым и правильным, но я новичок в WPF, так что почувствуйте бесплатно, чтобы комментировать, или даже сделать запрос на перенос.

https://github.com/Plasma-Paris/Plasma.WpfUtils

Вы можете использовать это так:

public RelayCommand YesNoMessageBoxCommand { get; private set; }
async void YesNoMessageBox()
{
    var result = await _Service.ShowMessage("This is the content of the message box", "This is the title", System.Windows.MessageBoxButton.YesNo);
    if (result == System.Windows.MessageBoxResult.Yes)
        // [...]
}

Или вот так, если вам нужен более сложный попин:

var result = await _Service.ShowCustomMessageBox(new MyMessageBoxViewModel { /* What you want */ });

И это показывает следующее:

Я размышлял над подобной проблемой, когда спрашивал как должна выглядеть модель представления для задачи или диалога.

Мое текущее решение выглядит так:

public class SelectionTaskModel<TChoosable> : ViewModel
    where TChoosable : ViewModel
{
    public SelectionTaskModel(ICollection<TChoosable> choices);
    public ReadOnlyCollection<TChoosable> Choices { get; }
    public void Choose(TChoosable choosen);
    public void Abort();
}

Когда модель представления решает, что требуется ввод данных пользователем, она извлекает экземпляр SelectionTaskModel с возможными вариантами выбора для пользователя. Инфраструктура позаботится о том, чтобы вызвать соответствующее представление, которое в свое время вызовет функцию Choose() по выбору пользователя.

Я боролся с той же проблемой. Я придумал способ взаимодействия между View и ViewModel. Вы можете инициировать отправку сообщения из ViewModel в View, чтобы сообщить ему, что нужно показать окно сообщения, и он отправит отчет с результатом. Затем ViewModel может реагировать на результат, возвращаемый из View.

Я демонстрирую это в мой блог:

Я написал довольно исчерпывающую статью по этой теме, а также разработал всплывающую библиотеку для диалогов MVVM. Строгое соблюдение MVVM не только возможно, но и очень чисто при правильной реализации, и его можно легко распространить на сторонние библиотеки, которые сами этого не придерживаются:

https://www.codeproject.com/Articles/820324/Implementing-Dialog-Boxes-in-MVVM

Извините, но я должен вмешаться. Я прошел через несколько предложенных решений, прежде чем нашел пространство имен Prism.Wpf.Interactivity в проекте Prism. Вы можете использовать запросы на взаимодействие и действие всплывающего окна, чтобы либо развернуть настраиваемое окно, либо для более простых нужд встроены всплывающие окна с уведомлениями и подтверждениями. Они создают настоящие окна и управляются как таковые. вы можете передать объект контекста с любыми нужными вам зависимостями в диалоговом окне. Мы используем это решение в своей работе с тех пор, как я его нашел. У нас здесь много старших разработчиков, и никто не придумал ничего лучше. Нашим предыдущим решением была диалоговая служба в наложении и использование класса презентатора, чтобы это произошло, но у вас должны были быть фабрики для всех моделей диалоговых окон и т. Д.

Это нетривиально, но и не очень сложно. И он встроен в Prism и поэтому является лучшей (или лучшей) практикой ИМХО.

Мои 2 цента!

РЕДАКТИРОВАТЬ: да, я согласен, что это неправильный подход MVVM, и теперь я использую что-то похожее на то, что предлагает blindmeis.

Один из способов сделать это -

В вашей модели основного представления (где вы открываете модальное окно):

void OpenModal()
{
    ModalWindowViewModel mwvm = new ModalWindowViewModel();
    Window mw = new Window();
    mw.content = mwvm;
    mw.ShowDialog()
    if(mw.DialogResult == true)
    { 
        // Your Code, you can access property in mwvm if you need.
    }
}

И в вашем модальном окне просмотра / ViewModel:

XAML:

<Button Name="okButton" Command="{Binding OkCommand}" CommandParameter="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}}">OK</Button>
<Button Margin="2" VerticalAlignment="Center" Name="cancelButton" IsCancel="True">Cancel</Button>

ViewModel:

public ICommand OkCommand
{
    get
    {
        if (_okCommand == null)
        {
            _okCommand = new ActionCommand<Window>(DoOk, CanDoOk);
        }
        return _okCommand ;
    }
}

void DoOk(Window win)
{
    <!--Your Code-->
    win.DialogResult = true;
    win.Close();
}

bool CanDoOk(Window win) { return true; }

или аналогично тому, что размещено здесь WPF MVVM: как закрыть окно