Teilen über


ConsoleKey Enumeration

Definition

Gibt die Standardtasten für eine Konsole an.

public enum class ConsoleKey
public enum ConsoleKey
[System.Serializable]
public enum ConsoleKey
type ConsoleKey = 
[<System.Serializable>]
type ConsoleKey = 
Public Enum ConsoleKey
Vererbung
ConsoleKey
Attribute

Felder

A 65

A-TASTE

Add 107

ADDITIONSTASTE (die Additionstaste auf der Zehnertastatur)

Applications 93

ANWENDUNGSTASTE (Microsoft Natural Keyboard)

Attention 246

ATTN-TASTE

B 66

B-TASTE

Backspace 8

RÜCKTASTE

BrowserBack 166

BROWSER-ZURÜCK-TASTE

BrowserFavorites 171

BROWSER-FAVORITEN-TASTE

BrowserForward 167

BROWSER-VORWÄRTS-TASTE

BrowserHome 172

BROWSER-STARTSEITE-TASTE

BrowserRefresh 168

BROWSER-AKTUALISIEREN-TASTE

BrowserSearch 170

BROWSER-SUCHEN-TASTE

BrowserStop 169

BROWSER-ABBRECHEN-TASTE

C 67

C-TASTE

Clear 12

ENTF-TASTE

CrSel 247

CRSEL-TASTE (Cursor auswählen)

D 68

D-TASTE

D0 48

0-TASTE

D1 49

1-TASTE

D2 50

2-TASTE

D3 51

3-TASTE

D4 52

4-TASTE

D5 53

5-TASTE

D6 54

6-TASTE

D7 55

7-TASTE

D8 56

8-TASTE

D9 57

9-TASTE

Decimal 110

KOMMATASTE (die Kommataste auf der Zehnertastatur)

Delete 46

ENTF-TASTE

Divide 111

DIVISIONSTASTE (die Divisionstaste auf der Zehnertastatur)

DownArrow 40

NACH-UNTEN-TASTE

E 69

E-TASTE

End 35

ENDE-TASTE

Enter 13

EINGABETASTE

EraseEndOfFile 249

ERASE EOF-TASTE

Escape 27

ESC-TASTE

Execute 43

AUSFÜHREN-TASTE

ExSel 248

EXSEL-TASTE (Auswahl erweitern)

F 70

F-TASTE

F1 112

F1-TASTE

F10 121

F10-TASTE

F11 122

F11-TASTE

F12 123

F12-TASTE

F13 124

F13-TASTE

F14 125

F14-TASTE

F15 126

F15-TASTE

F16 127

F16-TASTE

F17 128

F17-TASTE

F18 129

F18-TASTE

F19 130

F19-TASTE

F2 113

F2-TASTE

F20 131

F20-TASTE

F21 132

F21-TASTE

F22 133

F22-TASTE

F23 134

F23-TASTE

F24 135

F24-TASTE

F3 114

F3-TASTE

F4 115

F4-TASTE

F5 116

F5-TASTE

F6 117

F6-TASTE

F7 118

F7-TASTE

F8 119

F8-TASTE

F9 120

F9-TASTE

G 71

G-TASTE

H 72

H-TASTE

Help 47

HILFE-TASTE

Home 36

POS1-TASTE

I 73

I-TASTE

Insert 45

EINFG-TASTE

J 74

J-TASTE

K 75

K-TASTE

L 76

L-TASTE

LaunchApp1 182

ANWENDUNGSSTARTTASTE 1 (Microsoft Natural Keyboard).

LaunchApp2 183

ANWENDUNGSSTARTTASTE 2 (Microsoft Natural Keyboard).

LaunchMail 180

Die Taste zum Starten einer E-Mail (Microsoft Natural Keyboard).

LaunchMediaSelect 181

Die Taste für die Medienauswahl (Microsoft Natural Keyboard).

LeftArrow 37

NACH-LINKS-TASTE

LeftWindows 91

