Process.EnableRaisingEvents Process.EnableRaisingEvents Process.EnableRaisingEvents Process.EnableRaisingEvents Property

Definizione

Ottiene o imposta la generazione dell'evento Exited quando il processo viene terminato.Gets or sets whether the Exited event should be raised when the process terminates.

public:
 property bool EnableRaisingEvents { bool get(); void set(bool value); };
[System.ComponentModel.Browsable(false)]
public bool EnableRaisingEvents { get; set; }
member this.EnableRaisingEvents : bool with get, set
Public Property EnableRaisingEvents As Boolean

Valore della proprietà

true se l'evento Exited dovrà essere generato quando il processo associato viene terminato (mediante un'uscita o una chiamata al metodo Kill()); in caso contrario, false.true if the Exited event should be raised when the associated process is terminated (through either an exit or a call to Kill()); otherwise, false. Il valore predefinito è false.The default is false. Si noti che il Exited evento viene generato anche se il valore di EnableRaisingEvents viene false quando il processo viene chiuso durante o prima che l'utente esegue un HasExited controllare.Note that the Exited event is raised even if the value of EnableRaisingEvents is false when the process exits during or before the user performs a HasExited check.

Esempi

Esempio di codice seguente crea un processo che consente di stampare un file.The following code example creates a process that prints a file. Imposta il EnableRaisingEvents proprietà per fare in modo che il processo generi il Exited eventi alla chiusura.It sets the EnableRaisingEvents property to cause the process to raise the Exited event when it exits. Il Exited gestore dell'evento Visualizza le informazioni sul processo.The Exited event handler displays process information.

using System;
using System.Diagnostics;
using System.Threading;

class PrintProcessClass
{
    private Process myProcess;
    private int elapsedTime;
    private bool eventHandled;

    // Print a file with any known extension.
    public void PrintDoc(string fileName)
    {
        elapsedTime = 0;
        eventHandled = false;

        using (myProcess = new Process())
        {
            try
            {
                // Start a process to print a file and raise an event when done.
                myProcess.StartInfo.FileName = fileName;
                myProcess.StartInfo.Verb = "Print";
                myProcess.StartInfo.CreateNoWindow = true;
                myProcess.EnableRaisingEvents = true;
                myProcess.Exited += new EventHandler(myProcess_Exited);
                myProcess.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred trying to print \"{fileName}\":\n{ex.Message}");
                return;
            }

            // Wait for Exited event, but not more than 30 seconds.
            const int SleepAmount = 100;
            while (!eventHandled)
            {
                elapsedTime += SleepAmount;
                if (elapsedTime > 30000)
                {
                    break;
                }
                
                Thread.Sleep(SleepAmount);
            }
        }
    }

    // Handle Exited event and display process information.
    private void myProcess_Exited(object sender, System.EventArgs e)
    {
        eventHandled = true;
        Console.WriteLine(
            $"Exit time    : {myProcess.ExitTime}\n" +
            $"Exit code    : {myProcess.ExitCode}\n" +
            $"Elapsed time : {elapsedTime}");
    }

    public static void Main(string[] args)
    {
        // Verify that an argument has been entered.
        if (args.Length <= 0)
        {
            Console.WriteLine("Enter a file name.");
            return;
        }

        // Create the process and print the document.
        PrintProcessClass myPrintProcess = new PrintProcessClass();
        myPrintProcess.PrintDoc(args[0]);
    }
}
Imports System
Imports System.Diagnostics
Imports System.Threading

Class PrintProcessClass

    Private WithEvents myProcess As Process
    Private elapsedTime As Integer
    Private eventHandled As Boolean

    Public Event Exited As EventHandler

    ' Print a file with any known extension.
    Sub PrintDoc(ByVal fileName As String)

        elapsedTime = 0
        eventHandled = False

        Using myProcess = New Process
            Try
                ' Start a process to print a file and raise an event when done.
                myProcess.StartInfo.FileName = fileName
                myProcess.StartInfo.Verb = "Print"
                myProcess.StartInfo.CreateNoWindow = True
                myProcess.EnableRaisingEvents = True
                myProcess.Start()

            Catch ex As Exception
                Console.WriteLine("An error occurred trying to print ""{0}"":" &
                vbCrLf & ex.Message, fileName)
                Return
            End Try
        End Using

        ' Wait for Exited event, but not more than 30 seconds.
        Const SLEEP_AMOUNT As Integer = 100
        Do While Not eventHandled
            elapsedTime += SLEEP_AMOUNT
            If elapsedTime > 30000 Then
                Exit Do
            End If
            Thread.Sleep(SLEEP_AMOUNT)
        Loop
    End Sub

    ' Handle Exited event and display process information.
    Private Sub myProcess_Exited(ByVal sender As Object,
            ByVal e As System.EventArgs) Handles myProcess.Exited

        eventHandled = True
        Console.WriteLine("Exit time:    {0}" & vbCrLf &
            "Exit code:    {1}" & vbCrLf & "Elapsed time: {2}",
            myProcess.ExitTime, myProcess.ExitCode, elapsedTime)
    End Sub

    Shared Sub Main(ByVal args() As String)

        ' Verify that an argument has been entered.
        If args.Length <= 0 Then
            Console.WriteLine("Enter a file name.")
            Return
        End If

        ' Create the process and print the document.
        Dim myPrintProcess As New PrintProcessClass
        myPrintProcess.PrintDoc(args(0))
    End Sub
