Console Klasse

Definition

Stellt die Standardstreams für Eingabe, Ausgabe und Fehler bei Konsolenanwendungen dar.Represents the standard input, output, and error streams for console applications. Diese Klasse kann nicht vererbt werden.This class cannot be inherited.

public ref class Console abstract sealed
public static class Console
type Console = class
Public Class Console
Vererbung
Console

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Daten aus den standardmäßigen Eingabe-und Ausgabedaten strömen gelesen und in diese geschrieben werden.The following example demonstrates how to read data from, and write data to, the standard input and output streams. Beachten Sie, dass diese Streams mithilfe der-Methode SetIn und SetOut der-Methode umgeleitet werden können.Note that these streams can be redirected by using the SetIn and SetOut methods.

using namespace System;

int main()
{
   Console::Write( L"Hello " );
   Console::WriteLine( L"World!" );
   Console::Write( L"Enter your name: " );
   String^ name = Console::ReadLine();
   Console::Write( L"Good day, " );
   Console::Write( name );
   Console::WriteLine( L"!" );
}
// The example displays output similar to the following:
//       Hello World!
//       Enter your name: James
//       Good day, James!
using System;

public class Example {
    public static void Main() 
    {
        Console.Write("Hello ");
        Console.WriteLine("World!");
        Console.Write("Enter your name: ");
        String name = Console.ReadLine();
        Console.Write("Good day, ");
        Console.Write(name);
        Console.WriteLine("!");
    }
}
// The example displays output similar to the following:
//       Hello World!
//       Enter your name: James
//       Good day, James!
Public Class Example
    Public Shared Sub Main()
        Console.Write("Hello ")
        Console.WriteLine("World!")
        Console.Write("Enter your name: ")
        Dim name As String = Console.ReadLine()
        Console.Write("Good day, ")
        Console.Write(name)
        Console.WriteLine("!")
    End Sub
End Class 
' The example displays output similar to the following:
'        Hello World!
'        Enter your name: James
'        Good day, James!

Hinweise

Bei der Konsole handelt es sich um ein Betriebssystemfenster, in dem Benutzer mit dem Betriebssystem oder einer textbasierten Konsolenanwendung interagieren, indem Texteingaben über die Computertastatur eingegeben werden und die Textausgabe aus dem Computerterminal gelesen wird.The console is an operating system window where users interact with the operating system or with a text-based console application by entering text input through the computer keyboard, and by reading text output from the computer terminal. Beispielsweise wird im Windows-Betriebssystem die-Konsole als Eingabe Aufforderungs Fenster bezeichnet und akzeptiert MS-DOS-Befehle.For example, in the Windows operating system, the console is called the Command Prompt window and accepts MS-DOS commands. Die Console -Klasse bietet grundlegende Unterstützung für Anwendungen, die Zeichen aus der Konsole lesen und in diese schreiben.The Console class provides basic support for applications that read characters from, and write characters to, the console.

Weitere Informationen zum Entwickeln mit der Console -Klasse finden Sie in den folgenden Abschnitten:For information about developing with the Console class, see the following sections:

Konsolen-e/a-StreamsConsole I/O Streams

Beim Starten einer Konsolenanwendung ordnet das Betriebssystem automatisch drei e/a-Streams der Konsole zu: Standardeingabe Datenstrom, Standardausgabestream und standardfehlerausgabestream.When a console application starts, the operating system automatically associates three I/O streams with the console: standard input stream, standard output stream, and standard error output stream. Die Anwendung kann Benutzereingaben aus dem Standardeingabestream lesen. Schreiben von normalen Daten in den Standardausgabestream und schreiben Fehler Daten in den standardfehlerausgabestream.Your application can read user input from the standard input stream; write normal data to the standard output stream; and write error data to the standard error output stream. Diese Streams werden Ihrer Anwendung als Werte der Console.InEigenschaften, Console.Outund Console.Error angezeigt.These streams are presented to your application as the values of the Console.In, Console.Out, and Console.Error properties.

Standard In mäßig ist der Wert der Out -Eigenschaft ein System.IO.TextReader -Objekt, das die Tastatur darstellt, und die Werte der Eigenschaften Error und sind System.IO.TextWriter Objekte, die ein Konsolenfenster darstellen.By default, the value of the In property is a System.IO.TextReader object that represents the keyboard, and the values of the Out and Error properties are System.IO.TextWriter objects that represent a console window. Sie können diese Eigenschaften jedoch auf Streams festlegen, die das Konsolenfenster oder die Tastatur nicht darstellen. Beispielsweise können Sie diese Eigenschaften auf Streams festlegen, die Dateien darstellen.However, you can set these properties to streams that do not represent the console window or keyboard; for example, you can set these properties to streams that represent files. Rufen Sie die Standardeingabe, Standardausgabe oder Standardfehlerstream umgeleitet, die Console.SetIn, Console.SetOut, oder Console.SetError Methode bzw.To redirect the standard input, standard output, or standard error stream, call the Console.SetIn, Console.SetOut, or Console.SetError method, respectively. E/a-Vorgänge, die diese Streams verwenden, sind synchronisiert. Dies bedeutet, dass mehrere Threads die Datenströme lesen oder in diese schreiben können.I/O operations that use these streams are synchronized, which means that multiple threads can read from, or write to, the streams. Dies bedeutet, dass Methoden, die normalerweise asynchron sind TextReader.ReadLineAsync, wie z. b., synchron ausgeführt werden, wenn das Objekt einen Konsolen Datenstrom darstellt.This means that methods that are ordinarily asynchronous, such as TextReader.ReadLineAsync, execute synchronously if the object represents a console stream.

Hinweis

Verwenden Sie die- Console Klasse nicht zum Anzeigen der Ausgabe in unbeaufsichtigten Anwendungen, wie z. b. Server Anwendungen.Do not use the Console class to display output in unattended applications, such as server applications. Aufrufe von Methoden, wie Console.Write z Console.WriteLine . b. und, haben in GUI-Anwendungen keine Auswirkung.Calls to methods such as Console.Write and Console.WriteLine have no effect in GUI applications.

ConsoleKlassenmember, die normal funktionieren, wenn der zugrunde liegende Stream an eine Konsole geleitet wird, lösen möglicherweise eine Ausnahme aus, wenn der Stream z. b. an eine Datei umgeleitet wird.Console class members that work normally when the underlying stream is directed to a console might throw an exception if the stream is redirected, for example, to a file. Program mieren Sie Ihre Anwendung System.IO.IOException , um Ausnahmen abzufangen, wenn Sie einen Standardstream umleitenProgram your application to catch System.IO.IOException exceptions if you redirect a standard stream. Sie IsOutputRedirectedkönnen auch die Eigenschaften, IsInputRedirectedund IsErrorRedirected verwenden, um zu bestimmen, ob ein Standardstream umgeleitet wird, bevor Sie einen System.IO.IOException Vorgang ausführen, der eine Ausnahme auslöst.You can also use the IsOutputRedirected, IsInputRedirected, and IsErrorRedirected properties to determine whether a standard stream is redirected before performing an operation that throws an System.IO.IOException exception.

Es ist manchmal hilfreich, die Member der Stream-Objekte, die durch die InEigenschaften, und Error dargestellt werden, Outexplizit aufzurufen.It is sometimes useful to explicitly call the members of the stream objects represented by the In, Out, and Error properties. Die Console.ReadLine -Methode liest z. b. standardmäßig Eingaben aus dem Standardeingabestream.For example, by default, the Console.ReadLine method reads input from the standard input stream. Ebenso schreibt die Console.WriteLine -Methode Daten in den Standardausgabestream, und auf die Daten folgt die standardmäßige Zeilen Beendigungs Zeichenfolge, bei der es sich um einen Wagen Rücklauf und einen Zeilenvorschub ("\r\n") handelt.Similarly, the Console.WriteLine method writes data to the standard output stream, and the data is followed by the default line termination string, which is a carriage return and line feed ("\r\n"). Die Console -Klasse stellt jedoch keine entsprechende Methode zum Schreiben von Daten in den standardfehlerausgabestream oder eine Eigenschaft zum Ändern der Zeilen Beendigungs Zeichenfolge für Daten dar, die in diesen Stream geschrieben werden.However, the Console class does not provide a corresponding method to write data to the standard error output stream, or a property to change the line termination string for data written to that stream.

Sie können dieses Problem beheben, indem Sie TextWriter.NewLine die-Eigenschaft Out der Error -Eigenschaft oder der-Eigenschaft auf eine andere zeilenabbruch Zeichenfolge festlegenYou can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. Beispielsweise legt die folgende C# Anweisung die Zeilen Beendigungs Zeichenfolge für den standardfehlerausgabestream auf zwei Wagen Rücklauf-und Zeilenvorschub Sequenzen fest:For example, the following C# statement sets the line termination string for the standard error output stream to two carriage return and line feed sequences:

Console.Error.NewLine = "\r\n\r\n";

Sie können dann die WriteLine -Methode des fehlerausgabestreamobjekts wie in der folgenden C# -Anweisung explizit aufzurufen:You can then explicitly call the WriteLine method of the error output stream object, as in the following C# statement:

Console.Error.WriteLine();

