ConsoleKey Enumeration

Referenz

Definition

Namespace:: System

Assembly:: System.Console.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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: Object

ValueType

Enum
ConsoleKey

Attribute: SerializableAttribute

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: