การจัดการเหตุการณ์การปิดหน้าต่างด้วย WPF / MVVM Light Toolkit

ฉันต้องการจัดการ Closingกิจกรรม (เมื่อผู้ใช้คลิกปุ่ม 'X' ด้านขวาบน) ของหน้าต่างของฉันเพื่อแสดงข้อความยืนยันหรือ / และยกเลิกการปิดท้าย

ฉันรู้วิธีการทำเช่นนี้ในโค้ด - เบื้องหลัง: สมัครสมาชิกกับClosingเหตุการณ์ของหน้าต่างจากนั้นใช้CancelEventArgs.Cancelคุณสมบัติ

แต่ฉันใช้ MVVM ฉันไม่แน่ใจว่ามันเป็นแนวทางที่ดี

ฉันคิดว่าวิธีการที่ดีคือการผูกClosingกิจกรรมไว้Commandใน ViewModel ของฉัน

ฉันลองแล้ว:

<i:Interaction.Triggers>
    <i:EventTrigger EventName="Closing">
        <cmd:EventToCommand Command="{Binding CloseCommand}" />
    </i:EventTrigger>
</i:Interaction.Triggers>

ด้วยการเชื่อมโยงRelayCommandใน ViewModel ของฉัน แต่มันไม่ทำงาน (รหัสของคำสั่งไม่ได้ถูกเรียกใช้)

ฉันเพียงแค่เชื่อมโยงตัวจัดการในตัวสร้างมุมมอง:

MyWindow() 
{
    // Set up ViewModel, assign to DataContext etc.
    Closing += viewModel.OnWindowClosing;
}

จากนั้นเพิ่มตัวจัดการไปที่ViewModel:

using System.ComponentModel;

public void OnWindowClosing(object sender, CancelEventArgs e) 
{
   // Handle closing logic, set e.Cancel as needed
}

ในกรณีนี้คุณจะไม่ได้รับอะไรนอกจากความซับซ้อนโดยใช้รูปแบบที่ซับซ้อนมากขึ้นพร้อมกับการอ้อมมากขึ้น (XAML เพิ่มอีก 5 บรรทัดCommand)

"ศูนย์ behind รหัส" มนต์ไม่ได้เป็นเป้าหมายในตัวเองชี้คือการแยก ViewModel จากมุมมอง แม้เมื่อมีเหตุการณ์ที่ถูกผูกไว้ในรหัสที่อยู่เบื้องหลังของการดูที่ViewModelไม่ได้ขึ้นอยู่กับมุมมองและตรรกะปิดสามารถเป็นหน่วยทดสอบ

รหัสนี้ใช้งานได้ดี:

ViewModel.cs:

public ICommand WindowClosing
{
    get
    {
        return new RelayCommand<CancelEventArgs>(
            (args) =>{
                     });
    }
}

และใน XAML:

<i:Interaction.Triggers>
    <i:EventTrigger EventName="Closing">
        <command:EventToCommand Command="{Binding WindowClosing}" PassEventArgsToCommand="True" />
    </i:EventTrigger>
</i:Interaction.Triggers>

สมมติว่า:

• ViewModel ถูกกำหนดให้DataContextกับคอนเทนเนอร์หลัก
• xmlns:command="clr-namespace:GalaSoft.MvvmLight.Command;assembly=GalaSoft.MvvmLight.Extras.SL5"
• xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

ตัวเลือกนี้ง่ายยิ่งขึ้นและอาจเหมาะสำหรับคุณ ในตัวสร้างมุมมองโมเดลของคุณคุณสามารถติดตามเหตุการณ์การปิดหน้าต่างหลักเช่นนี้:

Application.Current.MainWindow.Closing += new CancelEventHandler(MainWindow_Closing);

void MainWindow_Closing(object sender, CancelEventArgs e)
{
            //Your code to handle the event
}

ทั้งหมดที่ดีที่สุด

นี่คือคำตอบตามรูปแบบ MVVM หากคุณไม่ต้องการรู้เกี่ยวกับหน้าต่าง (หรือเหตุการณ์ใด ๆ ) ใน ViewModel

public interface IClosing
{
    /// <summary>
    /// Executes when window is closing
    /// </summary>
    /// <returns>Whether the windows should be closed by the caller</returns>
    bool OnClosing();
}

ใน ViewModel ให้เพิ่มส่วนต่อประสานและการใช้งาน

public bool OnClosing()
{
    bool close = true;

    //Ask whether to save changes och cancel etc
    //close = false; //If you want to cancel close

    return close;
}

ในหน้าต่างฉันเพิ่มเหตุการณ์การปิด โค้ดด้านหลังนี้ไม่ทำลายรูปแบบ MVVM มุมมองสามารถรู้เกี่ยวกับมุมมองโมเดล!

void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
    IClosing context = DataContext as IClosing;
    if (context != null)
    {
        e.Cancel = !context.OnClosing();
    }
}