Bildschirm Puffer und KonsolenfensterScreen Buffer and Console Window

Zwei eng verwandte Features der-Konsole sind der Bildschirm Puffer und das Konsolenfenster.Two closely related features of the console are the screen buffer and the console window. Text wird tatsächlich aus Streams gelesen oder in diese geschrieben, die sich im Besitz der Konsole befinden, aber anscheinend aus der Konsole gelesen oder in einen Bereich geschrieben werden, der als Bildschirm Puffer bezeichnet wird.Text is actually read from or written to streams owned by the console, but appear to be read from or written to an area owned by the console called the screen buffer. Der Bildschirm Puffer ist ein Attribut der-Konsole und wird als rechteckiges Raster von Zeilen und Spalten organisiert, wobei jede Raster Überschneidung oder Zeichen Zelle ein Zeichen enthalten kann.The screen buffer is an attribute of the console, and is organized as a rectangular grid of rows and columns where each grid intersection, or character cell, can contain a character. Jedes Zeichen verfügt über eine eigene Vordergrundfarbe, und jede Zeichen Zelle hat eine eigene Hintergrundfarbe.Each character has its own foreground color, and each character cell has its own background color.

Der Bildschirm Puffer wird über einen rechteckigen Bereich angezeigt, der als Konsolenfenster bezeichnet wird.The screen buffer is viewed through a rectangular region called the console window. Das Konsolenfenster ist ein weiteres Attribut der Konsole. Dabei handelt es sich nicht um die Konsole, bei der es sich um ein Betriebssystemfenster handelt.The console window is another attribute of the console; it is not the console itself, which is an operating system window. Das Konsolenfenster wird in Zeilen und Spalten angeordnet, ist kleiner als oder gleich der Größe des Bildschirm Puffers und kann verschoben werden, um unterschiedliche Bereiche des zugrunde liegenden Bildschirm Puffers anzuzeigen.The console window is arranged in rows and columns, is less than or equal to the size of the screen buffer, and can be moved to view different areas of the underlying screen buffer. Wenn der Bildschirm Puffer größer als das Konsolenfenster ist, zeigt die Konsole automatisch Bild Lauf leisten an, damit das Konsolenfenster über dem Bildschirm Pufferbereich neu positioniert werden kann.If the screen buffer is larger than the console window, the console automatically displays scroll bars so the console window can be repositioned over the screen buffer area.

Ein Cursor gibt die Bildschirm Puffer Position an, an der der Text gerade gelesen oder geschrieben wird.A cursor indicates the screen buffer position where text is currently read or written. Der Cursor kann ausgeblendet oder sichtbar gemacht werden, und seine Höhe kann geändert werden.The cursor can be hidden or made visible, and its height can be changed. Wenn der Cursor sichtbar ist, wird die Position des Konsolenfensters automatisch verschoben, sodass sich der Cursor immer in der Ansicht befindet.If the cursor is visible, the console window position is moved automatically so the cursor is always in view.

Der Ursprung für Zeichen Zell Koordinaten im Bildschirm Puffer ist die linke obere Ecke, und die Positionen des Cursors und des Konsolenfensters werden relativ zu diesem Ursprung gemessen.The origin for character cell coordinates in the screen buffer is the upper left corner, and the positions of the cursor and the console window are measured relative to that origin. Verwenden von Null basierten Indizes zum Angeben von Positionen Das heißt, dass die oberste Zeile als Zeile 0 und die Spalte ganz links als Spalte 0 angegeben wird.Use zero-based indexes to specify positions; that is, specify the topmost row as row 0, and the leftmost column as column 0. Der Höchstwert für die Zeilen-und Spalten Indizes Int16.MaxValueist.The maximum value for the row and column indexes is Int16.MaxValue.

Unicode-Unterstützung für die KonsoleUnicode Support for the Console

Im Allgemeinen liest die-Konsole Eingaben und schreibt die Ausgabe mithilfe der aktuellen Konsolen Codepage, die standardmäßig vom System Gebiets Schema definiert wird.In general, the console reads input and writes output by using the current console code page, which the system locale defines by default. Eine Codepage kann nur eine Teilmenge der verfügbaren Unicode-Zeichen verarbeiten. Wenn Sie also versuchen, Zeichen anzuzeigen, die nicht von einer bestimmten Codepage zugeordnet sind, kann die Konsole nicht alle Zeichen anzeigen oder Sie genau darstellen.A code page can handle only a subset of available Unicode characters, so if you try to display characters that are not mapped by a particular code page, the console won't be able to display all characters or represent them accurately. Dieses Problem wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this problem. Es wird versucht, die Zeichen des kyrillischen Alphabets von u + 0410 bis u + 044f auf der Konsole anzuzeigen.It tries to display the characters of the Cyrillic alphabet from U+0410 to U+044F to the console. Wenn Sie das Beispiel auf einem System ausführen, das die Konsolen Codepage 437 verwendet, wird jedes Zeichen durch ein Fragezeichen (?) ersetzt, da kyrillische Zeichen nicht den Zeichen in der Codepage 437 zugeordnet werden.If you run the example on a system that uses console code page 437, each character is replaced by a question mark (?), because Cyrillic characters do not map to the characters in code page 437.

using System;