Linke Windows-Taste (Microsoft Natural Keyboard)

M 77

M-TASTE

MediaNext 176

Playertaste für den nächsten Titel

MediaPlay 179

Die WIEDERGABE-/PAUSE-TASTE für Medien.

MediaPrevious 177

Playertaste für den vorherigen Titel

MediaStop 178

Playertaste für das Beenden der Wiedergabe

Multiply 106

MULTIPLIKATIONSTASTE (die Multiplikationstaste auf der Zehnertastatur)

N 78

N-TASTE

NoName 252

Für zukünftige Verwendung reservierte Konstante

NumPad0 96

0-TASTE auf der Zehnertastatur

NumPad1 97

1-TASTE auf der Zehnertastatur

NumPad2 98

2-TASTE auf der Zehnertastatur

NumPad3 99

3-TASTE auf der Zehnertastatur

NumPad4 100

4-TASTE auf der Zehnertastatur

NumPad5 101

5-TASTE auf der Zehnertastatur

NumPad6 102

6-TASTE auf der Zehnertastatur

NumPad7 103

7-TASTE auf der Zehnertastatur

NumPad8 104

8-TASTE auf der Zehnertastatur

NumPad9 105

9-TASTE auf der Zehnertastatur

O 79

O-TASTE

Oem1 186

Die OEM-abhängige 1-TASTE (OEM-spezifisch)

Oem102 226

Die OEM-abhängige 102-TASTE (OEM-spezifisch)

Oem2 191

Die OEM-abhängige 2-TASTE (OEM-spezifisch)

Oem3 192

Die OEM-abhängige 3-TASTE (OEM-spezifisch)

Oem4 219

Die OEM-abhängige 4-TASTE (OEM-spezifisch)

Oem5 220

OEM-abhängige 5-TASTE (OEM-spezifisch)

Oem6 221

Die OEM-abhängige 6-TASTE (OEM-spezifisch)

Oem7 222

Die OEM-abhängige 7-TASTE (OEM-spezifisch)

Oem8 223

Die OEM-abhängige 8-TASTE (OEM-spezifisch)

OemClear 254

Die CLEAR-TASTE (OEM-spezifisch)

OemComma 188

Die OEM-abhängige KOMMATASTE auf Tastaturen beliebiger Länder/Regionen.

OemMinus 189

Die OEM-abhängige MINUSTASTE auf Tastaturen beliebiger Länder/Regionen.

OemPeriod 190

Die OEM-abhängige PUNKTTASTE auf Tastaturen beliebiger Länder/Regionen.

OemPlus 187

Die OEM-abhängige PLUSTASTE auf Tastaturen beliebiger Länder/Regionen.

P 80

P-TASTE

Pa1 253

PA1-Taste

Packet 231

PACKET-TASTE (zum Übergeben von Unicode-Zeichen mit Tastaturanschlägen)

PageDown 34

BILD-AB-TASTE

PageUp 33

BILD-AUF-TASTE

Pause 19

PAUSE-TASTE

Play 250

PLAY-TASTE

Print 42

DRUCKEN-TASTE

PrintScreen 44

DRUCK-TASTE

Process 229

Taste für IME-Verarbeitung

Q 81

Q-TASTE

R 82

R-TASTE

RightArrow 39

NACH-RECHTS-TASTE

RightWindows 92

Rechte Windows-Taste (Microsoft Natural Keyboard)

S 83

S-TASTE

Select 41

AUSWAHL-TASTE

Separator 108

TRENNZEICHENTASTE

Sleep 95

Taste für Standbymodus

Spacebar 32

LEERTASTE

Subtract 109

SUBTRAKTIONSTASTE (die Subtraktionstaste auf der Zehnertastatur)

T 84

T-TASTE

Tab 9

TAB-TASTE

U 85

U-TASTE

UpArrow 38

NACH-OBEN-TASTE

V 86

V-TASTE

VolumeDown 174

