Process.CloseMainWindow Metodo

Definizione

Spazio dei nomi:

System.Diagnostics

Assembly:

System.Diagnostics.Process.dll

Origine:

Process.cs

Chiude un processo che dispone di un'interfaccia utente inviando un messaggio di chiusura alla corrispondente finestra principale.

public:
 bool CloseMainWindow();

public bool CloseMainWindow ();

member this.CloseMainWindow : unit -> bool

Public Function CloseMainWindow () As Boolean

Restituisce

Boolean

true se il messaggio di chiusura è stato inviato correttamente, false se il processo associato non dispone di una finestra principale o se la finestra principale è disabilitata (ad esempio, se è attualmente visualizzata una finestra modale).

Eccezioni

InvalidOperationException

Processo già terminato.

-oppure-

Nessun processo associato all'oggetto Process.

Esempio

Nell'esempio seguente viene avviata un'istanza del Blocco note. Recupera quindi l'utilizzo della memoria fisica del processo associato a intervalli di 2 secondi per un massimo di 10 secondi. Nell'esempio viene rilevato se il processo viene chiuso prima che siano trascorsi 10 secondi. L'esempio chiude il processo se è ancora in esecuzione dopo 10 secondi.

#using <System.dll>

using namespace System;
using namespace System::Diagnostics;
using namespace System::Threading;
int main()
{
   try
   {
      Process^ myProcess;
      myProcess = Process::Start(  "Notepad.exe" );
      
      // Display physical memory usage 5 times at intervals of 2 seconds.
      for ( int i = 0; i < 5; i++ )
      {
         if (  !myProcess->HasExited )
         {
            
            // Discard cached information about the process.
            myProcess->Refresh();
            
            // Print working set to console.
            Console::WriteLine( "Physical Memory Usage : {0}", myProcess->WorkingSet.ToString() );
            
            // Wait 2 seconds.
            Thread::Sleep( 2000 );
         }
         else
         {
            break;
         }

      }
      myProcess->CloseMainWindow();
      
      // Free resources associated with process.
      myProcess->Close();
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "The following exception was raised: " );
      Console::WriteLine( e->Message );
   }

}

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Threading;

namespace ProcessSample
{
    class MyProcessClass
    {
        public static void Main()
        {
            try
            {
                using (Process myProcess = Process.Start("Notepad.exe"))
                {
                    // Display physical memory usage 5 times at intervals of 2 seconds.
                    for (int i = 0; i < 5; i++)
                    {
                        if (!myProcess.HasExited)
                        {
                            // Discard cached information about the process.
                            myProcess.Refresh();
                            // Print working set to console.
                            Console.WriteLine($"Physical Memory Usage: {myProcess.WorkingSet}");
                            // Wait 2 seconds.
                            Thread.Sleep(2000);
                        }
                        else
                        {
                            break;
                        }
                    }

                    // Close process by sending a close message to its main window.
                    myProcess.CloseMainWindow();
                    // Free resources associated with process.
                    myProcess.Close();
                }
            }
            catch (Exception e) when (e is Win32Exception || e is FileNotFoundException)
            {
                Console.WriteLine("The following exception was raised: ");
                Console.WriteLine(e.Message);
            }
        }
    }
}

Imports System.ComponentModel
Imports System.Diagnostics
Imports System.IO
Imports System.Threading

Namespace Process_Sample
    Class MyProcessClass

        Public Shared Sub Main()
            Try
                Using myProcess = Process.Start("Notepad.exe")
                    ' Display physical memory usage 5 times at intervals of 2 seconds.
                    Dim i As Integer
                    For i = 0 To 4
                        If Not myProcess.HasExited Then

                            ' Discard cached information about the process.
                            myProcess.Refresh()
                            ' Print working set to console.
                            Console.WriteLine($"Physical Memory Usage: {myProcess.WorkingSet}")
                            ' Wait 2 seconds.
                            Thread.Sleep(2000)
                        Else
                            Exit For
                        End If

                    Next i

                    ' Close process by sending a close message to its main window.
                    myProcess.CloseMainWindow()
                    ' Free resources associated with process.
                    myProcess.Close()
                End Using
            Catch e As Exception When TypeOf e Is Win32Exception Or TypeOf e Is FileNotFoundException
                Console.WriteLine("The following exception was raised: ")
                Console.WriteLine(e.Message)
            End Try
        End Sub
    End Class
End Namespace 'Process_Sample

Commenti

Quando un processo è in esecuzione, il ciclo di messaggi è in uno stato di attesa. Il ciclo di messaggi viene eseguito ogni volta che un messaggio di Windows viene inviato al processo dal sistema operativo. La chiamata CloseMainWindow invia una richiesta per chiudere la finestra principale, che, in un'applicazione ben formata, chiude le finestre figlio e revoca tutti i cicli di messaggi in esecuzione per l'applicazione. La richiesta di uscire dal processo chiamando CloseMainWindow non forza la chiusura dell'applicazione. L'applicazione può richiedere la verifica dell'utente prima di uscire oppure rifiutare di uscire. Per forzare la chiusura dell'applicazione, usare il Kill metodo . Il comportamento di CloseMainWindow è identico a quello di un utente che chiude la finestra principale di un'applicazione usando il menu di sistema. Pertanto, la richiesta di uscire dal processo chiudendo la finestra principale non forza l'interruzione immediata dell'applicazione.

I dati modificati dal processo o dalle risorse allocate al processo possono essere persi se si chiama Kill. Kill causa una terminazione del processo anomala e deve essere usata solo quando necessario. CloseMainWindow abilita una terminazione ordinata del processo e chiude tutte le finestre, quindi è preferibile per le applicazioni con un'interfaccia. Se CloseMainWindow ha esito negativo, è possibile usare Kill per terminare il processo. Kill è l'unico modo per terminare i processi che non dispongono di interfacce grafiche.

È possibile chiamare Kill e CloseMainWindow solo per i processi in esecuzione nel computer locale. Non è possibile causare la chiusura dei processi nei computer remoti. È possibile visualizzare solo le informazioni per i processi in esecuzione nei computer remoti.