Console.CancelKeyPress Evento

Definición

Se produce cuando la tecla modificadora Control (Ctrl) y la tecla de consola C (C) o la tecla Interrumpir se presionan simultáneamente (Ctrl+C o Ctrl+Inter).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 

Ejemplos

En el ejemplo siguiente se muestra CancelKeyPress cómo se utiliza el evento.The following example demonstrates how the CancelKeyPress event is used. Al presionar Ctrl + C, la operación de lectura se interrumpe y se myHandler invoca el controlador de eventos.When you press Ctrl+C, the read operation is interrupted and the myHandler event handler is invoked. En el momento de la entrada al controlador ConsoleCancelEventArgs.Cancel de eventos false, la propiedad es, lo que significa que el proceso actual finalizará cuando finalice el controlador de eventos.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. Sin embargo, el controlador de eventos ConsoleCancelEventArgs.Cancel establece la truepropiedad en, lo que significa que el proceso no finalizará y se reanudará la operación de lectura.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

Comentarios

Este evento se utiliza junto con System.ConsoleCancelEventHandler y. System.ConsoleCancelEventArgsThis event is used in conjunction with System.ConsoleCancelEventHandler and System.ConsoleCancelEventArgs. El CancelKeyPress evento permite a una aplicación de consola interceptar la señal de Ctrl + C para que el controlador de eventos pueda decidir si continuar la ejecución o la finalización.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. Para obtener más información sobre el manejo de eventos, consulte controlar y provocar eventos.For more information about handling events, see Handling and Raising Events.

Cuando el usuario presiona Ctrl + C o Ctrl + Inter, se desencadena CancelKeyPress el evento y se ejecuta el controlador ConsoleCancelEventHandler de eventos de la aplicación.When the user presses either Ctrl+C or Ctrl+Break, the CancelKeyPress event is fired and the application's ConsoleCancelEventHandler event handler is executed. Se pasa al controlador de eventos ConsoleCancelEventArgs un objeto que tiene dos propiedades útiles:The event handler is passed a ConsoleCancelEventArgs object that has two useful properties:

  • SpecialKey, que le permite determinar si se invocó el controlador como resultado de que el usuario presiona Ctrl + C (el valor de la propiedad ConsoleSpecialKey.ControlCes) o Ctrl + Inter (el valor de ConsoleSpecialKey.ControlBreakla propiedad es).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, que le permite determinar el modo en que la aplicación debe responder al usuario presionando Ctrl + C o Ctrl + Inter.Cancel, which allows you to determine how to your application should respond to the user pressing Ctrl+C or Ctrl+Break. De forma predeterminada, Cancel la propiedad falsees, que hace que la ejecución del programa finalice cuando se cierre el controlador de eventos.By default, the Cancel property is false, which causes program execution to terminate when the event handler exits. Al cambiar su propiedad true a se especifica que la aplicación debe continuar ejecutándose.Changing its property to true specifies that the application should continue to execute.

Sugerencia

Si su aplicación tiene requisitos sencillos, puede utilizar la TreatControlCAsInput propiedad en lugar de este evento.If your application has simple requirements, you can use the TreatControlCAsInput property instead of this event. Al establecer esta propiedad en false, puede asegurarse de que la aplicación siempre se cierra si el usuario presiona Ctrl + C.By setting this property to false, you can ensure that your application always exits if the user presses Ctrl+C. Al establecerlo en true, puede asegurarse de que al presionar Ctrl + C no se finalizará la aplicación.By setting it to true, you can ensure that pressing Ctrl+C will not terminate the application.

El controlador de eventos para este evento se ejecuta en un subproceso de grupo de subprocesos.The event handler for this event is executed on a thread pool thread.

Seguridad

UIPermission
para modificar ventanas y subventanas seguras de nivel superior.for modifying safe top-level windows and subwindows. Enumeración asociada:SafeTopLevelWindowsAssociated enumeration: SafeTopLevelWindows

Se aplica a

Consulte también: