ConsoleCancelEventArgs.Cancel Eigenschaft

Definition

Ruft einen Wert ab, der angibt, ob gleichzeitiges Drücken von Control-Zusatztaste und C-Konsolentaste (STRG+C) oder STRG+UNTBR den aktuellen Vorgang beendet, oder legt diesen Wert fest.Gets or sets a value that indicates whether simultaneously pressing the Control modifier key and the C console key (Ctrl+C) or the Ctrl+Break keys terminates the current process. Der Standardwert ist false, der den aktuellen Prozess beendet.The default is false, which terminates the current process.

public:
 property bool Cancel { bool get(); void set(bool value); };
public bool Cancel { get; set; }
member this.Cancel : bool with get, set
Public Property Cancel As Boolean

Eigenschaftswert

Boolean

true, wenn der aktuelle Vorgang fortgesetzt werden soll, wenn der Ereignishandler abgeschlossen wird; false, wenn der aktuelle Vorgang beendet werden soll.true if the current process should resume when the event handler concludes; false if the current process should terminate. Der Standardwert ist false; der aktuelle Prozess wird beendet, wenn der Ereignishandler zurückkehrt.The default value is false; the current process terminates when the event handler returns. Wenn true, wird der aktuelle Prozess fortgesetzt.If true, the current process continues.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie die-Eigenschaft verwendet wird Cancel , um ein Ereignis zu behandeln.The following example demonstrates how to use the Cancel property to handle an event.

using namespace System;

void OnCancelKeyPressed(Object^ sender, 
    ConsoleCancelEventArgs^ args)
{
    Console::WriteLine("{0}The read operation has been interrupted.",
        Environment::NewLine);

    Console::WriteLine("  Key pressed: {0}", args->SpecialKey);

    Console::WriteLine("  Cancel property: {0}", args->Cancel);

    // Set the Cancel property to true to prevent the process from 
    // terminating.
    Console::WriteLine("Setting the Cancel property to true...");
    args->Cancel = true;

    // Announce the new value of the Cancel property.
    Console::WriteLine("  Cancel property: {0}", args->Cancel);
    Console::WriteLine("The read operation will resume...{0}",
        Environment::NewLine);
}

int main()
{       
    // Clear the screen.
    Console::Clear();

    // Establish an event handler to process key press events.
    Console::CancelKeyPress += 
        gcnew ConsoleCancelEventHandler(OnCancelKeyPressed);

    while (true)
    {
        // Prompt the user.
        Console::Write("Press any key, or 'X' to quit, or ");
        Console::WriteLine("CTRL+C to interrupt the read operation:");

        // Start a console read operation. Do not display the input.
        ConsoleKeyInfo^ keyInfo = Console::ReadKey(true);

        // Announce the name of the key that was pressed .
        Console::WriteLine("  Key pressed: {0}{1}", keyInfo->Key, 
            Environment::NewLine);

        // Exit if the user pressed the 'X' key.
        if (keyInfo->Key == ConsoleKey::X)
        {
            break;
        }
    }
}
// The example displays output similar to the following:
//    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
//    Key pressed: J
//    
//    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
//    Key pressed: Enter
//    
//    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
//    
//    The read operation has been interrupted.
//    Key pressed: ControlC
//    Cancel property: False
//    Setting the Cancel property to true...
//    Cancel property: True
//    The read operation will resume...
//    
//    Key pressed: Q
//    
//    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
//    Key pressed: X
using System;

class Sample
{
    public static void Main()
    {
        ConsoleKeyInfo cki;

        Console.Clear();

        // Establish an event handler to process key press events.
        Console.CancelKeyPress += new ConsoleCancelEventHandler(myHandler);
        while (true)
        {
            Console.Write("Press any key, or 'X' to quit, or ");
            Console.WriteLine("CTRL+C to interrupt the read operation:");

            // Start a console read operation. Do not display the input.
            cki = Console.ReadKey(true);

            // Announce the name of the key that was pressed .
            Console.WriteLine($"  Key pressed: {cki.Key}\n");

            // Exit if the user pressed the 'X' key.
            if (cki.Key == ConsoleKey.X) break;
        }
    }