Die Taste zum Verringern der Lautstärke (Microsoft Natural Keyboard).

VolumeMute 173

Die Taste zum Stummschalten (Microsoft Natural Keyboard).

VolumeUp 175

Die Taste Erhöhen der Lautstärke (Microsoft Natural Keyboard).

W 87

W-TASTE

X 88

X-TASTE

Y 89

Y-TASTE

Z 90

Z-TASTE

Zoom 251

ZOOM-TASTE

Beispiele

Im folgenden Beispiel wird die ConsoleKey -Enumeration verwendet, um dem Benutzer anzugeben, welche Taste der Benutzer gedrückt hat.

using namespace System;
using namespace System::Text;

void main()
{
   ConsoleKeyInfo input;
   do {
      Console::WriteLine("Press a key, together with Alt, Ctrl, or Shift.");
      Console::WriteLine("Press Esc to exit.");
      input = Console::ReadKey(true);

      StringBuilder^ output = gcnew StringBuilder(
                     String::Format("You pressed {0}", input.Key.ToString()));
      bool modifiers = false;

      if ((input.Modifiers & ConsoleModifiers::Alt) == ConsoleModifiers::Alt) {
         output->Append(", together with " + ConsoleModifiers::Alt.ToString());
         modifiers = true;
      }
      if ((input.Modifiers & ConsoleModifiers::Control) == ConsoleModifiers::Control)
      {
         if (modifiers) {
            output->Append(" and ");
         }   
         else {
            output->Append(", together with ");
            modifiers = true;
         }
         output->Append(ConsoleModifiers::Control.ToString());
      }
      if ((input.Modifiers & ConsoleModifiers::Shift) == ConsoleModifiers::Shift)
      {
         if (modifiers) {
            output->Append(" and ");
         }   
         else {
            output->Append(", together with ");
            modifiers = true;
         }
         output->Append(ConsoleModifiers::Shift.ToString());
      }
      output->Append(".");                  
      Console::WriteLine(output->ToString());
      Console::WriteLine();
   } while (input.Key != ConsoleKey::Escape);
}
// The output from a sample console session might appear as follows:
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed D.
//       
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed X, along with Shift.
//       
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed L, along with Control and Shift.
//       
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed P, along with Alt and Control and Shift.
//       
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed Escape.
using System;
using System.Text;

public class ConsoleKeyExample
{
   public static void Main()
   {
      ConsoleKeyInfo input;
      do {
         Console.WriteLine("Press a key, together with Alt, Ctrl, or Shift.");
         Console.WriteLine("Press Esc to exit.");
         input = Console.ReadKey(true);

         StringBuilder output = new StringBuilder(
                       String.Format("You pressed {0}", input.Key.ToString()));
         bool modifiers = false;

         if ((input.Modifiers & ConsoleModifiers.Alt) == ConsoleModifiers.Alt) {
            output.Append(", together with " + ConsoleModifiers.Alt.ToString());
            modifiers = true;
         }
         if ((input.Modifiers & ConsoleModifiers.Control) == ConsoleModifiers.Control)
         {
            if (modifiers) {
               output.Append(" and ");
            }
            else {
               output.Append(", together with ");
               modifiers = true;
            }
            output.Append(ConsoleModifiers.Control.ToString());
         }
         if ((input.Modifiers & ConsoleModifiers.Shift) == ConsoleModifiers.Shift)
         {
            if (modifiers) {
               output.Append(" and ");
            }
            else {
               output.Append(", together with ");
               modifiers = true;
            }
            output.Append(ConsoleModifiers.Shift.ToString());
         }
         output.Append(".");
         Console.WriteLine(output.ToString());
         Console.WriteLine();
      } while (input.Key != ConsoleKey.Escape);
   }
}
// The output from a sample console session might appear as follows:
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed D.
//
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed X, along with Shift.
//
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed L, along with Control and Shift.
//
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed P, along with Alt and Control and Shift.
//
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed Escape.
open System
open System.Text

