Process.CloseMainWindow Metodo

Definizione

Chiude un processo che dispone di un'interfaccia utente inviando un messaggio di chiusura alla corrispondente finestra principale.Closes a process that has a user interface by sending a close message to its main window.

public:
 bool CloseMainWindow();
public bool CloseMainWindow ();
member this.CloseMainWindow : unit -> bool
Public Function CloseMainWindow () As Boolean

Restituisce

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).true if the close message was successfully sent; false if the associated process does not have a main window or if the main window is disabled (for example if a modal dialog is being shown).

Eccezioni

Processo già terminato.The process has already exited.

-oppure--or- Nessun processo associato all'oggetto Process.No process is associated with this Process object.

Esempi

Nell'esempio seguente viene avviata un'istanza del blocco note.The following example starts an instance of Notepad. Recupera quindi l'utilizzo della memoria fisica del processo associato a intervalli di 2 secondi per un massimo di 10 secondi.It then retrieves the physical memory usage of the associated process at 2 second intervals for a maximum of 10 seconds. Nell'esempio viene rilevato se il processo viene terminato prima della scadenza di 10 secondi.The example detects whether the process exits before 10 seconds have elapsed. Nell'esempio viene chiuso il processo se è ancora in esecuzione dopo 10 secondi.The example closes the process if it is still running after 10 seconds.

#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 relativo ciclo di messaggi si trova in uno stato di attesa.When a process is executing, its message loop is in a wait state. Il ciclo di messaggi viene eseguito ogni volta che un messaggio di Windows viene inviato al processo dal sistema operativo.The message loop executes every time a Windows message is sent to the process by the operating system. Chiamando CloseMainWindow viene inviata una richiesta di chiusura della finestra principale, che, in un'applicazione ben formata, chiude le finestre figlio e revoca tutti i cicli di messaggi in esecuzione per l'applicazione.Calling CloseMainWindow sends a request to close the main window, which, in a well-formed application, closes child windows and revokes all running message loops for the application. La richiesta di uscire dal processo chiamando CloseMainWindow non impone la chiusura dell'applicazione.The request to exit the process by calling CloseMainWindow does not force the application to quit. L'applicazione può richiedere la verifica dell'utente prima di uscire oppure può rifiutare di uscire.The application can ask for user verification before quitting, or it can refuse to quit. Per forzare la chiusura dell'applicazione, usare il metodo Kill.To force the application to quit, use the Kill method. Il comportamento di CloseMainWindow è identico a quello di un utente che chiude la finestra principale di un'applicazione usando il menu di sistema.The behavior of CloseMainWindow is identical to that of a user closing an application's main window using the system menu. Pertanto, la richiesta di uscire dal processo chiudendo la finestra principale non impone immediatamente la chiusura dell'applicazione.Therefore, the request to exit the process by closing the main window does not force the application to quit immediately.

I dati modificati dal processo o dalle risorse allocate al processo possono essere persi se si chiama Kill.Data edited by the process or resources allocated to the process can be lost if you call Kill. Kill causa una chiusura anomala del processo e deve essere utilizzata solo quando necessario.Kill causes an abnormal process termination, and should be used only when necessary. CloseMainWindow consente una chiusura ordinata del processo e chiude tutte le finestre, quindi è preferibile per le applicazioni con un'interfaccia.CloseMainWindow enables an orderly termination of the process and closes all windows, so it is preferable for applications with an interface. Se CloseMainWindow ha esito negativo, è possibile usare Kill per terminare il processo.If CloseMainWindow fails, you can use Kill to terminate the process. Kill è l'unico modo per terminare i processi che non dispongono di interfacce grafiche.Kill is the only way to terminate processes that do not have graphical interfaces.

È possibile chiamare Kill e CloseMainWindow solo per i processi in esecuzione nel computer locale.You can call Kill and CloseMainWindow only for processes that are running on the local computer. Non è possibile causare la chiusura dei processi nei computer remoti.You cannot cause processes on remote computers to exit. È possibile visualizzare solo le informazioni per i processi in esecuzione in computer remoti.You can only view information for processes running on remote computers.

Sicurezza

LinkDemand
per l'attendibilità totale per il chiamante immediato.for full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile.This member cannot be used by partially trusted code.

Si applica a