public class Example
{
   public static void Main()
   {
      // Create a Char array for the modern Cyrillic alphabet, 
      // from U+0410 to U+044F.
      int nChars = 0x044F - 0x0410 + 1;
      char[] chars = new char[nChars];
      ushort codePoint = 0x0410;
      for (int ctr = 0; ctr < chars.Length; ctr++) {
        chars[ctr] = Convert.ToChar(codePoint);
        codePoint++;
      }   
         
      Console.WriteLine("Current code page: {0}\n", 
                        Console.OutputEncoding.CodePage);
      // Display the characters.
      foreach (var ch in chars) {
         Console.Write("{0}  ", ch);
         if (Console.CursorLeft >= 70) 
            Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Current code page: 437
//    
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
Module Example
   Public Sub Main()
      ' Create a Char array for the modern Cyrillic alphabet, 
      ' from U+0410 to U+044F.
      Dim nChars As Integer = &h44F - &h0410
      Dim chars(nChars) As Char
      Dim codePoint As UInt16 = &h0410
      For ctr As Integer = 0 To chars.Length - 1
        chars(ctr) = ChrW(codePoint)
        codePoint += CType(1, UShort)
      Next   
         
      Console.WriteLine("Current code page: {0}", 
                        Console.OutputEncoding.CodePage)
      Console.WriteLine()
      ' Display the characters.
      For Each ch In chars
         Console.Write("{0}  ", ch)
         If Console.CursorLeft >= 70 Then Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       Current code page: 437
'       
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?

Neben der Unterstützung von Codepages Console unterstützt die-Klasse die UTF- UTF8Encoding 8-Codierung mit der-Klasse.In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. Beginnend mit dem .NET Framework 4,5 unterstützt Console die-Klasse auch die UTF-16- UnicodeEncoding Codierung mit der-Klasse.Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. , Um Unicode-Zeichen in der Konsole anzuzeigen.To display Unicode characters to the console. Legen Sie die OutputEncoding -Eigenschaft entweder UTF8Encoding auf UnicodeEncodingoder fest.you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

Die Unterstützung für Unicode-Zeichen erfordert, dass der Encoder ein bestimmtes Unicode-Zeichen erkennt und außerdem eine Schriftart erfordert, die die Symbole enthält, die zum Rendering dieses Zeichens erforderlich sind.Support for Unicode characters requires the encoder to recognize a particular Unicode character, and also requires a font that has the glyphs needed to render that character. Um Unicode-Zeichen erfolgreich in der Konsole anzuzeigen, muss die Konsolen Schriftart auf eine nicht-Raster-oder TrueType-Schriftart wie Consolas oder Lucida Console festgelegt werden.To successfully display Unicode characters to the console, the console font must be set to a non-raster or TrueType font such as Consolas or Lucida Console. Im folgenden Beispiel wird gezeigt, wie Sie die Schriftart Programm gesteuert von einer Raster Schriftart in eine Lucida-Konsole ändern können.The following example shows how you can programmatically change the font from a raster font to Lucida Console.

using System;
using System.Runtime.InteropServices;

public class Example
{
   [DllImport("kernel32.dll", SetLastError = true)]
   static extern IntPtr GetStdHandle(int nStdHandle);

   [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
   static extern bool GetCurrentConsoleFontEx(
          IntPtr consoleOutput, 
          bool maximumWindow,
          ref CONSOLE_FONT_INFO_EX lpConsoleCurrentFontEx);
          
   [DllImport("kernel32.dll", SetLastError = true)]
   static extern bool SetCurrentConsoleFontEx(
          IntPtr consoleOutput, 
          bool maximumWindow,
          CONSOLE_FONT_INFO_EX consoleCurrentFontEx);
   
   private const int STD_OUTPUT_HANDLE = -11;
   private const int TMPF_TRUETYPE = 4;
   private const int LF_FACESIZE = 32;
   private static IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
   
   public static unsafe void Main()
   {
      string fontName = "Lucida Console";
      IntPtr hnd = GetStdHandle(STD_OUTPUT_HANDLE);
      if (hnd != INVALID_HANDLE_VALUE) {
         CONSOLE_FONT_INFO_EX info = new CONSOLE_FONT_INFO_EX();
         info.cbSize = (uint) Marshal.SizeOf(info);
         bool tt = false;
         // First determine whether there's already a TrueType font.
         if (GetCurrentConsoleFontEx(hnd, false, ref info)) {
            tt = (info.FontFamily & TMPF_TRUETYPE) == TMPF_TRUETYPE;
            if (tt) {
               Console.WriteLine("The console already is using a TrueType font.");
               return;
            }
            // Set console font to Lucida Console.
            CONSOLE_FONT_INFO_EX newInfo = new CONSOLE_FONT_INFO_EX();
            newInfo.cbSize = (uint) Marshal.SizeOf(newInfo);          
            newInfo.FontFamily = TMPF_TRUETYPE;
            IntPtr ptr = new IntPtr(newInfo.FaceName);
            Marshal.Copy(fontName.ToCharArray(), 0, ptr, fontName.Length);
            // Get some settings from current font.
            newInfo.dwFontSize = new COORD(info.dwFontSize.X, info.dwFontSize.Y);
            newInfo.FontWeight = info.FontWeight;
            SetCurrentConsoleFontEx(hnd, false, newInfo);
         }
      }    
    }
 
   [StructLayout(LayoutKind.Sequential)]
   internal struct COORD
   {
      internal short X;
      internal short Y;
      
      internal COORD(short x, short y)
      {
         X = x;
         Y = y;
      }
   }
 
   [StructLayout(LayoutKind.Sequential)]
   internal unsafe struct CONSOLE_FONT_INFO_EX 
   {
      internal uint cbSize;
      internal uint nFont;
      internal COORD dwFontSize;
      internal int FontFamily;
      internal int FontWeight;
      internal fixed char FaceName[LF_FACESIZE];
   } 
}
Imports System.Runtime.InteropServices

Public Module Example
   ' <DllImport("kernel32.dll", SetLastError = true)>
   Private Declare Function GetStdHandle Lib "Kernel32" (
                   nStdHandle As Integer) As IntPtr

   ' [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
   Private Declare Function GetCurrentConsoleFontEx Lib "Kernel32" ( 
                   consoleOutput As IntPtr, 
                   maximumWindow As Boolean,
                   ByRef lpConsoleCurrentFontEx As CONSOLE_FONT_INFO_EX) As Boolean
          
   ' [DllImport("kernel32.dll", SetLastError = true)]
   Private Declare Function SetCurrentConsoleFontEx Lib "Kernel32"(
                   consoleOutput As IntPtr, 
                   maximumWindow As Boolean,
                   consoleCurrentFontEx As CONSOLE_FONT_INFO_EX) As Boolean
   
   Private Const STD_OUTPUT_HANDLE As Integer = -11
   Private Const TMPF_TRUETYPE As Integer = 4
   Private Const LF_FACESIZE As Integer= 32
   Private INVALID_HANDLE_VALUE As IntPtr = New IntPtr(-1)
   
   Public Sub Main()
      Dim fontName As String = "Lucida Console"
      Dim hnd As IntPtr = GetStdHandle(STD_OUTPUT_HANDLE)
      If hnd <> INVALID_HANDLE_VALUE Then
         Dim info AS CONSOLE_FONT_INFO_EX = New CONSOLE_FONT_INFO_EX()
         info.cbSize = CUInt(Marshal.SizeOf(info))
         Dim tt As Boolean = False
         ' First determine whether there's already a TrueType font.
         If GetCurrentConsoleFontEx(hnd, False, info) Then
            tt = (info.FontFamily And TMPF_TRUETYPE) = TMPF_TRUETYPE
            If tt Then
               Console.WriteLine("The console already is using a TrueType font.")
               Return
            End If
            ' Set console font to Lucida Console.
            Dim newInfo As CONSOLE_FONT_INFO_EX = New CONSOLE_FONT_INFO_EX()
            newInfo.cbSize = CUInt(Marshal.SizeOf(newInfo))          
            newInfo.FontFamily = TMPF_TRUETYPE
            newInfo.FaceName = fontName
            ' Get some settings from current font.
            newInfo.dwFontSize = New COORD(info.dwFontSize.X, info.dwFontSize.Y)
            newInfo.FontWeight = info.FontWeight
            SetCurrentConsoleFontEx(hnd, False, newInfo)
         End If
      End If    
   End Sub
 
   <StructLayout(LayoutKind.Sequential)> Friend Structure COORD
      Friend X As Short
      Friend Y As Short
      
      Friend Sub New(x As Short, y As Short)
         Me.X = x
         Me.Y = y
      End Sub
   End Structure
 
   <StructLayout(LayoutKind.Sequential, CharSet := CharSet.Unicode)> Friend Structure CONSOLE_FONT_INFO_EX 
      Friend cbSize As UInteger
      Friend nFont As UInteger
      Friend dwFontSize As COORD
      Friend FontFamily As Integer
      Friend FontWeight As Integer
      <MarshalAs(UnmanagedType.ByValTStr, SizeConst := 32)> Friend FaceName As String
   End Structure 
End Module

TrueType-Schriftarten können jedoch nur eine Teilmenge der Symbole anzeigen.However, TrueType fonts can display only a subset of glyphs. Beispielsweise zeigt die Schriftart der Lucida-Konsole nur 643 von ungefähr 64.000 verfügbaren Zeichen von u + 0021 bis U + FB02 an.For example, the Lucida Console font displays only 643 of the approximately 64,000 available characters from U+0021 to U+FB02. Öffnen Sie in der Systemsteuerung das Applet " Fonts ", wählen Sie die Option Zeichen suchen aus, und wählen Sie die Schriftart aus, deren Zeichensatz Sie in der Schriftart Liste der Zeichen Zuordnung untersuchen möchten, um anzuzeigen, welche Zeichen eine bestimmte Schriftart unterstützt. ster.To see which characters a particular font supports, open the Fonts applet in Control Panel, choose the Find a character option, and choose the font whose character set you'd like to examine in the Font list of the Character Map window.

Windows verwendet Schriftart Verknüpfungen, um Symbole anzuzeigen, die in einer bestimmten Schriftart nicht verfügbar sind.Windows uses font linking to display glyphs that are not available in a particular font. Weitere Informationen zum Verknüpfen von Schriftart, um zusätzliche Zeichensätze anzuzeigen , finden Sie unterschritt Weise Anleitung für die Globalisierung: SchriftArten.For information about font linking to display additional character sets, see Globalization Step-by-Step: Fonts. Verknüpfte Schriftarten werden im Unterschlüssel HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows nt\currentversion\fontlink\systemlink der Registrierung definiert.Linked fonts are defined in the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink subkey of the registry. Jeder diesem Unterschlüssel zugeordnete Eintrag entspricht dem Namen einer Basis Schriftart, und sein Wert ist ein Zeichen folgen Array, das die Schriftart Dateien und die Schriftarten definiert, die mit der Basis Schriftart verknüpft sind.Each entry associated with this subkey corresponds to the name of a base font, and its value is a string array that defines the font files and the fonts that are linked to the base font. Jedes Element des Arrays definiert eine verknüpfte Schriftart und hat die Form Schriftart-Dateiname,Schriftart Name.Each member of the array defines a linked font and takes the form font-file-name,font-name. Das folgende Beispiel veranschaulicht, wie Sie eine verknüpfte Schriftart namens Simsun in einer Schriftart Datei mit dem Namen Simsun. TTC, die vereinfachte Han-Zeichen anzeigt, Programm gesteuert definieren können.The following example illustrates how you can programmatically define a linked font named SimSun found in a font file named simsun.ttc that displays Simplified Han characters.

using Microsoft.Win32;
using System;

public class Example
{
   public static void Main()
   {
      string valueName = "Lucida Console";
      string newFont = "simsun.ttc,SimSun";
      string[] fonts = null;
      RegistryValueKind kind = 0; 
      bool toAdd;
      
      RegistryKey key = Registry.LocalMachine.OpenSubKey( 
                 @"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink", 
                 true);
      if (key == null) {
         Console.WriteLine("Font linking is not enabled.");
      }
      else {
         // Determine if the font is a base font.
         string[] names = key.GetValueNames();
         if (Array.Exists(names, s => s.Equals(valueName, 
                                      StringComparison.OrdinalIgnoreCase))) {
            // Get the value's type.
            kind = key.GetValueKind(valueName);

            // Type should be RegistryValueKind.MultiString, but we can't be sure.
            switch (kind) {
               case RegistryValueKind.String:
                  fonts = new string[] { (string) key.GetValue(valueName) };
                  break;   
               case RegistryValueKind.MultiString:
                  fonts = (string[]) key.GetValue(valueName);
                  break;
               case RegistryValueKind.None:
                  // Do nothing.
                  fonts = new string[] { };
                  break;
            } 
            // Determine whether SimSun is a linked font.
            if (Array.FindIndex(fonts, s =>s.IndexOf("SimSun", 
                                       StringComparison.OrdinalIgnoreCase) >=0) >= 0) {
               Console.WriteLine("Font is already linked.");
               toAdd = false;
            }
            else {
               // Font is not a linked font.
               toAdd = true;
            }
         }
         else {
            // Font is not a base font.
            toAdd = true;
            fonts = new string[] { };
         }

         if (toAdd) {  
            Array.Resize(ref fonts, fonts.Length + 1);
            fonts[fonts.GetUpperBound(0)] = newFont;
            // Change REG_SZ to REG_MULTI_SZ.
            if (kind == RegistryValueKind.String)
               key.DeleteValue(valueName, false);

            key.SetValue(valueName, fonts, RegistryValueKind.MultiString);
            Console.WriteLine("SimSun added to the list of linked fonts.");
         }                     
      }
      
      if (key != null) key.Close();
   }
}
Imports Microsoft.Win32

Module Example
   Public Sub Main()
      Dim valueName As String = "Lucida Console"
      Dim newFont As String = "simsun.ttc,SimSun"
      Dim fonts() As String = Nothing
      Dim kind As RegistryValueKind 
      Dim toAdd As Boolean
      
      Dim key As RegistryKey = Registry.LocalMachine.OpenSubKey( 
                 "Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink", 
                 True)
      If key Is Nothing Then
         Console.WriteLine("Font linking is not enabled.")
      Else
         ' Determine if the font is a base font.
         Dim names() As String = key.GetValueNames()
         If Array.Exists(names, Function(s) s.Equals(valueName, 
                                                     StringComparison.OrdinalIgnoreCase))
            ' Get the value's type.
            kind = key.GetValueKind(valueName)

            ' Type should be RegistryValueKind.MultiString, but we can't be sure.
            Select Case kind
               Case RegistryValueKind.String
                  fonts = { CStr(key.GetValue(valueName)) }   
               Case RegistryValueKind.MultiString
                  fonts = CType(key.GetValue(valueName), String())
               Case RegistryValueKind.None
                  ' Do nothing.
                  fonts = { }
            End Select 
            ' Determine whether SimSun is a linked font.
            If Array.FindIndex(fonts, Function(s) s.IndexOf("SimSun", 
                                      StringComparison.OrdinalIgnoreCase) >=0) >= 0 Then
               Console.WriteLine("Font is already linked.")
               toAdd = False
            Else
               ' Font is not a linked font.
               toAdd = True
            End If
         Else
            ' Font is not a base font.
            toAdd = True
            fonts = { }
         End If

         If toAdd Then  
            Array.Resize(fonts, fonts.Length + 1)
            fonts(fonts.GetUpperBound(0)) = newFont
            ' Change REG_SZ to REG_MULTI_SZ.
            If kind = RegistryValueKind.String Then
               key.DeleteValue(valueName, False)
            End If
            key.SetValue(valueName, fonts, RegistryValueKind.MultiString)
            Console.WriteLine("SimSun added to the list of linked fonts.")
         End If                     
      End If
      
      If key IsNot Nothing Then key.Close()
   End Sub
End Module

Für die Unicode-Unterstützung der-Konsole gelten die folgenden Einschränkungen:Unicode support for the console has the following limitations:

  • UTF-32-Codierung wird nicht unterstützt.UTF-32 encoding is not supported. Die einzigen unterstützten Unicode-Codierungen sind UTF-8 und UTF-16, die durch die UTF8Encoding - UnicodeEncoding Klasse bzw. die-Klasse dargestellt werden.The only supported Unicode encodings are UTF-8 and UTF-16, which are represented by the UTF8Encoding and UnicodeEncoding classes, respectively.

  • Die bidirektionale Ausgabe wird nicht unterstützt.Bidirectional output is not supported.

  • Die Anzeige von Zeichen außerhalb der grundlegenden mehrsprachigen Ebene (d. h. von Ersatz Zeichen Paaren) wird nicht unterstützt, auch wenn Sie in einer verknüpften Schriftart Datei definiert sind.Display of characters outside the Basic Multilingual Plane (that is, of surrogate pairs) is not supported, even if they are defined in a linked font file.

  • Die Anzeige von Zeichen in komplexen Skripts wird nicht unterstützt.Display of characters in complex scripts is not supported.

  • Das Kombinieren von Zeichen folgen (d. h. Zeichen, die aus einem Basiszeichen und einem oder mehreren kombinierten Zeichen bestehen) werden als separate Zeichen angezeigt.Combining character sequences (that is, characters that consist of a base character and one or more combining characters) are displayed as separate characters. Um diese Einschränkung zu umgehen, können Sie die anzuzeigende Zeichenfolge normalisieren, indem Sie String.Normalize die-Methode aufrufen, bevor Sie die Ausgabe an die Konsole senden.To work around this limitation, you can normalize the string to be displayed by calling the String.Normalize method before sending output to the console. Im folgenden Beispiel wird der Konsole eine Zeichenfolge, die die kombinierte Zeichen Sequenz u + 0061 U + 0308 enthält, als zwei Zeichen angezeigt, bevor die Ausgabe Zeichenfolge normalisiert wird, und als einzelnes Zeichen String.Normalize , nachdem die-Methode aufgerufen wurde.In the following example, a string that contains the combining character sequence U+0061 U+0308 is displayed to the console as two characters before the output string is normalized, and as a single character after the String.Normalize method is called.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          char[] chars = { '\u0061', '\u0308' };
       
          string combining = new String(chars);
          Console.WriteLine(combining);
          
          combining = combining.Normalize();
          Console.WriteLine(combining);
       }
    }
    // The example displays the following output:
    //       a"
    //       ä
    
    Module Example
       Public Sub Main()
          Dim chars() As Char = { ChrW(&h0061), ChrW(&h0308) }
       
          Dim combining As String = New String(chars)
          Console.WriteLine(combining)
          
          combining = combining.Normalize()
          Console.WriteLine(combining)
       End Sub
    End Module
    ' The example displays the following output:
    '       a"
    '       ä
    

    Beachten Sie, dass die Normalisierung nur dann eine geeignete Lösung ist, wenn der Unicode-Standard für das Zeichen ein vorzusammen gesetztes Formular enthält, das einer bestimmten kombinierten Zeichen Sequenz entspricht.Note that normalization is a viable solution only if the Unicode standard for the character includes a pre-composed form that corresponds to a particular combining character sequence.

  • Wenn eine Schriftart ein Symbol für einen Codepunkt im privaten Verwendungsbereich bereitstellt, wird dieses Symbol angezeigt.If a font provides a glyph for a code point in the private use area, that glyph will be displayed. Da Zeichen im privaten Verwendungsbereich jedoch anwendungsspezifisch sind, ist dies möglicherweise nicht das erwartete Symbol.However, because characters in the private use area are application-specific, this may not be the expected glyph.

Im folgenden Beispiel wird ein Bereich von Unicode-Zeichen in der Konsole angezeigt.The following example displays a range of Unicode characters to the console. Das Beispiel akzeptiert drei Befehlszeilenparameter: den Anfang des anzuzeigenden Bereichs, das Ende des anzuzeigenden Bereichs und ob die aktuelle Konsolen Codierung (false) oder die UTF-16-Codierung (true) verwendet werden soll.The example accepts three command-line parameters: the start of the range to display, the end of the range to display, and whether to use the current console encoding (false) or UTF-16 encoding (true). Dabei wird davon ausgegangen, dass die Konsole eine TrueType-Schriftart verwendet.It assumes that the console is using a TrueType font.

using System;
using System.IO;
using System.Globalization;
using System.Text;

public static class DisplayChars
{
   private static void Main(string[] args)
   {
      uint rangeStart = 0;
      uint rangeEnd = 0;
      bool setOutputEncodingToUnicode = true;
      // Get the current encoding so we can restore it.
      Encoding originalOutputEncoding = Console.OutputEncoding;

    try
    {
         switch(args.Length)
         {
            case 2:
               rangeStart = uint.Parse(args[0], NumberStyles.HexNumber);
               rangeEnd = uint.Parse(args[1], NumberStyles.HexNumber);
               setOutputEncodingToUnicode = true;
               break;
            case 3:
               if (! uint.TryParse(args[0], NumberStyles.HexNumber, null, out rangeStart))
                  throw new ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args[0]));
               
               if (!uint.TryParse(args[1], NumberStyles.HexNumber, null, out rangeEnd))
                  throw new ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args[1]));
               
               bool.TryParse(args[2], out setOutputEncodingToUnicode);
               break;
            default:
               Console.WriteLine("Usage: {0} <{1}> <{2}> [{3}]", 
                                 Environment.GetCommandLineArgs()[0], 
                                 "startingCodePointInHex", 
                                 "endingCodePointInHex", 
                                 "<setOutputEncodingToUnicode?{true|false, default:false}>");
               return;
         }
   
