Come posso uscire da un'applicazione WPF a livello di codice?

In pochi anni ho usato C # (Windows Forms), non ho mai usato WPF. Ma ora adoro WPF, ma non so come dovrei uscire dalla mia applicazione quando l'utente fa clic sulla voce di menu Esci dal menu File.

Ho provato:

this.Dispose();
this.Exit();
Application.ShutDown();
Application.Exit();
Application.Dispose();

Tra molti altri. Niente funziona.

Per uscire dall'applicazione è possibile chiamare

System.Windows.Application.Current.Shutdown();

Come descritto nella documentazione del Application.Shutdownmetodo, è anche possibile modificare il comportamento di arresto dell'applicazione specificando un ShutdownMode :

L'arresto viene chiamato implicitamente da Windows Presentation Foundation (WPF) nelle seguenti situazioni:

• Quando ShutdownMode è impostato su OnLastWindowClose.
• Quando ShutdownMode è impostato su OnMainWindowClose.
• Quando un utente termina una sessione e l'evento SessionEnding non viene gestito o gestito senza annullamento.

Si noti inoltre che Application.Current.Shutdown();può essere chiamato solo dal thread che ha creato l' Applicationoggetto, ovvero normalmente il thread principale.

Se ne hai davvero bisogno per chiudere puoi anche usare Environment.Exit () , ma non è affatto grazioso (più come terminare il processo).

Usalo come segue:

Environment.Exit(0)

Come ha detto wuminqi , Application.Current.Shutdown();è irreversibile e credo che sia in genere utilizzato per forzare la chiusura di un'applicazione in momenti come quando un utente si disconnette o chiude Windows.

Invece, chiama this.close()nella finestra principale. Ciò equivale a premere Alt+ F4o il pulsante di chiusura [x] sulla finestra. Ciò causerà la chiusura di tutte le altre finestre di proprietà e terminerà la chiamata Application.Current.Shutdown();fino a quando l'azione di chiusura non verrà annullata. Consultare la documentazione MSDN su Chiusura di una finestra .

Anche perchè this.close() è cancellabile, è possibile inserire una finestra di dialogo di conferma delle modifiche nel gestore eventi di chiusura. È sufficiente creare un gestore eventi <Window Closing="...">e modificarlo di e.Cancelconseguenza. (Vedi la documentazione MSDN per maggiori dettagli su come farlo.)

Utilizzare uno dei seguenti come necessario:

1.

 App.Current.Shutdown();
OR
 Application.Current.Shutdown();

2.

 App.Current.MainWindow.Close();
OR
 Application.Current.MainWindow.Close();

Soprattutto i metodi chiameranno closing eventdi Windowclasse e l'esecuzione potrebbe interrompersi ad un certo punto (perché di solito le applicazioni inseriscono dialoghi come 'ne sei sicuro?' O ' Vuoi salvare i dati prima di chiudere? ', Prima che una finestra venga chiusa completamente)

3. Ma se si desidera terminare l'applicazione senza alcun avviso immediatamente. Usa sotto

   Environment.Exit(0);

Questo dovrebbe fare il trucco:

Application.Current.Shutdown();

Se sei interessato, ecco del materiale aggiuntivo che ho trovato utile:

Dettagli su Application.Current

Ciclo di vita dell'applicazione WPF

Ecco come faccio il mio:

// Any control that causes the Window.Closing even to trigger.
private void MenuItemExit_Click(object sender, RoutedEventArgs e)
{
    this.Close();
}