Geez ดูเหมือนว่าจะมีรหัสมากมายเกิดขึ้นที่นี่สำหรับเรื่องนี้ Stas ด้านบนมีวิธีการที่เหมาะสมสำหรับความพยายามน้อยที่สุด นี่คือการปรับตัวของฉัน (โดยใช้ MVVMLight แต่ควรเป็นที่จดจำได้) ... โอ้และPassEventArgsToCommand = "True"นั้นแน่นอนสิ่งจำเป็นยิ่งตามที่ระบุไว้ข้างต้น

(ให้เครดิตกับ Laurent Bugnion http://blog.galasoft.ch/archive/2009/10/18/clean-shutdown-in-silverlight-and-wpf-applications.aspx )

   ... MainWindow Xaml
   ...
   WindowStyle="ThreeDBorderWindow" 
    WindowStartupLocation="Manual">



<i:Interaction.Triggers>
    <i:EventTrigger EventName="Closing">
        <cmd:EventToCommand Command="{Binding WindowClosingCommand}" PassEventArgsToCommand="True" />
    </i:EventTrigger>
</i:Interaction.Triggers> 

ในรูปแบบมุมมอง:

///<summary>
///  public RelayCommand<CancelEventArgs> WindowClosingCommand
///</summary>
public RelayCommand<CancelEventArgs> WindowClosingCommand { get; private set; }
 ...
 ...
 ...
        // Window Closing
        WindowClosingCommand = new RelayCommand<CancelEventArgs>((args) =>
                                                                      {
                                                                          ShutdownService.MainWindowClosing(args);
                                                                      },
                                                                      (args) => CanShutdown);

ใน ShutdownService

    /// <summary>
    ///   ask the application to shutdown
    /// </summary>
    public static void MainWindowClosing(CancelEventArgs e)
    {
        e.Cancel = true;  /// CANCEL THE CLOSE - let the shutdown service decide what to do with the shutdown request
        RequestShutdown();
    }

RequestShutdown มีลักษณะเหมือนดังต่อไปนี้ แต่โดยทั่วไปแล้วขอShutdownหรืออะไรก็ตามที่มีชื่อจะตัดสินใจว่าจะปิดแอปพลิเคชันหรือไม่ (ซึ่งจะปิดหน้าต่างอย่างสนุกสนาน):

...
...
...
    /// <summary>
    ///   ask the application to shutdown
    /// </summary>
    public static void RequestShutdown()
    {

        // Unless one of the listeners aborted the shutdown, we proceed.  If they abort the shutdown, they are responsible for restarting it too.

        var shouldAbortShutdown = false;
        Logger.InfoFormat("Application starting shutdown at {0}...", DateTime.Now);
        var msg = new NotificationMessageAction<bool>(
            Notifications.ConfirmShutdown,
            shouldAbort => shouldAbortShutdown |= shouldAbort);

        // recipients should answer either true or false with msg.execute(true) etc.

        Messenger.Default.Send(msg, Notifications.ConfirmShutdown);

        if (!shouldAbortShutdown)
        {
            // This time it is for real
            Messenger.Default.Send(new NotificationMessage(Notifications.NotifyShutdown),
                                   Notifications.NotifyShutdown);
            Logger.InfoFormat("Application has shutdown at {0}", DateTime.Now);
            Application.Current.Shutdown();
        }
        else
            Logger.InfoFormat("Application shutdown aborted at {0}", DateTime.Now);
    }
    }

ผู้ถามควรใช้คำตอบ STAS แต่สำหรับผู้อ่านที่ใช้ปริซึมและไม่มี galasoft / mvvmlight พวกเขาอาจต้องการลองสิ่งที่ฉันใช้:

ในคำจำกัดความที่ด้านบนสุดสำหรับหน้าต่างหรือผู้ใช้ควบคุม ฯลฯ กำหนด namespace:

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

และใต้คำจำกัดความนั้น:

<i:Interaction.Triggers>
        <i:EventTrigger EventName="Closing">
            <i:InvokeCommandAction Command="{Binding WindowClosing}" CommandParameter="{Binding}" />
        </i:EventTrigger>
</i:Interaction.Triggers>

อสังหาริมทรัพย์ในมุมมองโมเดลของคุณ:

public ICommand WindowClosing { get; private set; }

แนบผู้แทนคำแนะนำในตัวสร้างมุมมองโมเดลของคุณ:

this.WindowClosing = new DelegateCommand<object>(this.OnWindowClosing);

ในที่สุดโค้ดของคุณที่คุณต้องการเข้าถึงใกล้กับส่วนควบคุม / หน้าต่าง / อะไรก็ตาม:

private void OnWindowClosing(object obj)
        {
            //put code here
        }

ฉันจะถูกล่อลวงให้ใช้ตัวจัดการเหตุการณ์ภายในไฟล์ App.xaml.cs ของคุณซึ่งจะช่วยให้คุณตัดสินใจได้ว่าจะปิดแอปพลิเคชันหรือไม่