let mutable input = Unchecked.defaultof<ConsoleKeyInfo>

while input.Key <> ConsoleKey.Escape do
    printfn "Press a key, together with Alt, Ctrl, or Shift."
    printfn "Press Esc to exit."
    input <- Console.ReadKey true

    let output = StringBuilder $"You pressed {input.Key}"
    let mutable modifiers = false

    if input.Modifiers &&& ConsoleModifiers.Alt = ConsoleModifiers.Alt then
        output.Append ", together with {ConsoleModifiers.Alt}" |> ignore
        modifiers <- true

    if input.Modifiers &&& ConsoleModifiers.Control = ConsoleModifiers.Control then
        if modifiers then
            output.Append " and " |> ignore
    else
        output.Append ", together with " |> ignore
        modifiers <- true
        output.Append(string ConsoleModifiers.Control) |> ignore

    if input.Modifiers &&& ConsoleModifiers.Shift = ConsoleModifiers.Shift then
        if modifiers then
            output.Append " and " |> ignore
        else
            output.Append ", together with " |> ignore
            modifiers <- true
        output.Append(string ConsoleModifiers.Shift) |> ignore
    output.Append "." |> ignore
    
    printfn $"{output}\n"


// The output from a sample console session might appear as follows:
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed D.
//
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed X, along with Shift.
//
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed L, along with Control and Shift.
//
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed P, along with Alt and Control and Shift.
//
//       Press a key, along with Alt, Ctrl, or Shift.
//       Press Esc to exit.
//       You pressed Escape.
Imports System.Text

Module ConsoleKeyExample

   Public Sub Main()
      Dim input As ConsoleKeyInfo
      Do 
         Console.WriteLine("Press a key, together with Alt, Ctrl, or Shift.")
         Console.WriteLine("Press Esc to exit.")
         input = Console.ReadKey(True)

         Dim output As New StringBuilder(String.Format("You pressed {0}", input.Key.ToString()))
         Dim modifiers As Boolean

         If (input.Modifiers And ConsoleModifiers.Alt) = ConsoleModifiers.Alt Then
            output.Append(", together with " + ConsoleModifiers.Alt.ToString())
            modifiers = True
         End If
         If (input.Modifiers And ConsoleModifiers.Control) = ConsoleModifiers.Control Then
            If modifiers Then
               output.Append(" and ")
            Else
               output.Append(", together with ")
               modifiers = True
            End If
            output.Append(ConsoleModifiers.Control.ToString)
         End If
         If (input.Modifiers And ConsoleModifiers.Shift) = ConsoleModifiers.Shift Then
            If modifiers Then
               output.Append(" and ")
            Else
               output.Append(", together with ")
            End If
            output.Append(ConsoleModifiers.Shift.ToString)
         End If
         output.Append(".")                  
         Console.WriteLine(output.ToString())
         Console.WriteLine()
      Loop While input.Key <> ConsoleKey.Escape        
   End Sub
End Module
' The output from a sample console session might appear as follows:
'       Press a key, along with Alt, Ctrl, or Shift.
'       Press Esc to exit.
'       You pressed D.
'       
'       Press a key, along with Alt, Ctrl, or Shift.
'       Press Esc to exit.
'       You pressed X, along with Shift.
'       
'       Press a key, along with Alt, Ctrl, or Shift.
'       Press Esc to exit.
'       You pressed L, along with Control and Shift.
'       
'       Press a key, along with Alt, Ctrl, or Shift.
'       Press Esc to exit.
'       You pressed P, along with Alt and Control and Shift.
'       
'       Press a key, along with Alt, Ctrl, or Shift.
'       Press Esc to exit.
'       You pressed Escape.

Hinweise

Die ConsoleKey -Enumeration wird in der Regel in der nfo-Struktur verwendet, die von der Console.ReadKey -Methode zurückgegeben wird, um anzugeben, welche Taste auf der Konsole gedrückt wurde.

Gilt für: