Đóng cửa sổ từ ViewModel

Tôi đang tạo Đăng nhập bằng cách sử dụng window controlđể cho phép người dùng đăng nhập vào WPFứng dụng mà tôi đang tạo.

Cho đến nay, tôi đã tạo ra một phương pháp kiểm tra xem liệu người dùng đã nhập đúng thông tin đăng nhập cho usernamevà passwordtrong một textboxtrên màn hình đăng nhập, bindinghai hay không properties.

Tôi đã đạt được điều này bằng cách tạo ra một boolphương pháp, như vậy;

public bool CheckLogin()
{
    var user = context.Users.Where(i => i.Username == this.Username).SingleOrDefault();

    if (user == null)
    {
        MessageBox.Show("Unable to Login, incorrect credentials.");
        return false;
    }
    else if (this.Username == user.Username || this.Password.ToString() == user.Password)
    {
        MessageBox.Show("Welcome " + user.Username + ", you have successfully logged in.");

        return true;
    }
    else
    {
        MessageBox.Show("Unable to Login, incorrect credentials.");
        return false;
    }
}

public ICommand ShowLoginCommand
{
    get
    {
        if (this.showLoginCommand == null)
        {
            this.showLoginCommand = new RelayCommand(this.LoginExecute, null);
        }
        return this.showLoginCommand;
    }
}

private void LoginExecute()
{
    this.CheckLogin();
} 

Tôi cũng có một nút commandmà tôi bindđể nút của tôi trong xamltương tự như vậy;

<Button Name="btnLogin" IsDefault="True" Content="Login" Command="{Binding ShowLoginCommand}" />

Khi tôi nhập tên người dùng và mật khẩu, nó sẽ thực thi mã đã chiếm đoạt, cho dù nó đúng hay sai. Nhưng làm cách nào để đóng cửa sổ này từ ViewModel khi cả tên người dùng và mật khẩu đều đúng?

Trước đây tôi đã thử sử dụng một dialog modalnhưng nó không hoàn toàn hiệu quả. Hơn nữa, trong app.xaml của tôi, tôi đã làm điều gì đó giống như sau, tải trang đăng nhập trước, sau đó khi đúng, tải ứng dụng thực tế.

private void ApplicationStart(object sender, StartupEventArgs e)
{
    Current.ShutdownMode = ShutdownMode.OnExplicitShutdown;

    var dialog = new UserView();

    if (dialog.ShowDialog() == true)
    {
        var mainWindow = new MainWindow();
        Current.ShutdownMode = ShutdownMode.OnMainWindowClose;
        Current.MainWindow = mainWindow;
        mainWindow.Show();
    }
    else
    {
        MessageBox.Show("Unable to load application.", "Error", MessageBoxButton.OK);
        Current.Shutdown(-1);
    }
}

Câu hỏi: Làm cách nào để đóng Đăng nhập Window controltừ ViewModel?

Cảm ơn trước.

Bạn có thể chuyển cửa sổ tới ViewModel của mình bằng cách sử dụng CommandParameter. Xem Ví dụ của tôi bên dưới.

Tôi đã triển khai một CloseWindowPhương pháp lấy Windows làm tham số và đóng nó. Cửa sổ được chuyển đến ViewModel qua CommandParameter. Lưu ý rằng bạn cần xác định một x:Namecửa sổ sẽ đóng. Trong Cửa sổ XAML của tôi, tôi gọi phương thức này thông qua Commandvà chuyển chính cửa sổ đó làm tham số cho ViewModel bằng cách sử dụng CommandParameter.

Command="{Binding CloseWindowCommand, Mode=OneWay}" 
CommandParameter="{Binding ElementName=TestWindow}"

ViewModel

public RelayCommand<Window> CloseWindowCommand { get; private set; }

public MainViewModel()
{
    this.CloseWindowCommand = new RelayCommand<Window>(this.CloseWindow);
}

private void CloseWindow(Window window)
{
    if (window != null)
    {
       window.Close();
    }
}

Lượt xem

<Window x:Class="ClientLibTestTool.ErrorView"
        x:Name="TestWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:localization="clr-namespace:ClientLibTestTool.ViewLanguages"
        DataContext="{Binding Main, Source={StaticResource Locator}}"
        Title="{x:Static localization:localization.HeaderErrorView}"
        Height="600" Width="800"
        ResizeMode="NoResize"
        WindowStartupLocation="CenterScreen">
    <Grid> 
        <Button Content="{x:Static localization:localization.ButtonClose}" 
                Height="30" 
                Width="100" 
                Margin="0,0,10,10" 
                IsCancel="True" 
                VerticalAlignment="Bottom" 
                HorizontalAlignment="Right" 
                Command="{Binding CloseWindowCommand, Mode=OneWay}" 
                CommandParameter="{Binding ElementName=TestWindow}"/>
    </Grid>
</Window>

Lưu ý rằng tôi đang sử dụng khung nhẹ MVVM, nhưng phần mềm chính áp dụng cho mọi ứng dụng wpf.

Giải pháp này vi phạm mẫu MVVM, vì mô hình xem không được biết bất kỳ điều gì về Triển khai giao diện người dùng. Nếu bạn muốn tuân thủ nghiêm ngặt mô hình lập trình MVVM, bạn phải tóm tắt kiểu xem với một giao diện.

Giải pháp phù hợp MVVM (EDIT2 cũ)

người dùng Crono đề cập đến một điểm hợp lệ trong phần bình luận:

Việc chuyển đối tượng Window vào mô hình xem sẽ phá vỡ IMHO của mẫu MVVM, vì nó buộc vm của bạn biết nó đang được xem trong gì.

Bạn có thể khắc phục điều này bằng cách giới thiệu một giao diện chứa phương thức đóng.

Giao diện:

public interface ICloseable
{
    void Close();
}

ViewModel được tái cấu trúc của bạn sẽ trông giống như sau:

ViewModel

public RelayCommand<ICloseable> CloseWindowCommand { get; private set; }

public MainViewModel()
{
    this.CloseWindowCommand = new RelayCommand<IClosable>(this.CloseWindow);
}

private void CloseWindow(ICloseable window)
{
    if (window != null)
    {
        window.Close();
    }
}

Bạn phải tham khảo và triển khai ICloseablegiao diện theo quan điểm của mình

Xem (Mã phía sau)

public partial class MainWindow : Window, ICloseable
{
    public MainWindow()
    {
        InitializeComponent();
    }
}

Câu trả lời cho câu hỏi ban đầu: (EDIT1 cũ)

Nút Đăng nhập của bạn (Đã thêm CommandParameter):

<Button Name="btnLogin" IsDefault="True" Content="Login" Command="{Binding ShowLoginCommand}" CommandParameter="{Binding ElementName=LoginWindow}"/>

Ma cua ban:

 public RelayCommand<Window> CloseWindowCommand { get; private set; } // the <Window> is important for your solution!

 public MainViewModel() 
 {
     //initialize the CloseWindowCommand. Again, mind the <Window>
     //you don't have to do this in your constructor but it is good practice, thought
     this.CloseWindowCommand = new RelayCommand<Window>(this.CloseWindow);
 }

 public bool CheckLogin(Window loginWindow) //Added loginWindow Parameter
 {
    var user = context.Users.Where(i => i.Username == this.Username).SingleOrDefault();

    if (user == null)
    {
        MessageBox.Show("Unable to Login, incorrect credentials.");
        return false;
    }
    else if (this.Username == user.Username || this.Password.ToString() == user.Password)
    {
        MessageBox.Show("Welcome "+ user.Username + ", you have successfully logged in.");
        this.CloseWindow(loginWindow); //Added call to CloseWindow Method
        return true;
    }
    else
    {
        MessageBox.Show("Unable to Login, incorrect credentials.");
        return false;
    }
 }

 //Added CloseWindow Method
 private void CloseWindow(Window window)
 {
     if (window != null)
     {
         window.Close();
     }
 }

Giữ nguyên MVVM, tôi nghĩ rằng việc sử dụng Behaviors từ Blend SDK (System.Windows.Interactivity) hoặc một yêu cầu tương tác tùy chỉnh từ Prism có thể hoạt động thực sự tốt cho loại tình huống này.

Nếu đi theo lộ trình Hành vi, đây là ý tưởng chung:

public class CloseWindowBehavior : Behavior<Window>
{
    public bool CloseTrigger
    {
        get { return (bool)GetValue(CloseTriggerProperty); }
        set { SetValue(CloseTriggerProperty, value); }
    }

    public static readonly DependencyProperty CloseTriggerProperty =
        DependencyProperty.Register("CloseTrigger", typeof(bool), typeof(CloseWindowBehavior), new PropertyMetadata(false, OnCloseTriggerChanged));

