Console.CancelKeyPress Console.CancelKeyPress Console.CancelKeyPress Console.CancelKeyPress Event

Definition

Tritt ein, wenn die Control-Modifizierertaste (STRG) und entweder die C-Konsolentaste (c) oder die UNTBR-TASTE gleichzeitig gedrückt werden (STRG+C oder STRG+UNTBR).Occurs when the Control modifier key (Ctrl) and either the C console key (C) or the Break key are pressed simultaneously (Ctrl+C or Ctrl+Break).

public:
 static event ConsoleCancelEventHandler ^ CancelKeyPress;
public static event ConsoleCancelEventHandler CancelKeyPress;
member this.CancelKeyPress : ConsoleCancelEventHandler 
Public Shared Custom Event CancelKeyPress As ConsoleCancelEventHandler 

Beispiele

Im folgenden Beispiel wird veranschaulicht, CancelKeyPress wie das-Ereignis verwendet wird.The following example demonstrates how the CancelKeyPress event is used. Wenn Sie STRG + C drücken, wird der Lesevorgang unterbrochen, und myHandler der Ereignishandler wird aufgerufen.When you press Ctrl+C, the read operation is interrupted and the myHandler event handler is invoked. Beim Eintritt in den-Ereignishandler ist ConsoleCancelEventArgs.Cancel falsedie-Eigenschaft. Dies bedeutet, dass der aktuelle Prozess beendet wird, wenn der Ereignishandler beendet wird.Upon entry to the event handler, the ConsoleCancelEventArgs.Cancel property is false, which means that the current process will terminate when the event handler terminates. Allerdings legt der Ereignishandler die ConsoleCancelEventArgs.Cancel -Eigenschaft trueauf fest. Dies bedeutet, dass der Prozess nicht beendet wird und der Lesevorgang fortgesetzt wird.However, the event handler sets the ConsoleCancelEventArgs.Cancel property to true, which means that the process will not terminate and the read operation will resume.

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: {0}\n", cki.Key);

            // 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: {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...\n");
    }
}
// The example displays output similar to the follwoing:
//    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: {0}" & vbCrLf, cki.Key)
            
            ' 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: {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..." & 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

Dieses Ereignis wird in Verbindung mit System.ConsoleCancelEventHandler und System.ConsoleCancelEventArgsverwendet.This event is used in conjunction with System.ConsoleCancelEventHandler and System.ConsoleCancelEventArgs. Das CancelKeyPress -Ereignis ermöglicht einer Konsolenanwendung, das STRG + C-Signal abzufangen, damit der Ereignishandler entscheiden kann, ob die Ausführung oder das Beenden fortgesetzt werden soll.The CancelKeyPress event enables a console application to intercept the Ctrl+C signal so the event handler can decide whether to continue executing or terminate. Weitere Informationen zur Behandlung von Ereignissen finden Sie unter behandeln und Auslösen von Ereignissen.For more information about handling events, see Handling and Raising Events.

Wenn der Benutzer entweder STRG + C oder Strg + Pause drückt, wird CancelKeyPress das-Ereignis ausgelöst, und der ConsoleCancelEventHandler -Ereignishandler der Anwendung wird ausgeführt.When the user presses either Ctrl+C or Ctrl+Break, the CancelKeyPress event is fired and the application's ConsoleCancelEventHandler event handler is executed. Dem Ereignishandler wird ein ConsoleCancelEventArgs -Objekt mit zwei nützlichen Eigenschaften übermittelt:The event handler is passed a ConsoleCancelEventArgs object that has two useful properties:

  • SpecialKey, mit dem Sie bestimmen können, ob der Handler als Ergebnis des Benutzers aufgerufen wurde, drücken Sie STRG + C (der-Eigenschafts Wert ist ConsoleSpecialKey.ControlC) oder Strg + Pause (der-Eigenschafts Wert ist ConsoleSpecialKey.ControlBreak).SpecialKey, which allows you to determine whether the handler was invoked as a result of the user pressing Ctrl+C (the property value is ConsoleSpecialKey.ControlC) or Ctrl+Break (the property value is ConsoleSpecialKey.ControlBreak).

  • Cancel, mit dem Sie bestimmen können, wie Ihre Anwendung auf den Benutzer reagieren soll, indem Sie STRG + C oder Strg + Pause drücken.Cancel, which allows you to determine how to your application should respond to the user pressing Ctrl+C or Ctrl+Break. Standardmäßig ist die Cancel -Eigenschaft false, was bewirkt, dass die Programmausführung beendet wird, wenn der Ereignishandler beendet wird.By default, the Cancel property is false, which causes program execution to terminate when the event handler exits. Durch Ändern der- true Eigenschaft in wird angegeben, dass die Anwendung weiterhin ausgeführt werden soll.Changing its property to true specifies that the application should continue to execute.

Tipp

Wenn Ihre Anwendung einfache Anforderungen hat, können Sie die TreatControlCAsInput -Eigenschaft anstelle dieses Ereignisses verwenden.If your application has simple requirements, you can use the TreatControlCAsInput property instead of this event. Wenn Sie diese Eigenschaft auf falsefestlegen, können Sie sicherstellen, dass die Anwendung immer beendet wird, wenn der Benutzer STRG + C drückt.By setting this property to false, you can ensure that your application always exits if the user presses Ctrl+C. Durch Festlegen von auf truekönnen Sie sicherstellen, dass die Anwendung durch Drücken von STRG + C nicht beendet wird.By setting it to true, you can ensure that pressing Ctrl+C will not terminate the application.

Der Ereignishandler für dieses Ereignis wird für einen Thread Pool Thread ausgeführt.The event handler for this event is executed on a thread pool thread.

Sicherheit

UIPermission
zum Ändern von sicheren Fenstern und untergeordneten Fenstern der obersten Ebene.for modifying safe top-level windows and subwindows. Zugehörige Enumeration:SafeTopLevelWindowsAssociated enumeration: SafeTopLevelWindows

Gilt für:

Siehe auch