Process.EnableRaisingEvents Egenskap

public:
 property bool EnableRaisingEvents { bool get(); void set(bool value); };

[System.ComponentModel.Browsable(false)]
public bool EnableRaisingEvents { get; set; }

[<System.ComponentModel.Browsable(false)>]
member this.EnableRaisingEvents : bool with get, set

Public Property EnableRaisingEvents As Boolean

Egenskapsvärde

trueom händelsen Exited ska aktiveras när den associerade processen avslutas (antingen genom ett avslut eller ett anrop till Kill()), annars . false Standardvärdet är false. Observera att även om värdet EnableRaisingEvents för är falseExited genereras händelsen av egenskapsåtkomstorn HasExited om den fastställer att processen har avslutats.

Attribut

BrowsableAttribute

Exempel

I följande kodexempel skapas en process som skriver ut en fil. Den ställer in egenskapen EnableRaisingEvents så att processen genererar händelsen när den Exited avslutas. Händelsehanteraren Exited visar processinformation.

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

class PrintProcessClass
{
    private Process myProcess;
    private TaskCompletionSource<bool> eventHandled;

    // Print a file with any known extension.
    public async Task PrintDoc(string fileName)
    {
        eventHandled = new TaskCompletionSource<bool>();

        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.
            await Task.WhenAny(eventHandled.Task,Task.Delay(30000));
        }
    }

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

    public static async Task 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();
        await myPrintProcess.PrintDoc(args[0]);
    }
}

open System
open System.Diagnostics
open System.Threading.Tasks

let mutable myProcess = new Process()
let mutable eventHandled = TaskCompletionSource<bool>()

// Handle Exited event and display process information.
let myProcess_Exited (sender: obj) (e: EventArgs) =
    printfn $"Exit time    : {myProcess.ExitTime}\n"
    printfn $"Exit code    : {myProcess.ExitCode}\n"
    printfn $"Elapsed time : {round ((myProcess.ExitTime - myProcess.StartTime).TotalMilliseconds)}"
    eventHandled.TrySetResult true |> ignore

// Print a file with any known extension.
let printDoc fileName =
    task {
        eventHandled <- TaskCompletionSource<bool>()

        use 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.AddHandler(EventHandler myProcess_Exited)
            myProcess.Start() |> ignore
        with ex ->
            printfn $"An error occurred trying to print \"{fileName}\":\n{ex.Message}"

        // Wait for Exited event, but not more than 30 seconds.
        let! _ = Task.WhenAny(eventHandled.Task, Task.Delay(30000))
        ()
    }

[<EntryPoint>]
let main args =
    // Verify that an argument has been entered.
    if args.Length <= 0 then
        printfn "Enter a file name."
    else
        // Create the process and print the document.
        printDoc(args[0]).Wait() |> ignore

    0

Imports System.Diagnostics

Class PrintProcessClass

    Private WithEvents myProcess As Process
    Private eventHandled As TaskCompletionSource(Of Boolean)

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

        eventHandled = New TaskCompletionSource(Of Boolean)()
        myProcess = New Process
        Using myProcess
            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
                AddHandler myProcess.Exited, New EventHandler(AddressOf myProcess_Exited)
                myProcess.Start()

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

            ' Wait for Exited event, but not more than 30 seconds.
            Await Task.WhenAny(eventHandled.Task, Task.Delay(30000))
        End Using
    End Function

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

        Console.WriteLine("Exit time:    {0}" & vbCrLf &
            "Exit code:    {1}" & vbCrLf & "Elapsed time: {2}",
            myProcess.ExitTime, myProcess.ExitCode,
            Math.Round((myProcess.ExitTime - myProcess.StartTime).TotalMilliseconds))
        eventHandled.TrySetResult(True)
    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)).Wait()

    End Sub
End Class

Kommentarer

Egenskapen EnableRaisingEvents anger om komponenten ska meddelas när operativsystemet har stängt av en process. Egenskapen EnableRaisingEvents används i asynkron bearbetning för att meddela ditt program att en process har avslutats. Använd metoden för att tvinga programmet att synkront vänta på en avslutningshändelse (som avbryter bearbetningen av programmet tills avslutshändelsen WaitForExit har inträffat).

Om komponentens EnableRaisingEvents värde är true, eller när EnableRaisingEvents är false och en HasExited kontroll anropas av komponenten, kan komponenten komma åt den administrativa informationen för den associerade processen, som fortfarande lagras av operativsystemet. Sådan information omfattar ExitTime och ExitCode.

När den associerade processen har avslutats pekar komponenten Handle inte längre på en befintlig processresurs. I stället kan den bara användas för att komma åt operativsystemets information om processresursen. Operativsystemet är medvetet om att det finns referenser till avslutade processer som inte har släppts av Process komponenter, så det behåller ExitTime informationen och Handle i minnet.

Det finns en kostnad som är kopplad till att titta efter en process att avsluta. Om EnableRaisingEvents är trueutlöses Exited händelsen när den associerade processen avslutas. Dina procedurer för Exited händelsen körs då.

Ibland startar ditt program en process men kräver inte avisering om stängningen. Ditt program kan till exempel starta Anteckningar så att användaren kan utföra textredigering men inte längre använda Anteckningar-programmet. Du kan välja att undvika meddelanden när processen avslutas eftersom den inte är relevant för den fortsatta driften av ditt program. Om du anger EnableRaisingEvents till false kan du spara systemresurser.

Se även

• WaitForExit(Int32)
• Exited
• CloseMainWindow()
• Kill()
• Handle
• ExitTime
• HasExited