// Method to handle the Window.Closing event.
private void Window_Closing(object sender, CancelEventArgs e)
{
    var response = MessageBox.Show("Do you really want to exit?", "Exiting...",
                                   MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
    if (response == MessageBoxResult.No)
    {
        e.Cancel = true;
    }
    else
    {
        Application.Current.Shutdown();
    }
}

Chiedo solo Application.Current.ShutDown()dalla finestra principale dell'applicazione, tutte le altre finestre usanothis.Close() . Nella mia finestra principale, Window_Closing(...)gestisce il xpulsante in alto a destra . Se uno dei metodi richiede la chiusura della finestra, Window_Closing(...)cattura l'evento per chiudere se l'utente conferma.

La ragione per cui lo faccio, infatti Application.Current.Shutdown() nella mia finestra principale è che ho notato che se si è verificato un errore di progettazione e non ho dichiarato un genitore di una delle mie finestre in un'applicazione, se quella finestra viene aperta senza essere mostrata prima all'ultima chiusura attiva della finestra, mi rimane una finestra nascosta in esecuzione in background. L'applicazione non si chiuderà. L'unico modo per impedire la completa perdita di memoria è per me andare nel Task Manager per chiudere l'applicazione. Application.Current.Shutdown()mi protegge da difetti di progettazione involontari.

Questo proviene dalla mia esperienza personale. Alla fine, usa ciò che è meglio per il tuo scenario. Questa è solo un'altra informazione.

Non ci dovrebbe essere un messaggio Application.ShutDown();o .Exit().

Applicationè una classe statica. Non si riferisce all'applicazione corrente. Devi arrivare all'applicazione corrente e quindi spegnerla in questo modo:

Application.Current.Shutdown();

Un altro modo per farlo:

System.Diagnostics.Process.GetCurrentProcess().Kill();

Questo forzerà l'uccisione della tua applicazione. Funziona sempre, anche in un'applicazione multi-thread.

Nota: fai solo attenzione a non perdere i dati non salvati in un altro thread.

private void _MenuExit_Click(object sender, RoutedEventArgs e)
{
   System.Windows.Application.Current.MainWindow.Close();
}

//Override the onClose method in the Application Main window

protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
{
    MessageBoxResult result =   MessageBox.Show("Do you really want to close", "",
                                          MessageBoxButton.OKCancel);
    if (result == MessageBoxResult.Cancel)
    {
       e.Cancel = true;
    }
    base.OnClosing(e);
}

Provare

App.Current.Shutdown();

Per me

Application.Current.Shutdown(); 

non ha funzionato.

Secondo la mia comprensione, Application.Current.Shutdown()ha anche il suo svantaggio.

Se si desidera mostrare una finestra di conferma per consentire agli utenti di confermare all'uscita o meno, Application.Current.Shutdown()è irreversibile.

Riassumendo, ci sono alcuni modi per farlo.

1) Killing the process, che salta la finalizzazione, la gestione degli errori ecc .:

Process.GetCurrentProcess().Kill();

2) Chiudere l'applicazione corrente, che è probabilmente il modo corretto perché chiama gli eventi di uscita:

Application.Current.Shutdown();

o

this.Shutdown();

(quando clled in un'istanza di classe App)

3) Chiusura dell'app corrente (tutti i moduli devono essere chiusi / completati in precedenza):

this.Close(); 

(quando clled in un'istanza di classe App)

4) Uscita dall'ambiente, che termina l'app:

Environment.Exit(0);

Inoltre, potresti voler leggere qui le statistiche di uscita

Caliburn micro aromatizzato

public class CloseAppResult : CancelResult
{
    public override void Execute(CoroutineExecutionContext context)
    {
        Application.Current.Shutdown();
        base.Execute(context);
    }
}

public class CancelResult : Result
{
    public override void Execute(CoroutineExecutionContext context)
    {
        OnCompleted(this, new ResultCompletionEventArgs { WasCancelled = true });
    }
}

Se si desidera uscire da un altro thread che non ha creato l'oggetto applicazione, utilizzare:

System.Windows.Application.Current.Dispatcher.InvokeShutdown();

Application.Current.ShutdownMode = ShutdownMode.OnExplicitShutdown;

Dal codice xaml puoi chiamare un SystemCommand predefinito:

Command="SystemCommands.MinimizeWindowCommand"

Penso che questo dovrebbe essere il modo preferito ...