    protected static void myHandler(object sender, ConsoleCancelEventArgs args)
    {
        Console.WriteLine("\nThe read operation has been interrupted.");

        Console.WriteLine($"  Key pressed: {args.SpecialKey}");

        Console.WriteLine($"  Cancel property: {args.Cancel}");

        // Set the Cancel property to true to prevent the process from terminating.
        Console.WriteLine("Setting the Cancel property to true...");
        args.Cancel = true;

        // Announce the new value of the Cancel property.
        Console.WriteLine($"  Cancel property: {args.Cancel}");
        Console.WriteLine("The read operation will resume...\n");
    }
}
// The example displays output similar to the following:
//    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
//      Key pressed: J
//
//    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
//      Key pressed: Enter
//
//    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
//
//    The read operation has been interrupted.
//      Key pressed: ControlC
//      Cancel property: False
//    Setting the Cancel property to true...
//      Cancel property: True
//    The read operation will resume...
//
//      Key pressed: Q
//
//    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
//      Key pressed: X
Class Sample
    Public Shared Sub Main() 
        Dim cki As ConsoleKeyInfo
        
        Console.Clear()
        
        ' Establish an event handler to process key press events.
        AddHandler Console.CancelKeyPress, AddressOf myHandler

        While True
            Console.Write("Press any key, or 'X' to quit, or ")
            Console.WriteLine("CTRL+C to interrupt the read operation:")
            
            ' Start a console read operation. Do not display the input.
            cki = Console.ReadKey(True)
            
            ' Announce the name of the key that was pressed .
            Console.WriteLine($"  Key pressed: {cki.Key}{vbCrLf}")
            
            ' Exit if the user pressed the 'X' key.
            If cki.Key = ConsoleKey.X Then Exit While
        End While
    End Sub

    Protected Shared Sub myHandler(ByVal sender As Object, _
                                   ByVal args As ConsoleCancelEventArgs) 
        Console.WriteLine($"{vbCrLf}The read operation has been interrupted.")
        
        Console.WriteLine($"  Key pressed: {args.SpecialKey}")
        
        Console.WriteLine($"  Cancel property: {args.Cancel}")
        
        ' Set the Cancel property to true to prevent the process from terminating.
        Console.WriteLine("Setting the Cancel property to true...")
        args.Cancel = True
        
        ' Announce the new value of the Cancel property.
        Console.WriteLine($"  Cancel property: {args.Cancel}")
        Console.WriteLine($"The read operation will resume...{vbCrLf}")
    End Sub
End Class
' The example diplays output similar to the following:
'    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
'     Key pressed: J
'    
'    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
'     Key pressed: Enter
'    
'    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
'    
'    The read operation has been interrupted.
'     Key pressed: ControlC
'     Cancel property: False
'    Setting the Cancel property to true...
'     Cancel property: True
'    The read operation will resume...
'    
'     Key pressed: Q
'    
'    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
'     Key pressed: X

Hinweise

Die- Cancel Eigenschaft wird automatisch mit initialisiert, false Wenn der Handler für das- CancelKeyPress Ereignis aufgerufen wird.The Cancel property is automatically initialized to false when the handler for the CancelKeyPress event is invoked. Der Wert der- Cancel Eigenschaft, wenn der Ereignishandler beendet wird, bestimmt, ob der aktuelle Prozess fortgesetzt oder beendet wird.The value of the Cancel property when the event handler finishes determines whether the current process resumes or terminates.

Geben Sie in einem Set-Vorgang nach dem Drücken von STRG + C true an, um anzugeben, dass der aktuelle Prozess fortgesetzt werden soll, wenn der Ereignishandler beendet wird, oder false um anzugeben, dass der aktuelle Prozess beendet werden soll.In a set operation after Ctrl+C is pressed, specify true to indicate that the current process should resume when the event handler concludes, or false to indicate that the current process should terminate.

Hinweise für Aufrufer

In den .NET Framework 3,5 und .NET Framework 4 hat versucht, die- Cancel Eigenschaft auf festzulegen, true Wenn das CancelKeyPress Ereignis vom Benutzer aufgerufen wurde, indem Sie STRG + untpause drücken, eine Ausnahme ausgelöst hat InvalidOperationException .In the .NET Framework 3.5 and .NET Framework 4, attempting to set the Cancel property to true if the CancelKeyPress event was invoked by the user pressing Ctrl+Break threw an InvalidOperationException exception. Im .NET Framework 4,5 können Sie die- Cancel Eigenschaft auf festlegen, true nachdem der Benutzer STRG + PAUSE gedrückt und die Beendigung der Anwendung abgebrochen hat.In the .NET Framework 4.5, you can set the Cancel property to true after the user presses Ctrl+Break and cancel the termination of the application.

Gilt für:

Siehe auch