    private static void OnCloseTriggerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var behavior = d as CloseWindowBehavior;

        if (behavior != null)
        {
            behavior.OnCloseTriggerChanged();
        }
    }

    private void OnCloseTriggerChanged()
    {
        // when closetrigger is true, close the window
        if (this.CloseTrigger)
        {
            this.AssociatedObject.Close();
        }
    }
}

Sau đó, trong cửa sổ của bạn, bạn sẽ chỉ ràng buộc CloseTrigger với một giá trị boolean sẽ được đặt khi bạn muốn cửa sổ đóng lại.

<Window x:Class="TestApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
        xmlns:local="clr-namespace:TestApp"
        Title="MainWindow" Height="350" Width="525">
    <i:Interaction.Behaviors>
        <local:CloseWindowBehavior CloseTrigger="{Binding CloseTrigger}" />
    </i:Interaction.Behaviors>

    <Grid>

    </Grid>
</Window>

Cuối cùng, DataContext / ViewModel của bạn sẽ có một thuộc tính mà bạn đặt khi muốn đóng cửa sổ như sau:

public class MainWindowViewModel : INotifyPropertyChanged
{
    private bool closeTrigger;

    /// <summary>
    /// Gets or Sets if the main window should be closed
    /// </summary>
    public bool CloseTrigger
    {
        get { return this.closeTrigger; }
        set
        {
            this.closeTrigger = value;
            RaisePropertyChanged(nameof(CloseTrigger));
        }
    }

    public MainWindowViewModel()
    {
        // just setting for example, close the window
        CloseTrigger = true;
    }

    protected void RaisePropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

(đặt Window.DataContext = new MainWindowViewModel ())

Tôi thường đặt một sự kiện trên mô hình khung nhìn khi tôi cần làm điều này và sau đó nối nó với Window.Close()khi liên kết mô hình khung nhìn với cửa sổ

public class LoginViewModel
{
    public event EventHandler OnRequestClose;

    private void Login()
    {
        // Login logic here
        OnRequestClose(this, new EventArgs());
    }
}

Và khi tạo cửa sổ đăng nhập

var vm = new LoginViewModel();
var loginWindow = new LoginWindow
{
    DataContext = vm
};
vm.OnRequestClose += (s, e) => loginWindow.Close();

loginWindow.ShowDialog(); 

nó có thể muộn, nhưng đây là câu trả lời của tôi

foreach (Window item in Application.Current.Windows)
{
    if (item.DataContext == this) item.Close();
}

Đây là một cái gì đó tôi đã sử dụng trong một số dự án. Nó có thể trông giống như một vụ hack, nhưng nó hoạt động tốt.

public class AttachedProperties : DependencyObject //adds a bindable DialogResult to window
{
    public static readonly DependencyProperty DialogResultProperty = 
        DependencyProperty.RegisterAttached("DialogResult", typeof(bool?), typeof(AttachedProperties), 
        new PropertyMetaData(default(bool?), OnDialogResultChanged));

    public bool? DialogResult
    {
        get { return (bool?)GetValue(DialogResultProperty); }
        set { SetValue(DialogResultProperty, value); }
    }

    private static void OnDialogResultChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var window = d as Window;
        if (window == null)
            return;

        window.DialogResult = (bool?)e.NewValue;
    }
}

Bây giờ bạn có thể liên kết DialogResultvới một máy ảo và đặt giá trị của một thuộc tính. Các Windowsẽ đóng cửa, khi giá trị được thiết lập.

<!-- Assuming that the VM is bound to the DataContext and the bound VM has a property DialogResult -->
<Window someNs:AttachedProperties.DialogResult={Binding DialogResult} />

Đây là phần tóm tắt về những gì đang chạy trong môi trường sản xuất của chúng tôi

<Window x:Class="AC.Frontend.Controls.DialogControl.Dialog"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:DialogControl="clr-namespace:AC.Frontend.Controls.DialogControl" 
        xmlns:hlp="clr-namespace:AC.Frontend.Helper"
        MinHeight="150" MinWidth="300" ResizeMode="NoResize" SizeToContent="WidthAndHeight"
        WindowStartupLocation="CenterScreen" Title="{Binding Title}"
        hlp:AttachedProperties.DialogResult="{Binding DialogResult}" WindowStyle="ToolWindow" ShowInTaskbar="True"
        Language="{Binding UiCulture, Source={StaticResource Strings}}">
        <!-- A lot more stuff here -->
