Esci dall'applicazione console in C#

Per terminare un’applicazione console in C# al termine del suo lavoro, restituisci il controllo da Main. Chiama il metodo Environment.Exit() solo quando il processo deve essere arrestato immediatamente da un altro metodo. Restituire un intero da Main o passarlo a Environment.Exit(int) fornisce il codice di uscita del processo; il testo scritto nella console è distinto da quel codice.

Restituire il controllo da Main per terminare l’applicazione

Un’istruzione return termina il metodo corrente. Quando termina Main, l’esecuzione normale dell’applicazione finisce e le istruzioni successive a return non vengono eseguite. Un return in un metodo annidato restituisce soltanto il controllo al chiamante, quindi da solo non termina l’applicazione. Per concludere normalmente, preferisci restituire il controllo da Main: il flusso di controllo resta quello consueto e permette l’esecuzione dei blocchi finally circostanti e la pulizia delle risorse.

Un void Main() può usare return; per terminare senza restituire un valore. Un int Main() può restituire un codice di uscita. Questo esempio completo stampa una riga di stato e restituisce il codice convenzionale di successo. L’osservazione di runtime fornita ha prodotto Work completed. e il codice di uscita 0.

Esegui questo esempio:

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

using System;

class Program
{
    static int Main()
    {
        Console.WriteLine("Work completed.");
        return 0;
    }
}

Work completed.

return 0; termina Main e il sistema operativo o il processo chiamante riceve 0. Se devi segnalare un errore, restituisci invece un codice diverso da zero. Il significato preciso di ciascun valore diverso da zero è stabilito dal programma o da chi lo richiama.

Usare Environment.Exit() per terminare da qualsiasi metodo

Environment.Exit(int) può terminare il processo da un metodo diverso da Main. Arresta immediatamente il processo con il codice di uscita intero specificato e non restituisce il controllo al chiamante. Riserva questo metodo ai casi in cui non è possibile seguire il normale percorso di uscita, per esempio quando si vuole deliberatamente arrestare subito il processo; in genere, la normale gestione degli errori dovrebbe segnalare il problema e restituire da Main un codice appropriato.

Questo esempio completo chiama Environment.Exit(0) da StopApplication, un metodo diverso da Main:

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

using System;

class Program
{
    static void Main()
    {
        StopApplication();
        Console.WriteLine("This line is not reached.");
    }

    static void StopApplication()
    {
        Console.WriteLine("Stopping now.");
        Environment.Exit(0);
    }
}

La chiamata specifica il codice di uscita 0 e termina il processo prima che StopApplication restituisca il controllo, quindi l’esecuzione non raggiunge mai la riga successiva in Main. L’osservazione di runtime fornita riguarda l’esempio con Main qui sopra, non questo esempio. Una chiamata come Environment.Exit(1); specifica invece il codice di uscita 1: l’intero viene passato al sistema operativo o al processo chiamante, mentre gli eventuali messaggi stampati con Console.WriteLine restano testo separato nella console. Il metodo è statico in System.Environment, quindi un file che usa using System; può chiamarlo direttamente.

Scegliere un codice di uscita e capire cosa succede alla pulizia

Per convenzione, usa 0 per indicare il successo e un valore diverso da zero per indicare un errore. Si tratta di convenzioni, non di una corrispondenza universale valida per ogni applicazione: documenta i codici che uno script, un gestore di servizi o un altro chiamante deve interpretare. Sia restituire un intero da Main sia chiamare Environment.Exit(int) comunica il codice di uscita del processo. Nessuno dei due valori viene stampato automaticamente; se una persona deve conoscere la spiegazione, stampa un messaggio diagnostico separato.

Preferisci restituire il controllo da Main quando il programma può terminare normalmente. Il normale ritorno da un metodo permette l’esecuzione dei blocchi finally quando il controllo esce dalle rispettive istruzioni try; inoltre, le risorse con ambito limitato, come quelle dichiarate con using, possono essere rilasciate al termine del loro ambito. Environment.Exit() arresta subito il processo, senza il normale svolgimento dello stack: i blocchi finally in attesa e la pulizia gestita vengono saltati. Prima di un arresto immediato, svuota o chiudi le risorse importanti seguendo il normale flusso di controllo ed evita questo metodo se la pulizia è necessaria per salvare i dati o rilasciare risorse.

Distinguere la terminazione del processo da break, eccezioni e Ctrl+C

Un’istruzione break esce dal ciclo o dallo switch più vicino; l’esecuzione continua dopo quel costrutto. Se uscire da un ciclo deve terminare il programma, lascia che l’esecuzione raggiunga la fine di Main oppure restituisci il controllo da Main dopo il ciclo.

Lanciare un’eccezione trasferisce il controllo a un gestore corrispondente. Se il gestore la intercetta e l’esecuzione prosegue, il processo non è terminato. Gestisci la condizione, quindi scegli un percorso di ritorno normale e un codice di uscita appropriato se l’applicazione deve terminare. Un’eccezione non gestita può terminare un processo, ma usarla soltanto come scorciatoia per uscire rende meno chiari il flusso di controllo previsto e la gestione degli errori.

<kbd>Ctrl</kbd>+<kbd>C</kbd> è una richiesta di annullamento inviata dalla console, non un comando che garantisce una chiusura regolare. Un programma può rilevarla tramite Console.CancelKeyPress; che il processo si arresti subito o che il gestore annulli la risposta predefinita dipende dalla gestione dell’evento e dall’ambiente host. Se l’annullamento richiede una pulizia, registra la richiesta e lascia che il flusso di controllo principale interrompa il lavoro e termini normalmente.