         if (setOutputEncodingToUnicode) {
            // This won't work before .NET Framework 4.5.
            try {
               // Set encoding using endianness of this system.
               // We're interested in displaying individual Char objects, so 
               // we don't want a Unicode BOM or exceptions to be thrown on
               // invalid Char values.
               Console.OutputEncoding = new UnicodeEncoding(! BitConverter.IsLittleEndian, false); 
               Console.WriteLine("\nOutput encoding set to UTF-16");
            }
            catch (IOException) {
               Console.OutputEncoding = new UTF8Encoding();
               Console.WriteLine("Output encoding set to UTF-8");
            }
         }
         else {
            Console.WriteLine("The console encoding is {0} (code page {1})", 
                              Console.OutputEncoding.EncodingName,
                              Console.OutputEncoding.CodePage);
         }
         DisplayRange(rangeStart, rangeEnd);
      }
      catch (ArgumentException ex) {
         Console.WriteLine(ex.Message);
      }
      finally {
         // Restore console environment.
         Console.OutputEncoding = originalOutputEncoding;
      }
   }

   public static void DisplayRange(uint start, uint end)
   {
      const uint upperRange = 0x10FFFF;
      const uint surrogateStart = 0xD800;
      const uint surrogateEnd = 0xDFFF;
       
      if (end <= start) {
         uint t = start;
         start = end;
         end = t;
      }

      // Check whether the start or end range is outside of last plane.
      if (start > upperRange)
         throw new ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{1:X5})",
                                                   start, upperRange));                                   
      if (end > upperRange)
         throw new ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{0:X5})",
                                                   end, upperRange));

      // Since we're using 21-bit code points, we can't use U+D800 to U+DFFF.
      if ((start < surrogateStart & end > surrogateStart) || (start >= surrogateStart & start <= surrogateEnd ))
         throw new ArgumentException(String.Format("0x{0:X5}-0x{1:X5} includes the surrogate pair range 0x{2:X5}-0x{3:X5}", 
                                                   start, end, surrogateStart, surrogateEnd));         
      uint last = RoundUpToMultipleOf(0x10, end);
      uint first = RoundDownToMultipleOf(0x10, start);

      uint rows = (last - first) / 0x10;

      for (uint r = 0; r < rows; ++r) {
         // Display the row header.
         Console.Write("{0:x5} ", first + 0x10 * r);

         for (uint c = 0; c < 0x10; ++c) {
            uint cur = (first + 0x10 * r + c);
            if (cur  < start) {
               Console.Write(" {0} ", Convert.ToChar(0x20));
            }
            else if (end < cur) {
               Console.Write(" {0} ", Convert.ToChar(0x20));
            }
            else {
               // the cast to int is safe, since we know that val <= upperRange.
               String chars = Char.ConvertFromUtf32( (int) cur);
               // Display a space for code points that are not valid characters.
               if (CharUnicodeInfo.GetUnicodeCategory(chars[0]) == 
                                               UnicodeCategory.OtherNotAssigned)
                  Console.Write(" {0} ", Convert.ToChar(0x20));
               // Display a space for code points in the private use area.
               else if (CharUnicodeInfo.GetUnicodeCategory(chars[0]) ==
                                              UnicodeCategory.PrivateUse)
                 Console.Write(" {0} ", Convert.ToChar(0x20));
               // Is surrogate pair a valid character?
               // Note that the console will interpret the high and low surrogate
               // as separate (and unrecognizable) characters.
               else if (chars.Length > 1 && CharUnicodeInfo.GetUnicodeCategory(chars, 0) == 
                                            UnicodeCategory.OtherNotAssigned)
                  Console.Write(" {0} ", Convert.ToChar(0x20));
               else
                  Console.Write(" {0} ", chars); 
            }
            
            switch (c) {
               case 3: case 11:
                  Console.Write("-");
                  break;
               case 7:
                  Console.Write("--");
                  break;
            }
         }

         Console.WriteLine();
         if (0 < r && r % 0x10 == 0)
            Console.WriteLine();
      }
   }

   private static uint RoundUpToMultipleOf(uint b, uint u)
   {
      return RoundDownToMultipleOf(b, u) + b;
   }

   private static uint RoundDownToMultipleOf(uint b, uint u)
   {
      return u - (u % b);
   }
}
// If the example is run with the command line
//       DisplayChars 0400 04FF true
// the example displays the Cyrillic character set as follows:
//       Output encoding set to UTF-16
//       00400  Ѐ  Ё  Ђ  Ѓ - Є  Ѕ  І  Ї -- Ј  Љ  Њ  Ћ - Ќ  Ѝ  Ў  Џ
//       00410  А  Б  В  Г - Д  Е  Ж  З -- И  Й  К  Л - М  Н  О  П
//       00420  Р  С  Т  У - Ф  Х  Ц  Ч -- Ш  Щ  Ъ  Ы - Ь  Э  Ю  Я
//       00430  а  б  в  г - д  е  ж  з -- и  й  к  л - м  н  о  п
//       00440  р  с  т  у - ф  х  ц  ч -- ш  щ  ъ  ы - ь  э  ю  я
//       00450  ѐ  ё  ђ  ѓ - є  ѕ  і  ї -- ј  љ  њ  ћ - ќ  ѝ  ў  џ
//       00460  Ѡ  ѡ  Ѣ  ѣ - Ѥ  ѥ  Ѧ  ѧ -- Ѩ  ѩ  Ѫ  ѫ - Ѭ  ѭ  Ѯ  ѯ
//       00470  Ѱ  ѱ  Ѳ  ѳ - Ѵ  ѵ  Ѷ  ѷ -- Ѹ  ѹ  Ѻ  ѻ - Ѽ  ѽ  Ѿ  ѿ
//       00480  Ҁ  ҁ  ҂  ҃ - ҄  ҅  ҆  ҇ -- ҈  ҉  Ҋ  ҋ - Ҍ  ҍ  Ҏ  ҏ
//       00490  Ґ  ґ  Ғ  ғ - Ҕ  ҕ  Җ  җ -- Ҙ  ҙ  Қ  қ - Ҝ  ҝ  Ҟ  ҟ
//       004a0  Ҡ  ҡ  Ң  ң - Ҥ  ҥ  Ҧ  ҧ -- Ҩ  ҩ  Ҫ  ҫ - Ҭ  ҭ  Ү  ү
//       004b0  Ұ  ұ  Ҳ  ҳ - Ҵ  ҵ  Ҷ  ҷ -- Ҹ  ҹ  Һ  һ - Ҽ  ҽ  Ҿ  ҿ
//       004c0  Ӏ  Ӂ  ӂ  Ӄ - ӄ  Ӆ  ӆ  Ӈ -- ӈ  Ӊ  ӊ  Ӌ - ӌ  Ӎ  ӎ  ӏ
//       004d0  Ӑ  ӑ  Ӓ  ӓ - Ӕ  ӕ  Ӗ  ӗ -- Ә  ә  Ӛ  ӛ - Ӝ  ӝ  Ӟ  ӟ
//       004e0  Ӡ  ӡ  Ӣ  ӣ - Ӥ  ӥ  Ӧ  ӧ -- Ө  ө  Ӫ  ӫ - Ӭ  ӭ  Ӯ  ӯ
//       004f0  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ
Imports System.IO
Imports System.Globalization
Imports System.Text

Public Module DisplayChars
   Public Sub Main(args() As String)
      Dim rangeStart As UInteger = 0
      Dim rangeEnd As UInteger = 0
      Dim setOutputEncodingToUnicode As Boolean = True
      ' Get the current encoding so we can restore it.
      Dim originalOutputEncoding As Encoding = Console.OutputEncoding

    Try
         Select Case args.Length
            Case 2
               rangeStart = UInt32.Parse(args(0), NumberStyles.HexNumber)
               rangeEnd = UInt32.Parse(args(1), NumberStyles.HexNumber)
               setOutputEncodingToUnicode = True
            Case 3
               If Not UInt32.TryParse(args(0), NumberStyles.HexNumber, Nothing, rangeStart) Then
                  Throw New ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args(0)))
               End If
               
               If Not UInt32.TryParse(args(1), NumberStyles.HexNumber, Nothing, rangeEnd) Then
                  Throw New ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args(1)))
               End If
               
               Boolean.TryParse(args(2), setOutputEncodingToUnicode)
            Case Else
               Console.WriteLine("Usage: {0} <{1}> <{2}> [{3}]", 
                                 Environment.GetCommandLineArgs()(0), 
                                 "startingCodePointInHex", 
                                 "endingCodePointInHex", 
                                 "<setOutputEncodingToUnicode?{true|false, default:false}>")
               Exit Sub
         End Select
   
         If setOutputEncodingToUnicode Then
            ' This won't work before .NET Framework 4.5.
            Try 
               ' Set encoding Imports endianness of this system.
               ' We're interested in displaying individual Char objects, so 
               ' we don't want a Unicode BOM or exceptions to be thrown on
               ' invalid Char values.
               Console.OutputEncoding = New UnicodeEncoding(Not BitConverter.IsLittleEndian, False) 
               Console.WriteLine("{0}Output encoding set to UTF-16", vbCrLf)
            Catch e As IOException
               Console.OutputEncoding = New UTF8Encoding()
               Console.WriteLine("Output encoding set to UTF-8")
            End Try
         Else
            Console.WriteLine("The console encoding is {0} (code page {1})", 
                              Console.OutputEncoding.EncodingName,
                              Console.OutputEncoding.CodePage)
         End If
         DisplayRange(rangeStart, rangeEnd)
      Catch ex As ArgumentException
         Console.WriteLine(ex.Message)
      Finally
         ' Restore console environment.
         Console.OutputEncoding = originalOutputEncoding
      End Try
   End Sub

   Public Sub DisplayRange(rangeStart As UInteger, rangeEnd As UInteger)
      Const upperRange As UInteger = &h10FFFF
      Const surrogateStart As UInteger = &hD800
      Const surrogateEnd As UInteger = &hDFFF
       
      If rangeEnd <= rangeStart Then
         Dim t As UInteger = rangeStart
         rangeStart = rangeEnd
         rangeEnd = t
      End If

      ' Check whether the start or end range is outside of last plane.
      If rangeStart > upperRange Then
         Throw New ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{1:X5})",
                                                   rangeStart, upperRange))                                   
      End If
      If rangeEnd > upperRange Then
         Throw New ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{0:X5})",
                                                   rangeEnd, upperRange))
      End If
      ' Since we're using 21-bit code points, we can't use U+D800 to U+DFFF.
      If (rangeStart < surrogateStart And rangeEnd > surrogateStart) OrElse (rangeStart >= surrogateStart And rangeStart <= surrogateEnd )
         Throw New ArgumentException(String.Format("0x{0:X5}-0x{1:X5} includes the surrogate pair range 0x{2:X5}-0x{3:X5}", 
                                                   rangeStart, rangeEnd, surrogateStart, surrogateEnd))         
      End If
      
      Dim last As UInteger = RoundUpToMultipleOf(&h10, rangeEnd)
      Dim first As UInteger = RoundDownToMultipleOf(&h10, rangeStart)

      Dim rows As UInteger = (last - first) \ &h10

      For r As UInteger = 0 To rows - 1
         ' Display the row header.
         Console.Write("{0:x5} ", first + &h10 * r)

         For c As UInteger = 1 To &h10
            Dim cur As UInteger = first + &h10 * r + c
            If cur  < rangeStart Then
               Console.Write(" {0} ", Convert.ToChar(&h20))
            Else If rangeEnd < cur Then
               Console.Write(" {0} ", Convert.ToChar(&h20))
            Else 
               ' the cast to int is safe, since we know that val <= upperRange.
               Dim chars As String = Char.ConvertFromUtf32(CInt(cur))
               ' Display a space for code points that are not valid characters.
               If CharUnicodeInfo.GetUnicodeCategory(chars(0)) = 
                                   UnicodeCategory.OtherNotAssigned Then
                  Console.Write(" {0} ", Convert.ToChar(&h20))
               ' Display a space for code points in the private use area.
               Else If CharUnicodeInfo.GetUnicodeCategory(chars(0)) =
                                        UnicodeCategory.PrivateUse Then
                 Console.Write(" {0} ", Convert.ToChar(&h20))
               ' Is surrogate pair a valid character?
               ' Note that the console will interpret the high and low surrogate
               ' as separate (and unrecognizable) characters.
               Else If chars.Length > 1 AndAlso CharUnicodeInfo.GetUnicodeCategory(chars, 0) = 
                                            UnicodeCategory.OtherNotAssigned Then
                  Console.Write(" {0} ", Convert.ToChar(&h20))
               Else
                  Console.Write(" {0} ", chars) 
               End If   
            End If
            
            Select Case c
               Case 3, 11
                  Console.Write("-")
               Case 7
                  Console.Write("--")
            End Select
         Next

         Console.WriteLine()
         If 0 < r AndAlso r Mod &h10 = 0
            Console.WriteLine()
         End If
      Next
   End Sub

   Private Function RoundUpToMultipleOf(b As UInteger, u As UInteger) As UInteger
      Return RoundDownToMultipleOf(b, u) + b
   End Function

   Private Function RoundDownToMultipleOf(b As UInteger, u As UInteger) As UInteger
      Return u - (u Mod b)
   End Function