</Window>

Như bạn có thể thấy, tôi đang khai báo không gian tên xmlns:hlp="clr-namespace:AC.Frontend.Helper"trước và sau đó là ràng buộc hlp:AttachedProperties.DialogResult="{Binding DialogResult}".

Các AttachedPropertyngoại hình như thế này. Nó không giống như tôi đã đăng ngày hôm qua, nhưng IMHO nó sẽ không có bất kỳ ảnh hưởng nào.

public class AttachedProperties
{
    #region DialogResult

    public static readonly DependencyProperty DialogResultProperty =
        DependencyProperty.RegisterAttached("DialogResult", typeof (bool?), typeof (AttachedProperties), new PropertyMetadata(default(bool?), OnDialogResultChanged));

    private static void OnDialogResultChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var wnd = d as Window;
        if (wnd == null)
            return;

        wnd.DialogResult = (bool?) e.NewValue;
    }

    public static bool? GetDialogResult(DependencyObject dp)
    {
        if (dp == null) throw new ArgumentNullException("dp");

        return (bool?)dp.GetValue(DialogResultProperty);
    }

    public static void SetDialogResult(DependencyObject dp, object value)
    {
        if (dp == null) throw new ArgumentNullException("dp");

        dp.SetValue(DialogResultProperty, value);
    }

    #endregion
}

Cách dễ dàng

public interface IRequireViewIdentification
{
    Guid ViewID { get; }
}

Triển khai cho ViewModel

public class MyViewVM : IRequireViewIdentification
{
    private Guid _viewId;

    public Guid ViewID
    {
        get { return _viewId; }
    }

    public MyViewVM()
    {
        _viewId = Guid.NewGuid();
    }
}

Thêm trình trợ giúp trình quản lý cửa sổ chung

public static class WindowManager
{
    public static void CloseWindow(Guid id)
    {
        foreach (Window window in Application.Current.Windows)
        {
            var w_id = window.DataContext as IRequireViewIdentification;
            if (w_id != null && w_id.ViewID.Equals(id))
            {
                window.Close();
            }
        }
    }
}

Và đóng nó như thế này trong viewmodel

WindowManager.CloseWindow(ViewID);

Đây là một ví dụ đơn giản sử dụng MVVM Light Messenger thay vì một sự kiện. Mô hình chế độ xem sẽ gửi một thông báo đóng khi một nút được nhấp vào:

    public MainViewModel()
    {
        QuitCommand = new RelayCommand(ExecuteQuitCommand);
    }

    public RelayCommand QuitCommand { get; private set; }

    private void ExecuteQuitCommand() 
    {
        Messenger.Default.Send<CloseMessage>(new CloseMessage());
    }

Sau đó, nó được nhận trong mã phía sau của cửa sổ.

    public Main()
    {   
        InitializeComponent();
        Messenger.Default.Register<CloseMessage>(this, HandleCloseMessage);
    }

    private void HandleCloseMessage(CloseMessage closeMessage)
    {
        Close();
    }

Làm thế nào về điều này ?

ViewModel:

class ViewModel
{
    public Action CloseAction { get; set; }
    private void Stuff()
    {
       // Do Stuff
       CloseAction(); // closes the window
    }
}

Trong ViewModel của bạn, hãy sử dụng CloseAction () để đóng cửa sổ giống như trong ví dụ trên.

Lượt xem:

public View()
{
    InitializeComponent();
    ViewModel vm = new ViewModel (); // this creates an instance of the ViewModel
    this.DataContext = vm; // this sets the newly created ViewModel as the DataContext for the View
    if (vm.CloseAction == null)
        vm.CloseAction = new Action(() => this.Close());
}

Tôi biết đây là một bài viết cũ, có lẽ sẽ không ai di chuyển đến đây, tôi biết tôi đã không. Vì vậy, sau nhiều giờ thử các công cụ khác nhau, tôi tìm thấy blog này và anh bạn đã giết nó. Cách đơn giản nhất để làm điều này, đã thử và nó hoạt động như một sự quyến rũ.

Blog

Trong ViewModel:

...

public bool CanClose { get; set; }

private RelayCommand closeCommand;
public ICommand CloseCommand
{
    get
    {
        if(closeCommand == null)
        (
            closeCommand = new RelayCommand(param => Close(), param => CanClose);
        )
    }
}

public void Close()
{
    this.Close();
}

...