ตัวอย่างเช่นคุณสามารถมีรหัสต่อไปนี้ในไฟล์ App.xaml.cs ของคุณ:

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
    // Create the ViewModel to attach the window to
    MainWindow window = new MainWindow();
    var viewModel = new MainWindowViewModel();

    // Create the handler that will allow the window to close when the viewModel asks.
    EventHandler handler = null;
    handler = delegate
    {
        //***Code here to decide on closing the application****
        //***returns resultClose which is true if we want to close***
        if(resultClose == true)
        {
            viewModel.RequestClose -= handler;
            window.Close();
        }
    }
    viewModel.RequestClose += handler;

    window.DataContaxt = viewModel;

    window.Show();

}

จากนั้นภายในรหัส MainWindowViewModel ของคุณคุณสามารถมีสิ่งต่อไปนี้:

#region Fields
RelayCommand closeCommand;
#endregion

#region CloseCommand
/// <summary>
/// Returns the command that, when invoked, attempts
/// to remove this workspace from the user interface.
/// </summary>
public ICommand CloseCommand
{
    get
    {
        if (closeCommand == null)
            closeCommand = new RelayCommand(param => this.OnRequestClose());

        return closeCommand;
    }
}
#endregion // CloseCommand

#region RequestClose [event]

/// <summary>
/// Raised when this workspace should be removed from the UI.
/// </summary>
public event EventHandler RequestClose;

/// <summary>
/// If requested to close and a RequestClose delegate has been set then call it.
/// </summary>
void OnRequestClose()
{
    EventHandler handler = this.RequestClose;
    if (handler != null)
    {
        handler(this, EventArgs.Empty);
    }
}

#endregion // RequestClose [event]

โดยทั่วไปเหตุการณ์หน้าต่างอาจไม่ได้รับมอบหมายให้ MVVM โดยทั่วไปปุ่มปิดแสดงกล่องโต้ตอบเพื่อถามผู้ใช้ "บันทึก: ใช่ / ไม่ใช่ / ยกเลิก" และ MVVM อาจไม่สามารถทำได้

คุณอาจให้ตัวจัดการเหตุการณ์ OnClosing ซึ่งคุณเรียกใช้ Model.Close.CanExecute () และตั้งค่าผลลัพธ์บูลีนในคุณสมบัติเหตุการณ์ ดังนั้นหลังจากการเรียก CanExecute () ถ้าเป็นจริงหรือในเหตุการณ์ OnClosed ให้เรียก Model.Close.Execute ()

ฉันไม่ได้ทำการทดสอบมากนัก แต่ดูเหมือนว่าจะใช้งานได้ นี่คือสิ่งที่ฉันมาด้วย:

namespace OrtzIRC.WPF
{
    using System;
    using System.Windows;
    using OrtzIRC.WPF.ViewModels;

    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        private MainViewModel viewModel = new MainViewModel();
        private MainWindow window = new MainWindow();

        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            viewModel.RequestClose += ViewModelRequestClose;

            window.DataContext = viewModel;
            window.Closing += Window_Closing;
            window.Show();
        }

        private void ViewModelRequestClose(object sender, EventArgs e)
        {
            viewModel.RequestClose -= ViewModelRequestClose;
            window.Close();
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            window.Closing -= Window_Closing;
            viewModel.RequestClose -= ViewModelRequestClose; //Otherwise Close gets called again
            viewModel.CloseCommand.Execute(null);
        }
    }
}

เราใช้ AttachedCommandBehavior สำหรับสิ่งนี้ คุณสามารถแนบเหตุการณ์ใด ๆ กับคำสั่งในรูปแบบมุมมองของคุณหลีกเลี่ยงรหัสใด ๆ ที่อยู่เบื้องหลัง

เราใช้มันตลอดการแก้ปัญหาของเราและมีโค้ดเกือบเป็นศูนย์

http://marlongrech.wordpress.com/2008/12/13/attachedcommandbehavior-v2-aka-acb/

การใช้ชุดเครื่องมือ MVVM Light:

สมมติว่ามีคำสั่งExitในรูปแบบมุมมอง:

ICommand _exitCommand;
public ICommand ExitCommand
{
    get
    {
        if (_exitCommand == null)
            _exitCommand = new RelayCommand<object>(call => OnExit());
        return _exitCommand;
    }
}

void OnExit()
{
     var msg = new NotificationMessageAction<object>(this, "ExitApplication", (o) =>{});
     Messenger.Default.Send(msg);
}

สิ่งนี้ได้รับในมุมมอง:

Messenger.Default.Register<NotificationMessageAction<object>>(this, (m) => if (m.Notification == "ExitApplication")
{
     Application.Current.Shutdown();
});

ในทางกลับกันฉันจัดการกับClosingเหตุการณ์MainWindowโดยใช้อินสแตนซ์ของ ViewModel:

private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{ 
    if (((ViewModel.MainViewModel)DataContext).CancelBeforeClose())
        e.Cancel = true;
}

CancelBeforeClose ตรวจสอบสถานะปัจจุบันของมุมมองรูปแบบและคืนค่าจริงถ้าปิดควรหยุด

หวังว่าจะช่วยใครซักคน

private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    {
        MessageBox.Show("closing");
    }