Console.CancelKeyPress 이벤트

정의

네임스페이스:

System

어셈블리:

System.Console.dll

Source:

Console.cs

Control 보조 키(Ctrl)와 C 콘솔 키(C) 또는 Break 키를 동시에 누르면(Ctrl+C 또는 Ctrl+Break) 발생합니다.

public:
 static event ConsoleCancelEventHandler ^ CancelKeyPress;

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
[System.Runtime.Versioning.UnsupportedOSPlatform("android")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static event ConsoleCancelEventHandler? CancelKeyPress;

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("android")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
member this.CancelKeyPress : ConsoleCancelEventHandler 

Public Shared Custom Event CancelKeyPress As ConsoleCancelEventHandler 

이벤트 유형

ConsoleCancelEventHandler

특성

UnsupportedOSPlatformAttribute

예제

다음 예제에서는 이벤트를 사용 하는 방법을 CancelKeyPress 보여 줍니다. Ctrl+C를 누르면 읽기 작업이 중단되고 myHandler 이벤트 처리기가 호출됩니다. 이벤트 처리기를 입력할 때 속성은 입니다false. 즉, ConsoleCancelEventArgs.Cancel 이벤트 처리기가 종료될 때 현재 프로세스가 종료됩니다. 그러나 이벤트 처리기는 속성을 true로 설정합니다ConsoleCancelEventArgs.Cancel. 즉, 프로세스가 종료되지 않고 읽기 작업이 다시 시작됩니다.

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

open System

let myHandler sender (args: ConsoleCancelEventArgs) =
    printfn "\nThe read operation has been interrupted."

    printfn $"  Key pressed: {args.SpecialKey}"

    printfn $"  Cancel property: {args.Cancel}"

    // Set the Cancel property to true to prevent the process from terminating.
    printfn "Setting the Cancel property to true..."
    args.Cancel <- true

    // Announce the new value of the Cancel property.
    printfn $"  Cancel property: {args.Cancel}"
    printfn "The read operation will resume...\n"

// Establish an event handler to process key press events.
Console.CancelKeyPress.AddHandler(ConsoleCancelEventHandler myHandler)

let mutable quit = false
while not quit do
    printf "Press any key, or 'X' to quit, or "
    printfn "CTRL+C to interrupt the read operation:"

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

    // Announce the name of the key that was pressed .
    printfn $"  Key pressed: {cki.Key}\n"

    // Exit if the user pressed the 'X' key.
    if cki.Key = ConsoleKey.X then
        quit <- true

// 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

설명

이 이벤트는 및 System.ConsoleCancelEventArgs와 함께 System.ConsoleCancelEventHandler 사용됩니다. CancelKeyPress 이벤트에 이벤트 처리기는 계속 실행 또는 종료 여부를 결정할 수 있도록 Ctrl + C 신호를 가로채 콘솔 애플리케이션을 사용 하도록 설정 합니다. 이벤트 처리에 대한 자세한 내용은 이벤트 처리 및 발생 을 참조하십시오.

사용자가 Ctrl + Break 또는 Ctrl + C를 누를 때를 CancelKeyPress 이벤트가 발생 하 고 애플리케이션의 ConsoleCancelEventHandler 이벤트 처리기가 실행 됩니다. 이벤트 처리기는 두 가지 유용한 속성이 있는 개체를 전달 ConsoleCancelEventArgs 합니다.

• SpecialKey을 사용하면 사용자가 Ctrl+C(속성 값이 )를 누르거나 Ctrl+Break(속성 값이 ConsoleSpecialKey.ControlC)를 누른 결과로 처리기가 호출되었는지 여부를 확인할 수 있습니다 ConsoleSpecialKey.ControlBreak.

• Cancel을 사용하면 Ctrl+C 또는 Ctrl+Break를 누르는 사용자에게 애플리케이션이 응답하는 방법을 결정할 수 있습니다. 기본적으로 속성은 Cancel 이며 false, 이벤트 처리기가 종료되면 프로그램 실행이 종료됩니다. 해당 속성을 변경 true 애플리케이션 실행을 계속 되도록 지정 합니다.

팁

애플리케이션의 요구 사항이 단순한, 하는 경우 사용할 수 있습니다는 TreatControlCAsInput 대신이 이벤트는 속성입니다. 이 속성을 설정 하 여 false, 사용자가 Ctrl + C를 누르면 애플리케이션을 항상 종료 되는 것을 확인할 수 있습니다. 로 설정 하 여 true, Ctrl + C를 눌러 애플리케이션을 종료 하지는 확인할 수 있습니다.

이 이벤트에 대한 이벤트 처리기는 스레드 풀 스레드에서 실행됩니다.

추가 정보

• ConsoleCancelEventArgs
• ConsoleCancelEventHandler
• TreatControlCAsInput