La mise en œuvre de “fermer la fenêtre” commande avec MVVM

Vous n'avez pas besoin de passer à l'instance de Vue de votre couche ViewModel. Vous pouvez accéder à la fenêtre principale, ce

Application.Current.MainWindow.Close()

Je ne vois pas de problème à accéder à votre fenêtre principale dans le ViewModel de la classe comme indiqué ci-dessus. Comme par MVVM le principe, il ne devrait pas être un couplage étroit entre votre point de Vue et ViewModel c'est à dire ils devraient être conscient de autres opérations. Ici, nous ne sommes pas passer quelque chose à ViewModel de la Vue. Si vous voulez chercher d'autres options de ce qui pourrait vous aider - Fermer la fenêtre en utilisant MVVM

Ma solution pour fermer une fenêtre de la vue modèle en cliquant sur un bouton comme suit:

Dans le modèle de vue

public RelayCommand CloseWindow;
Constructor()
{
    CloseWindow = new RelayCommand(CloseWin);
}

public void CloseWin(object obj)
{
    Window win = obj as Window;
    win.Close();
}

En Vue, définie comme suit

<Button Command="{Binding CloseWindowCommand}" CommandParameter="{Binding ElementName=WindowNameTobeClose}" Content="Cancel" />

Watch out pour la mode paradigmes. MVVM peut être utile, mais vous ne devriez vraiment pas le traiter comme un ensemble de règles rigides. Utilisez votre propre jugement, et quand il ne fait pas de sens - ne l'utilisez pas.

Les solutions proposées ici (à l'exception de @RV1987 de la solution) sont un très bon exemple que les choses sortir de la main. Vous remplacez un seul Close() appel avec une telle quantité énorme de code, pour quel but? Vous gagnez absolument rien de déplacer le code de fermeture de la vue à la vue-modèle. La seule chose que vous gagnez de la place pour plus de bugs.

Maintenant, je ne dis pas que MVVM est d'être ignoré. Bien au contraire, il peut être très utile. Il suffit de ne pas trop le faire.

Cette solution est rapide et facile. Inconvénient, c'est qu'il y a de couplage entre les couches.

Dans votre viewmodel:

public class MyWindowViewModel: ViewModelBase
{


    public Command.StandardCommand CloseCommand
    {
        get
        {
            return new Command.StandardCommand(Close);
        }
    }
    public void Close()
    {
        foreach (System.Windows.Window window in System.Windows.Application.Current.Windows)
        {
            if (window.DataContext == this)
            {
                window.Close();
            }
        }
    }
}

Ceci est très similaire à eoldre de réponse. Il est fonctionnellement identique dans la mesure où il regarde dans la même collection Windows une fenêtre qui a le modèle de vue que son datacontext; mais j'ai utilisé un RelayCommand et certains LINQ pour obtenir le même résultat.

public RelayCommand CloseCommand
{
    get
    {
        return new RelayCommand(() => Application.Current.Windows
            .Cast<Window>()
            .Single(w => w.DataContext == this)
            .Close());
    }
}

Ceci est pris à partir de ken2k réponse (merci!), tout ajout de la CloseCommand également à la base CloseableViewModel.

public class CloseableViewModel
{
    public CloseableViewModel()
    {
        CloseCommand = new RelayCommand(this.OnClosingRequest);
    }

    public event EventHandler ClosingRequest;

    protected void OnClosingRequest()
    {
        if (this.ClosingRequest != null)
        {
            this.ClosingRequest(this, EventArgs.Empty);
        }
    }

    public RelayCommand CloseCommand
    {
        get;
        private set;
    }
}

Votre modèle de vue, il hérite

public class MyViewModel : CloseableViewModel

En vue

public MyView()
{
    var viewModel = new StudyDataStructureViewModel(studyId);
    this.DataContext = viewModel;

    //InitializeComponent(); ...

    viewModel.ClosingRequest += (sender, e) => this.Close();
}

tout d'abord de donner à votre fenêtre un nom comme

x:Name="AboutViewWindow"

sur mon bouton fermer j'ai défini le Commandement et le Paramètre de Commande comme

CommandParameter="{Binding ElementName=AboutViewWindow}"
Command="{Binding CancelCommand}"

alors de mon point de vue modèle

private ICommand _cancelCommand;        
public ICommand CancelCommand       
{
   get          
     {
        if (_cancelCommand == null)
           {
              _cancelCommand = new DelegateCommand<Window>(
                    x =>
                    {
                        x?.Close();
                    });
            }

            return _cancelCommand;          
     }      
}