thêm thuộc tính Action vào ViewModel, nhưng xác định nó từ tệp mã phía sau của View. Điều này sẽ cho phép chúng tôi xác định động một tham chiếu trên ViewModel trỏ đến View.

Trên ViewModel, chúng tôi chỉ cần thêm:

public Action CloseAction { get; set; }

Và trên Chế độ xem, chúng tôi sẽ định nghĩa nó như sau:

public View()
{
    InitializeComponent() // this draws the View
    ViewModel vm = new ViewModel(); // this creates an instance of the ViewModel
    this.DataContext = vm; // this sets the newly created ViewModel as the DataContext for the View
    if ( vm.CloseAction == null )
        vm.CloseAction = new Action(() => this.Close());
}

Bạn có thể tạo trình xử lý Sự kiện mới trong ViewModel như thế này.

public event EventHandler RequestClose;

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

Sau đó xác định RelayCommand cho ExitCommand.

private RelayCommand _CloseCommand;
    public ICommand CloseCommand
    {
        get
        {
            if(this._CloseCommand==null)
                this._CloseCommand=new RelayCommand(CloseClick);
            return this._CloseCommand;
        }
    }

    private void CloseClick(object obj)
    {
        OnRequestClose();
    }

Sau đó, trong tập hợp tệp XAML

<Button Command="{Binding CloseCommand}" />

Đặt DataContext trong Tệp xaml.cs và Đăng ký sự kiện chúng tôi đã tạo.

public partial class MainWindow : Window
{
    private ViewModel mainViewModel = null;
    public MainWindow()
    {
        InitializeComponent();
        mainViewModel = new ViewModel();
        this.DataContext = mainViewModel;
        mainViewModel.RequestClose += delegate(object sender, EventArgs args) { this.Close(); };
    }
}

Cách phổ biến của tôi là Khai báo sự kiện trong ViewModel và sử dụng kết hợp InvokeMethodAction như bên dưới.

Chế độ xem mẫu

public class MainWindowViewModel : BindableBase, ICloseable
{
    public DelegateCommand SomeCommand { get; private set; }
    #region ICloseable Implementation
    public event EventHandler CloseRequested;        

    public void RaiseCloseNotification()
    {
        var handler = CloseRequested;
        if (handler != null)
        {
            handler.Invoke(this, EventArgs.Empty);
        }
    }
    #endregion

    public MainWindowViewModel()
    {
        SomeCommand = new DelegateCommand(() =>
        {
            //when you decide to close window
            RaiseCloseNotification();
        });
    }
}

Giao diện I Closable như bên dưới nhưng không yêu cầu thực hiện thao tác này. IClosable sẽ giúp tạo dịch vụ chế độ xem chung, vì vậy nếu bạn tạo chế độ xem và ViewModel bằng cách tiêm phụ thuộc thì những gì bạn có thể làm là

internal interface ICloseable
{
    event EventHandler CloseRequested;
}

Sử dụng IClosable

var viewModel = new MainWindowViewModel();
        // As service is generic and don't know whether it can request close event
        var window = new Window() { Content = new MainView() };
        var closeable = viewModel as ICloseable;
        if (closeable != null)
        {
            closeable.CloseRequested += (s, e) => window.Close();
        }

Và bên dưới là Xaml, Bạn có thể sử dụng xaml này ngay cả khi bạn không triển khai giao diện, nó sẽ chỉ cần mô hình khung nhìn của bạn để nâng CloseRquested.

<Window 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:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:WPFRx"
xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity" 
xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions" 
xmlns:ViewModels="clr-namespace:WPFRx.ViewModels" x:Name="window" x:Class="WPFRx.MainWindow"
    mc:Ignorable="d"
    Title="MainWindow" Height="350" Width="525" 
d:DataContext="{d:DesignInstance {x:Type ViewModels:MainWindowViewModel}}">

<i:Interaction.Triggers>
    <i:EventTrigger SourceObject="{Binding Mode=OneWay}" EventName="CloseRequested" >
        <ei:CallMethodAction TargetObject="{Binding ElementName=window}" MethodName="Close"/>
    </i:EventTrigger>
</i:Interaction.Triggers>

<Grid>
    <Button Content="Some Content" Command="{Binding SomeCommand}" Width="100" Height="25"/>
</Grid>

Bạn có thể sử dụng Messengertừ bộ công cụ MVVMLight. khi bạn ViewModelgửi một thông báo như thế này:
Messenger.Default.Send(new NotificationMessage("Close"));
sau đó trong mã cửa sổ của bạn phía sau, sau InitializeComponent, đăng ký cho thông báo đó như sau:

