Aceptar cancelar Dialog MVVM Pattern wpf.¿Cómo puedo hacerlo?

Question

Estoy trabajando en una aplicación MVVM wpf y necesito mostrar varios cuadros de diálogo con ok cancel. He visto pocos en la red, pero la mirada es demasiado complicada o puede ser que yo esté luchando.

he notado que muchos de los que usan "IDialogService"

Puede alguien que me señale un enlace o tiene un fragmento útil sobre cómo implementar un diálogo utilizando un patrón MVVM?

muchas gracias

Answer 1

aquí es un cuadro de diálogo de barebones con los botones Aceptar y Cancelar. He incluido el XAML, Ver y modelo de vista:

XAML:

<Window 
    x:Class="TestProject.Views.OKCancelDialog" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
    Title="Window Title" 
    Height="300" 
    Width="600" 
    WindowStartupLocation="CenterOwner" 
    WindowStyle="ToolWindow" 
    ResizeMode="CanResize" 
    UseLayoutRounding="True" 
    TextOptions.TextFormattingMode="Display"> 

    <Grid> 
     <Button 
      Name="OKButton" 
      Content="OK" 
      Height="23" 
      HorizontalAlignment="Right" 
      Margin="0,0,93,12" 
      VerticalAlignment="Bottom" 
      Width="75" 
      Click="OKButton_Click" 
      IsDefault="True" 
      Command="{Binding OKButtonCommand}" /> 

     <Button 
      Name="CancelButton" 
      Content="Cancel" 
      Height="23" 
      HorizontalAlignment="Right" 
      Margin="0,0,12,12" 
      VerticalAlignment="Bottom" 
      Width="75" 
      IsCancel="True" /> 
    </Grid> 
</Window> 

Codebehind:

using System.Windows; 
using TestProject.ViewModel; 

namespace TestProject.Views 
{ 
    public partial class OKCancelDialog : Window 
    { 
     private readonly OKCancelViewModel viewModel; 

     //I use DI to inject the ViewModel into the View 
     //This will allow you to use the view for different ViewModels if you need to. 
     //Create an Interface for your ViewModel to implement to make ViewModel unit testing 
     //easier. Testing frameworks such as rhino mock require Interfaces to test methods 
     //in a class under test and it allows you to use an IoC Container to create the 
     //ViewModel for you.     
     public OpenReturnDialog(IOKCancelViewModel viewModel) 
     { 
      InitializeComponent(); 
      this.viewModel = viewModel; //Do this if you need access to the VM from inside your View. Or you could just use this.Datacontext to access the VM. 
      this.DataContext = viewModel; 
     } 

     private void OKButton_Click(object sender, RoutedEventArgs e) 
     { 
      DialogResult = true; 
     } 

    } 
} 

modelo de vista

using Microsoft.Practices.Composite.Presentation.Commands; 


namespace TestProject.ViewModel 
{ 
    public class OKCancelViewModel 
    { 
     public OKCancelViewModel() 
     { 
      OKButtonCommand = new DelegateCommand<object>(HandleOKButtonCommand, CanExecuteOKButtonCommand); 
     } 

     public DelegateCommand<object> OKButtonCommand { get; private set; } 

     public void HandleOKButtonCommand(object obj) 
     { 
      //Here is where your code for OK button clicks go. 

     } 

     public bool CanExecuteOKButtonCommand(object obj) 
     { 
      //Put code to determine when the OK button will be enabled/disabled. 
     } 

     //You may want to add a command for the Cancel button also if you have a need to 
     //enable/disable the cancel button 
     //The command will look just like the OK button command above. 
    } 
} 

Ahora, lo más probable es que desee que su ViewModel implemente INotifyPropertyChanged en caso de que tenga otros controles en su UI que se vincularán a las propiedades en ViewModel.

Espero que esto ayude ...

Answer 2

creo que todo el mundo que utiliza un IDialogService o en realidad crea sus propios cuadros de diálogo ha terminado el problema de ingeniería. Realmente me gusta el enfoque simplista de usar Funcs. Aquí hay un ejemplo. Primero se debe agregar esto a su modelo de vista:

public abstract class ViewModelBase : INotifyPropertyChanged 
{ 
    /** Other ViewModel Code *// 

    public Func<string, string, bool> OkCancelDialog { get; set; } 
} 

Luego, cuando se instancia la clase derivada de su modelo de vista, que acaba de adjuntar el siguiente código: (Me suelen hacer esto en el arranque como Program.cs)

var myVM = new SomeSuperViewModel(); 
myVM.OkCancelDialog = (msg, caption) => MessageBox.Show(msg, caption, MessageBoxButton.OkCancel) == MessageBoxResult.OK; 

En su código modelo de vista real, todo lo que tiene que hacer es llamar:

if (OkCancelDialog("Some crazy message.", "Caption")) 
    //do something if true 
else 
    //else do something if false 

En las pruebas unitarias se puede hacer esto:

var myVMToTest = new SomeSuperViewModel(); 
myVMToTest.OkCancelDialog = (msg, caption) => true; //could be false too if you need to test that functionality. 

Prefiero este enfoque, ya que es simple y fácil de probar. ¿Qué piensan los demás?

Answer 3

que te pueden echar un vistazo a la aplicación (EmailClient) muestra modelo de vista de la WPF Application Framework (WAF). Muestra cómo escribir diálogos personalizados con MVVM y muestra cómo puede usar el MessageBox sin violar el patrón de MVVM.

Answer 4

¿Qué pasa con sólo llamar System.Windows.MessageBox.Show() desde el código de su modelo de vista

por ejemplo,

public bool GetConfirmation(string Message, string Caption) 
{ return MessageBox.Show(Message, 
         Caption, 
         System.Windows.MessageBoxButton.OKCancel, 
         System.Windows.MessageBoxImage.Question, 
         System.Windows.MessageBoxResult.Cancel) == System.Windows.MessageBoxResult.OK; }