End Class

Commenti

Il EnableRaisingEvents proprietà indica se il componente deve ricevere notifica quando il sistema operativo ha arrestato un processo.The EnableRaisingEvents property suggests whether the component should be notified when the operating system has shut down a process. Il EnableRaisingEvents proprietà viene utilizzata l'elaborazione asincrona per notificare all'applicazione che un processo è stato terminato.The EnableRaisingEvents property is used in asynchronous processing to notify your application that a process has exited. Per forzare l'applicazione in modo sincrono attendere un evento di uscita (che interrompe l'elaborazione dell'applicazione fino a quando non si è verificato l'evento di uscita), usare il WaitForExit (metodo).To force your application to synchronously wait for an exit event (which interrupts processing of the application until the exit event has occurred), use the WaitForExit method.

Nota

Se si usa Visual Studio e fare doppio clic su un Process componente nel progetto, un Exited delegato dell'evento e il gestore eventi vengono generati automaticamente.If you're using Visual Studio and double-click a Process component in your project, an Exited event delegate and event handler are automatically generated. Set di codice aggiuntivo di EnableRaisingEvents proprietà false.Additional code sets the EnableRaisingEvents property to false. È necessario modificare questa proprietà su true per il gestore dell'evento da eseguire quando viene chiuso il processo associato.You must change this property to true for your event handler to execute when the associated process exits.

Se il componente EnableRaisingEvents valore è true, o quando EnableRaisingEvents viene false e un HasExited controllo viene richiamato dal componente, il componente può accedere alle informazioni amministrative per il processo associato, che rimane archiviati dal sistema operativo.If the component's EnableRaisingEvents value is true, or when EnableRaisingEvents is false and a HasExited check is invoked by the component, the component can access the administrative information for the associated process, which remains stored by the operating system. Tali informazioni includono il ExitTime e il ExitCode.Such information includes the ExitTime and the ExitCode.

Dopo aver terminato il processo associato, il Handle del componente non punta più a una risorsa di processo esistente.After the associated process exits, the Handle of the component no longer points to an existing process resource. Al contrario, può solo essere utilizzato per accedere alle informazioni del sistema operativo sulla risorsa di processo.Instead, it can only be used to access the operating system's information about the process resource. Il sistema operativo è a conoscenza che non esistono handle a processi terminati che non sono stati rilasciati dai Process componenti, in modo che mantiene le ExitTime e Handle informazioni in memoria.The operating system is aware that there are handles to exited processes that haven't been released by Process components, so it keeps the ExitTime and Handle information in memory.

È previsto un costo associato la visione per un processo venga terminato.There's a cost associated with watching for a process to exit. Se EnableRaisingEvents viene true, il Exited evento viene generato quando termina il processo associato.If EnableRaisingEvents is true, the Exited event is raised when the associated process terminates. Le procedure per la Exited evento eseguito all'ora corrente.Your procedures for the Exited event run at that time.

In alcuni casi, l'applicazione avvia un processo ma non richiede la notifica della chiusura.Sometimes, your application starts a process but doesn't require notification of its closure. Ad esempio, l'applicazione può avviare Blocco note per consentire all'utente di eseguire la modifica del testo senza effettuare alcun altro uso dell'applicazione Blocco note.For example, your application can start Notepad to allow the user to perform text editing but make no further use of the Notepad application. È possibile scegliere evitare la notifica quando il processo viene terminato perché non è rilevante per la continuità operativa dell'applicazione.You can choose to avoid notification when the process exits because it's not relevant to the continued operation of your application. L'impostazione EnableRaisingEvents a false possono salvare le risorse di sistema.Setting EnableRaisingEvents to false can save system resources.

Sicurezza

LinkDemand
per un'attendibilità totale per il chiamante immediato.for full trust for the immediate caller. Impossibile utilizzare questo membro in codice parzialmente attendibile.This member cannot be used by partially trusted code.

Si applica a

Vedi anche