Messenger.Default.Register<NotificationMessage>(this, m=>{
    if(m.Notification == "Close") 
    {
        this.Close();
    }
   });

bạn có thể tìm thêm về bộ công cụ MVVMLight tại đây: Bộ công cụ MVVMLight trên Codeplex

Lưu ý rằng không có quy tắc "không có mã phía sau nào cả" trong MVVM và bạn có thể đăng ký các tin nhắn trong chế độ xem có mã phía sau.

Nó đơn giản. Bạn có thể tạo lớp ViewModel của riêng mình cho Đăng nhập - LoginViewModel. Bạn có thể tạo view var hộp thoại = new UserView (); bên trong LoginViewModel của bạn. Và bạn có thể thiết lập Command LoginCommand vào nút.

<Button Name="btnLogin" IsDefault="True" Content="Login" Command="{Binding LoginCommand}" />

và

<Button Name="btnCancel" IsDefault="True" Content="Login" Command="{Binding CancelCommand}" />

Lớp ViewModel:

public class LoginViewModel
{
    Window dialog;
    public bool ShowLogin()
    {
       dialog = new UserView();
       dialog.DataContext = this; // set up ViewModel into View
       if (dialog.ShowDialog() == true)
       {
         return true;
       }

       return false;
    }

    ICommand _loginCommand
    public ICommand LoginCommand
    {
        get
        {
            if (_loginCommand == null)
                _loginCommand = new RelayCommand(param => this.Login());

            return _loginCommand;
        }
    }

    public void CloseLoginView()
    {
            if (dialog != null)
          dialog.Close();
    }   

    public void Login()
    {
        if(CheckLogin()==true)
        {
            CloseLoginView();         
        }
        else
        {
          // write error message
        }
    }

    public bool CheckLogin()
    {
      // ... check login code
      return true;
    }
}

Đây là một cách tôi đã làm khá đơn giản:

YourWindow.xaml.cs

//In your constructor
public YourWindow()
{
    InitializeComponent();
    DataContext = new YourWindowViewModel(this);
}

YourWindowViewModel.cs

private YourWindow window;//so we can kill the window

//In your constructor
public YourWindowViewModel(YourWindow window)
{
    this.window = window;
}

//to close the window
public void CloseWindow()
{
    window.Close();
}

Tôi không thấy có gì sai với câu trả lời bạn đã chọn, tôi chỉ nghĩ rằng đây có thể là một cách đơn giản hơn để làm điều đó!

Bạn có thể coi cửa sổ như một dịch vụ (ví dụ: dịch vụ giao diện người dùng) và chuyển chính nó sang chế độ xem thông qua một giao diện , chẳng hạn như:

public interface IMainWindowAccess
{
    void Close(bool result);
}

public class MainWindow : IMainWindowAccess
{
    // (...)
    public void Close(bool result)
    {
        DialogResult = result;
        Close();
    }
}

public class MainWindowViewModel
{
    private IMainWindowAccess access;

    public MainWindowViewModel(IMainWindowAccess access)
    {
        this.access = access;
    }

    public void DoClose()
    {
        access.Close(true);
    }
}

Giải pháp này có hầu hết các mặt lợi của việc tự chuyển chế độ xem sang chế độ xem mà không có nhược điểm là phá vỡ MVVM, bởi vì mặc dù chế độ xem vật lý được chuyển sang chế độ xem, nhưng cái sau vẫn không biết về cái trước, nó chỉ thấy một số IMainWindowAccess. Vì vậy, ví dụ: nếu chúng tôi muốn di chuyển giải pháp này sang nền tảng khác, nó sẽ chỉ là vấn đề triển khai IMainWindowAccessđúng cách cho, ví dụ, một Activity.

Tôi đăng giải pháp ở đây để đề xuất một cách tiếp cận khác với các sự kiện (mặc dù nó thực sự rất giống nhau), bởi vì nó có vẻ đơn giản hơn một chút so với các sự kiện để triển khai (đính kèm / tách rời, v.v.), nhưng vẫn phù hợp tốt với mẫu MVVM.

Bạn có thể đóng cửa sổ hiện tại chỉ bằng cách sử dụng mã sau:

Application.Current.Windows[0].Close();

System.Enosystem.Exit (0); trong chế độ xem mô hình sẽ hoạt động.