End Module
' If the example is run with the command line
'       DisplayChars 0400 04FF true
' the example displays the Cyrillic character set as follows:
'       Output encoding set to UTF-16
'       00400  Ѐ  Ё  Ђ  Ѓ - Є  Ѕ  І  Ї -- Ј  Љ  Њ  Ћ - Ќ  Ѝ  Ў  Џ
'       00410  А  Б  В  Г - Д  Е  Ж  З -- И  Й  К  Л - М  Н  О  П
'       00420  Р  С  Т  У - Ф  Х  Ц  Ч -- Ш  Щ  Ъ  Ы - Ь  Э  Ю  Я
'       00430  а  б  в  г - д  е  ж  з -- и  й  к  л - м  н  о  п
'       00440  р  с  т  у - ф  х  ц  ч -- ш  щ  ъ  ы - ь  э  ю  я
'       00450  ѐ  ё  ђ  ѓ - є  ѕ  і  ї -- ј  љ  њ  ћ - ќ  ѝ  ў  џ
'       00460  Ѡ  ѡ  Ѣ  ѣ - Ѥ  ѥ  Ѧ  ѧ -- Ѩ  ѩ  Ѫ  ѫ - Ѭ  ѭ  Ѯ  ѯ
'       00470  Ѱ  ѱ  Ѳ  ѳ - Ѵ  ѵ  Ѷ  ѷ -- Ѹ  ѹ  Ѻ  ѻ - Ѽ  ѽ  Ѿ  ѿ
'       00480  Ҁ  ҁ  ҂  ҃ - ҄  ҅  ҆  ҇ -- ҈  ҉  Ҋ  ҋ - Ҍ  ҍ  Ҏ  ҏ
'       00490  Ґ  ґ  Ғ  ғ - Ҕ  ҕ  Җ  җ -- Ҙ  ҙ  Қ  қ - Ҝ  ҝ  Ҟ  ҟ
'       004a0  Ҡ  ҡ  Ң  ң - Ҥ  ҥ  Ҧ  ҧ -- Ҩ  ҩ  Ҫ  ҫ - Ҭ  ҭ  Ү  ү
'       004b0  Ұ  ұ  Ҳ  ҳ - Ҵ  ҵ  Ҷ  ҷ -- Ҹ  ҹ  Һ  һ - Ҽ  ҽ  Ҿ  ҿ
'       004c0  Ӏ  Ӂ  ӂ  Ӄ - ӄ  Ӆ  ӆ  Ӈ -- ӈ  Ӊ  ӊ  Ӌ - ӌ  Ӎ  ӎ  ӏ
'       004d0  Ӑ  ӑ  Ӓ  ӓ - Ӕ  ӕ  Ӗ  ӗ -- Ә  ә  Ӛ  ӛ - Ӝ  ӝ  Ӟ  ӟ
'       004e0  Ӡ  ӡ  Ӣ  ӣ - Ӥ  ӥ  Ӧ  ӧ -- Ө  ө  Ӫ  ӫ - Ӭ  ӭ  Ӯ  ӯ
'       004f0  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ

Allgemeine VorgängeCommon Operations

Die Console -Klasse enthält die folgenden Methoden zum Lesen von Konsolen Eingaben und zum Schreiben der Konsolenausgabe:The Console class contains the following methods for reading console input and writing console output:

  • Die über Ladungen der ReadKey -Methode lesen ein einzelnes Zeichen.The overloads of the ReadKey method read an individual character.

  • Die ReadLine -Methode liest eine ganze Zeile der Eingabe.The ReadLine method reads an entire line of input.

  • Die Write -Methoden Überladungen konvertieren eine Instanz eines Werttyps, eines Zeichen Arrays oder eines Satzes von Objekten in eine formatierte oder unformatierte Zeichenfolge und schreiben diese Zeichenfolge dann in die Konsole.The Write method overloads convert an instance of a value type, an array of characters, or a set of objects to a formatted or unformatted string, and then write that string to the console.

  • Ein paralleler Satz WriteLine von Methoden Überladungen gibt dieselbe Zeichenfolge wie Write die über Ladungen aus, aber auch eine Zeichenfolge für die Zeilen Beendigung.A parallel set of WriteLine method overloads output the same string as the Write overloads but also add a line termination string.

