Console.CancelKeyPress Zdarzenie

Definicja

Występuje po naciśnięciu klawisza modyfikującego Control (Ctrl) i klawisza C Console (C) lub klawisza Break (Ctrl + C lub Ctrl + Break).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 

Przykłady

Poniższy przykład ilustruje sposób używania zdarzenia CancelKeyPress.The following example demonstrates how the CancelKeyPress event is used. Po naciśnięciu klawiszy CTRL + C operacja odczytu zostanie przerwana i zostanie wywołana procedura obsługi zdarzeń myHandler.When you press Ctrl+C, the read operation is interrupted and the myHandler event handler is invoked. Po wprowadzeniu do programu obsługi zdarzeń Właściwość ConsoleCancelEventArgs.Cancel jest false, co oznacza, że bieżący proces zakończy się po zakończeniu obsługi zdarzeń.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. Jednak program obsługi zdarzeń ustawia właściwość ConsoleCancelEventArgs.Cancel na true, co oznacza, że proces nie zostanie zakończony i operacja odczytu zostanie wznowiona.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: {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

Uwagi

To zdarzenie jest używane w połączeniu z System.ConsoleCancelEventHandler i System.ConsoleCancelEventArgs.This event is used in conjunction with System.ConsoleCancelEventHandler and System.ConsoleCancelEventArgs. Zdarzenie CancelKeyPress umożliwia aplikacji konsolowej przechwycenie sygnału Ctrl + C, aby program obsługi zdarzeń mógł zdecydować, czy kontynuować wykonywanie czy zakończenie.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. Aby uzyskać więcej informacji na temat obsługi zdarzeń, zobacz Obsługa iwywoływanie zdarzeń.For more information about handling events, see Handling and Raising Events.

Gdy użytkownik naciśnie kombinację klawiszy CTRL + C lub Ctrl + Break, zdarzenie CancelKeyPress jest wyzwalane i zostanie wykonany program obsługi zdarzeń ConsoleCancelEventHandler aplikacji.When the user presses either Ctrl+C or Ctrl+Break, the CancelKeyPress event is fired and the application's ConsoleCancelEventHandler event handler is executed. Program obsługi zdarzeń przeszedł obiekt ConsoleCancelEventArgs, który ma dwie przydatne właściwości:The event handler is passed a ConsoleCancelEventArgs object that has two useful properties:

  • SpecialKey, która pozwala określić, czy program obsługi został wywołany w wyniku naciśnięcia kombinacji klawiszy CTRL + C (wartość właściwości to ConsoleSpecialKey.ControlC) lub Ctrl + Break (wartość właściwości jest 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, która pozwala określić, jak aplikacja ma reagować na użytkownika, naciskając klawisze CTRL + C lub Ctrl + Break.Cancel, which allows you to determine how to your application should respond to the user pressing Ctrl+C or Ctrl+Break. Domyślnie właściwość Cancel jest false, co powoduje przerwanie wykonywania programu po zakończeniu obsługi zdarzeń.By default, the Cancel property is false, which causes program execution to terminate when the event handler exits. Zmiana jego właściwości na true określa, że aplikacja powinna nadal działać.Changing its property to true specifies that the application should continue to execute.

Porada

Jeśli aplikacja ma proste wymagania, można użyć właściwości TreatControlCAsInput zamiast tego zdarzenia.If your application has simple requirements, you can use the TreatControlCAsInput property instead of this event. Ustawiając tę właściwość na false, można upewnić się, że aplikacja zawsze kończy działanie, jeśli użytkownik naciśnie klawisze CTRL + C.By setting this property to false, you can ensure that your application always exits if the user presses Ctrl+C. Ustawiając je na true, można upewnić się, że naciśnięcie klawiszy CTRL + C nie spowoduje zakończenia aplikacji.By setting it to true, you can ensure that pressing Ctrl+C will not terminate the application.

Procedura obsługi zdarzeń dla tego zdarzenia jest wykonywana w wątku puli wątków.The event handler for this event is executed on a thread pool thread.

Zabezpieczenia

UIPermission
Modyfikowanie bezpiecznych okien najwyższego poziomu i okien podrzędnych.for modifying safe top-level windows and subwindows. Associated enumeration: SafeTopLevelWindowsAssociated enumeration: SafeTopLevelWindows

Dotyczy

Zobacz też