Die Console -Klasse enthält auch Methoden und Eigenschaften, mit denen die folgenden Vorgänge durchgeführt werden können:The Console class also contains methods and properties to perform the following operations:

  • Gibt die Größe des Bildschirm Puffers an oder legt Sie fest.Get or set the size of the screen buffer. Mit BufferHeight der BufferWidth -Eigenschaft und der-Eigenschaft können Sie die Puffer Höhe und-Breite abrufen bzw SetBufferSize . festlegen, und mit der-Methode können Sie die Puffergröße in einem einzelnen Methoden Aufrufsatz festlegen.The BufferHeight and BufferWidth properties let you get or set the buffer height and width, respectively, and the SetBufferSize method lets you set the buffer size in a single method call.

  • Gibt die Größe des Konsolenfensters an oder legt Sie fest.Get or set the size of the console window. Mit WindowHeight der WindowWidth -Eigenschaft und der-Eigenschaft können Sie die Fensterhöhe und-Breite abrufen bzw SetWindowSize . festlegen, und mit der-Methode können Sie die Fenstergröße in einem einzelnen Methoden Aufrufsatz festlegen.The WindowHeight and WindowWidth properties let you get or set the window height and width, respectively, and the SetWindowSize method lets you set the window size in a single method call.

  • Gibt die Größe des Cursors an oder legt Sie fest.Get or set the size of the cursor. Die CursorSize -Eigenschaft gibt die Höhe des Cursors in einer Zeichen Zelle an.The CursorSize property specifies the height of the cursor in a character cell.

  • Gibt die Position des Konsolenfensters relativ zum Bildschirm Puffer an oder legt diese fest.Get or set the position of the console window relative to the screen buffer. Mit WindowTop der WindowLeft -Eigenschaft und der-Eigenschaft können Sie die oberste Zeile und die ganz links stehende Spalte des Bildschirm Puffers, der im Konsolenfenster angezeigt SetWindowPosition wird, Abrufen oder festlegen, und mit der-Methode können Sie diese Werte in einem einzelnen Methoden Aufrufsatz festlegen.The WindowTop and WindowLeft properties let you get or set the top row and leftmost column of the screen buffer that appears in the console window, and the SetWindowPosition method lets you set these values in a single method call.

  • Ruft die Position des Cursors ab oder legt Sie fest, indem die CursorTop - CursorLeft Eigenschaft und die-Eigenschaft festgelegt werden oder die Position des SetCursorPosition Cursors durch Aufrufen der-Methode festgelegt wird.Get or set the position of the cursor by getting or setting the CursorTop and CursorLeft properties, or set the position of the cursor by calling the SetCursorPosition method.

  • Verschieben oder löschen Sie Daten im Bildschirm Puffer, indem Sie MoveBufferArea die Clear -Methode oder die-Methode aufrufen.Move or clear data in the screen buffer by calling the MoveBufferArea or Clear method.

  • Rufen Sie die Vordergrund-und Hintergrundfarben mithilfe der ForegroundColor - BackgroundColor Eigenschaft und der-Eigenschaft ab, oder setzen Sie den Hintergrund und den Vorder ResetColor Grund durch Aufrufen der-Methode auf ihre Standardfarben zurück.Get or set the foreground and background colors by using the ForegroundColor and BackgroundColor properties, or reset the background and foreground to their default colors by calling the ResetColor method.

  • Geben Sie den Sound eines Signal durch den Konsolen Sprecher ein, indem Sie Beep die-Methode aufrufen.Play the sound of a beep through the console speaker by calling the Beep method.

.NET Core.NET Core Anmerkungen zu dieser VersionNotes

In der .NET Framework auf dem Desktop verwendet die Console -Klasse die von GetConsoleCP und GetConsoleOutputCPzurückgegebene Codierung, bei der es sich in der Regel um eine Code Page Codierung handelt.In the .NET Framework on the desktop, the Console class uses the encoding returned by GetConsoleCP and GetConsoleOutputCP, which typically is a code page encoding. Beispielsweise handelt es sich bei Systemen, deren Kultur Englisch (USA) ist, auf der Codepage 437, die standardmäßig verwendet wird.For example code, on systems whose culture is English (United States), code page 437 is the encoding that is used by default. Es ist .NET Core.NET Core jedoch möglich, dass nur eine begrenzte Teilmenge dieser Codierungen verfügbar ist.However, .NET Core.NET Core may make only a limited subset of these encodings available. Wenn dies der Fall ist, Encoding.UTF8 wird als Standard Codierung für die Konsole verwendet.Where this is the case, Encoding.UTF8 is used as the default encoding for the console.

Wenn Ihre APP von bestimmten Code Page Codierungen abhängig ist, können Sie Sie trotzdem verfügbar machen, indem Sie ** die folgenden Schritte ausführen Console , bevor Sie Methoden aufzurufen:If your app depends on specific code page encodings, you can still make them available by doing the following before you call any Console methods:

  1. Fügen Sie dem Projekt einen Verweis auf die System. Text. Encoding. Codepages. dll-Assembly hinzu.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Rufen Sie EncodingProvider das-Objekt CodePagesEncodingProvider.Instance aus der-Eigenschaft ab.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Übergeben Sie EncodingProvider das-Objekt Encoding.RegisterProvider an die-Methode, um die zusätzlichen Codierungen bereitzustellen, die vom Codierungs Anbieter unterstützt werden.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

Die Console Klasse verwendet dann automatisch die Standardsystem Codierung anstelle von Console UTF8, vorausgesetzt, dass Sie den Codierungs Anbieter registriert haben, bevor Sie Ausgabemethoden aufrufen.The Console class will then automatically use the default system encoding rather than UTF8, provided that you have registered the encoding provider before calling any Console output methods.

Eigenschaften

BackgroundColor

Ruft die Hintergrundfarbe der Konsole ab oder legt diese fest.Gets or sets the background color of the console.

BufferHeight

Ruft die Höhe des Pufferbereichs ab oder legt diese fest.Gets or sets the height of the buffer area.

BufferWidth

Ruft die Breite des Pufferbereichs ab oder legt diese fest.Gets or sets the width of the buffer area.

CapsLock

Ruft einen Wert ab, der angibt, ob die FESTSTELLTASTE-Tastaturumschalttaste aktiviert oder deaktiviert ist.Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft

Ruft die Spaltenposition des Cursors im Pufferbereich ab oder legt diese fest.Gets or sets the column position of the cursor within the buffer area.

CursorSize

Ruft die Höhe des Cursors innerhalb einer Zeichenzelle ab oder legt diese fest.Gets or sets the height of the cursor within a character cell.

CursorTop

Ruft die Zeilenposition des Cursors im Pufferbereich ab oder legt diese fest.Gets or sets the row position of the cursor within the buffer area.

CursorVisible

Ruft einen Wert ab, der angibt, ob der Cursor sichtbar ist, oder legt diesen fest.Gets or sets a value indicating whether the cursor is visible.

Error

Ruft den Standard-Fehlerausgabestream ab.Gets the standard error output stream.

ForegroundColor

Ruft die Vordergrundfarbe der Konsole ab oder legt diese fest.Gets or sets the foreground color of the console.

In

Ruft den Standardeingabestream ab.Gets the standard input stream.

InputEncoding

Ruft die Codierung ab, die die Konsole verwendet, um die Eingabe zu lesen, oder legt diese fest.Gets or sets the encoding the console uses to read input.

IsErrorRedirected

Ruft einen Wert ab, der angibt, ob der Fehlerausgabedatenstrom von dem Standardfehlerstream umgeleitet wurde.Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected

Ruft einen Wert ab, der angibt, ob die Eingabe aus dem Standardeingabestream umgeleitet wurde.Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected

Ruft einen Wert ab, der angibt, ob die Ausgabe aus dem Standardausgabestream umgeleitet wurde.Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable

Ruft einen Wert ab, der angibt, ob ein Tastendruck im Eingabestream vorhanden ist.Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight

Ruft die entsprechend der aktuellen Schriftart und Bildschirmauflösung größtmögliche Anzahl von Konsolenfensterzeilen ab.Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth

Ruft die entsprechend der aktuellen Schriftart und Bildschirmauflösung größtmögliche Anzahl von Konsolenfensterspalten ab.Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock

Ruft einen Wert ab, der angibt, ob die NUM-Tastaturumschalttaste aktiviert oder deaktiviert ist.Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out

Ruft den Standardausgabestream ab.Gets the standard output stream.

OutputEncoding

Ruft die Codierung ab, die die Konsole verwendet, um die Ausgabe zu schreiben, oder legt diese fest.Gets or sets the encoding the console uses to write output.

Title

Ruft den auf der Konsolentitelleiste anzuzeigenden Titel ab oder legt diesen fest.Gets or sets the title to display in the console title bar.

TreatControlCAsInput

Ruft einen Wert ab oder legt diesen fest, der angibt, ob die Kombination der Control-Modifizierertaste und der C-Konsolentaste (STRG+C) als normale Eingabe oder als vom Betriebssystem zu behandelnde Unterbrechung behandelt wird.Gets or sets a value indicating whether the combination of the Control modifier key and C console key (Ctrl+C) is treated as ordinary input or as an interruption that is handled by the operating system.

WindowHeight

Ruft die Höhe des Konsolenfensterbereichs ab oder legt diese fest.Gets or sets the height of the console window area.

WindowLeft

Ruft die am weitesten links stehende Position des Konsolenfensterbereichs im Verhältnis zum Bildschirmpuffer ab oder legt diese fest.Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop

Ruft die oberste Position des Konsolenfensterbereichs im Verhältnis zum Bildschirmpuffer ab oder legt diese fest.Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth

Ruft die Breite des Konsolenfensters ab oder legt diese fest.Gets or sets the width of the console window.

Methoden

Beep()

Gibt den Sound eines Signaltons auf dem Konsolenlautsprecher wieder.Plays the sound of a beep through the console speaker.

Beep(Int32, Int32)

Gibt den Sound eines Signaltons mit einer angegebenen Frequenz und Dauer auf dem Konsolenlautsprecher wieder.Plays the sound of a beep of a specified frequency and duration through the console speaker.

Clear()

Löscht die Anzeigeinformationen aus dem Konsolenpuffer und dem entsprechenden Konsolenfenster.Clears the console buffer and corresponding console window of display information.

MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32)

Kopiert einen angegebenen Quellbereich des Bildschirmpuffers in einen angegebenen Zielbereich.Copies a specified source area of the screen buffer to a specified destination area.

MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor)

Kopiert einen angegebenen Quellbereich des Bildschirmpuffers in einen angegebenen Zielbereich.Copies a specified source area of the screen buffer to a specified destination area.

OpenStandardError()

Ruft den Standardfehlerstream ab.Acquires the standard error stream.

OpenStandardError(Int32)

Ruft den Standardfehlerstream ab, der auf eine angegebene Puffergröße festgelegt wird.Acquires the standard error stream, which is set to a specified buffer size.

OpenStandardInput()

Ruft den Standardeingabestream ab.Acquires the standard input stream.

OpenStandardInput(Int32)

Ruft den Standardeingabestream ab, der auf eine angegebene Puffergröße festgelegt wird.Acquires the standard input stream, which is set to a specified buffer size.

OpenStandardOutput()

Ruft den Standardausgabestream ab.Acquires the standard output stream.

OpenStandardOutput(Int32)

Ruft den Standardausgabestream ab, der auf eine angegebene Puffergröße festgelegt wird.Acquires the standard output stream, which is set to a specified buffer size.

Read()

Liest das nächste Zeichen aus dem Standardeingabestream.Reads the next character from the standard input stream.

ReadKey()

Ruft die nächste vom Benutzer gedrückte Zeichen- oder Funktionstaste ab.Obtains the next character or function key pressed by the user. Die gedrückte Taste wird im Konsolenfenster angezeigt.The pressed key is displayed in the console window.

ReadKey(Boolean)

Ruft die nächste vom Benutzer gedrückte Zeichen- oder Funktionstaste ab.Obtains the next character or function key pressed by the user. Die gedrückte Taste wird optional im Konsolenfenster angezeigt.The pressed key is optionally displayed in the console window.

ReadLine()

Liest die nächste Zeile von Zeichen aus dem Standardeingabestream.Reads the next line of characters from the standard input stream.

ResetColor()

Legt die Vordergrund- und Hintergrundkonsolenfarben auf die entsprechenden Standardwerte fest.Sets the foreground and background console colors to their defaults.

SetBufferSize(Int32, Int32)

Legt die Höhe und die Breite des Bildschirmpufferbereichs auf die angegebenen Werte fest.Sets the height and width of the screen buffer area to the specified values.

SetCursorPosition(Int32, Int32)

Legt die Position des Cursors fest.Sets the position of the cursor.

SetError(TextWriter)

Legt die Error-Eigenschaft auf den angegebenen TextWriter fest.Sets the Error property to the specified TextWriter object.

SetIn(TextReader)

Legt die In-Eigenschaft auf den angegebenen TextReader fest.Sets the In property to the specified TextReader object.

SetOut(TextWriter)

Legt die Out-Eigenschaft fest, die auf das TextWriter-Objekt ausgerichtet ist.Sets the Out property to target the TextWriter object.

SetWindowPosition(Int32, Int32)

Legt die Position des Konsolenfensters relativ zum Bildschirmpuffer fest.Sets the position of the console window relative to the screen buffer.

SetWindowSize(Int32, Int32)

Legt die Höhe und die Breite des Konsolenfensters auf die angegebenen Werte fest.Sets the height and width of the console window to the specified values.

Write(Boolean)

Schreibt die Textdarstellung des angegebenen booleschen Werts in den Standardausgabestream.Writes the text representation of the specified Boolean value to the standard output stream.

Write(Char)

Schreibt das angegebene Unicode-Zeichen in den Standardausgabestream.Writes the specified Unicode character value to the standard output stream.

Write(Char[])

Schreibt das angegebene Array von Unicode-Zeichen in den Standardausgabestream.Writes the specified array of Unicode characters to the standard output stream.

Write(Char[], Int32, Int32)

Schreibt das angegebene Unterarray von Unicode-Zeichen in den Standardausgabestream.Writes the specified subarray of Unicode characters to the standard output stream.

Write(Decimal)

Schreibt die Textdarstellung des angegebenen Decimal-Werts in den Standardausgabestream.Writes the text representation of the specified Decimal value to the standard output stream.

Write(Double)

Schreibt die Textdarstellung der angegebenen Gleitkommazahl mit doppelter Genauigkeit in den Standardausgabestream.Writes the text representation of the specified double-precision floating-point value to the standard output stream.

Write(Int32)

Schreibt die Textdarstellung der angegebenen 32-Bit-Ganzzahl mit Vorzeichen in den Standardausgabestream.Writes the text representation of the specified 32-bit signed integer value to the standard output stream.

Write(Int64)

Schreibt die Textdarstellung der angegebenen 64-Bit-Ganzzahl mit Vorzeichen in den Standardausgabestream.Writes the text representation of the specified 64-bit signed integer value to the standard output stream.

Write(Object)

Schreibt die Textdarstellung des angegebenen Objekts in den Standardausgabestream.Writes the text representation of the specified object to the standard output stream.

Write(Single)

Schreibt die Textdarstellung der angegebenen Gleitkommazahl mit einfacher Genauigkeit in den Standardausgabestream.Writes the text representation of the specified single-precision floating-point value to the standard output stream.

Write(String)

Schreibt die angegebene Zeichenfolge in den Standardausgabestream.Writes the specified string value to the standard output stream.

Write(String, Object)

Schreibt die Textdarstellung des angegebenen Objekts unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified object to the standard output stream using the specified format information.

Write(String, Object, Object)

Schreibt die Textdarstellung der angegebenen Objekte unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified objects to the standard output stream using the specified format information.

Write(String, Object, Object, Object)

Schreibt die Textdarstellung der angegebenen Objekte unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified objects to the standard output stream using the specified format information.

Write(String, Object, Object, Object, Object)

Schreibt die Textdarstellung der angegebenen Objekte und der Parameterliste von variabler Länge unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified objects and variable-length parameter list to the standard output stream using the specified format information.

Write(String, Object[])

Schreibt die Textdarstellung des angegebenen Arrays von Objekten unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified array of objects to the standard output stream using the specified format information.

Write(UInt32)

Schreibt die Textdarstellung der angegebenen 32-Bit-Ganzzahl ohne Vorzeichen in den Standardausgabestream.Writes the text representation of the specified 32-bit unsigned integer value to the standard output stream.

Write(UInt64)

Schreibt die Textdarstellung der angegebenen 64-Bit-Ganzzahl ohne Vorzeichen in den Standardausgabestream.Writes the text representation of the specified 64-bit unsigned integer value to the standard output stream.

WriteLine()

Schreibt das aktuelle Zeichen für den Zeilenabschluss in den Standardausgabestream.Writes the current line terminator to the standard output stream.

WriteLine(Boolean)

Schreibt die Textdarstellung des angegebenen booleschen Werts, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

WriteLine(Char)

Schreibt das angegebene Unicode-Zeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the specified Unicode character, followed by the current line terminator, value to the standard output stream.

WriteLine(Char[])

Schreibt das angegebenen Array von Unicode-Zeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the specified array of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(Char[], Int32, Int32)

Schreibt das angegebene Unterarray von Unicode-Zeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the specified subarray of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(Decimal)

Schreibt die Textdarstellung des angegebenen Decimal-Werts, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified Decimal value, followed by the current line terminator, to the standard output stream.

WriteLine(Double)

Schreibt die Textdarstellung der angegebenen Gleitkommazahl mit doppelter Genauigkeit, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified double-precision floating-point value, followed by the current line terminator, to the standard output stream.

WriteLine(Int32)

Schreibt die Textdarstellung der angegebenen 32-Bit-Ganzzahl mit Vorzeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified 32-bit signed integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Int64)

Schreibt die Textdarstellung der angegebenen 64-Bit-Ganzzahl mit Vorzeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified 64-bit signed integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Object)

Schreibt die Textdarstellung des angegebenen Objekts, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream.

WriteLine(Single)

Schreibt die Textdarstellung der angegebenen Gleitkommazahl mit einfacher Genauigkeit, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified single-precision floating-point value, followed by the current line terminator, to the standard output stream.

WriteLine(String)

Schreibt den angegebenen Zeichenfolgenwert, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the specified string value, followed by the current line terminator, to the standard output stream.

WriteLine(String, Object)

Schreibt die Textdarstellung des angegebenen Objekts, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(String, Object, Object)

Schreibt die Textdarstellung der angegebenen Objekte, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(String, Object, Object, Object)

Schreibt die Textdarstellung der angegebenen Objekte, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(String, Object, Object, Object, Object)

Schreibt die Textdarstellung der angegebenen Objekte und der Parameterliste variabler Länge, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified objects and variable-length parameter list, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(String, Object[])

Schreibt die Textdarstellung des angegebenen Arrays von Objekten, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream.Writes the text representation of the specified array of objects, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(UInt32)

Schreibt die Textdarstellung der angegebenen 32-Bit-Ganzzahl ohne Vorzeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified 32-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

WriteLine(UInt64)

Schreibt die Textdarstellung der angegebenen 64-Bit-Ganzzahl ohne Vorzeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream.Writes the text representation of the specified 64-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

Ereignisse

CancelKeyPress

Tritt ein, wenn die Control-Modifizierertaste (STRG) und entweder die C-Konsolentaste (c) oder die UNTBR-TASTE gleichzeitig gedrückt werden (STRG+C oder STRG+UNTBR).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).

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.This type is thread safe.