Console Klasse
Definition
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.
Stellt die Standardstreams für Eingabe, Ausgabe und Fehler bei Konsolenanwendungen dar. Diese Klasse kann nicht vererbt werden.
public ref class Console abstract sealedpublic ref class Console sealedpublic static class Consolepublic sealed class Consoletype Console = classPublic Class ConsolePublic NotInheritable Class Console- Vererbung
-
Console
Beispiele
Im folgenden Beispiel wird veranschaulicht, wie Daten aus den Standardeingabe- und -ausgabestreams gelesen und in diese geschrieben werden. Beachten Sie, dass diese Streams mithilfe der Methoden und SetIn umgeleitet SetOut werden können.
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!
module Example
open System
[<EntryPoint>]
let main argv =
Console.Write("Hello ")
Console.WriteLine("World!")
Console.Write("Enter your name: ")
let name = Console.ReadLine()
Console.Write("Good day, ")
Console.Write(name)
Console.WriteLine("!")
0
// The example displays output similar to the following:
// Hello World!
// Enter your name: James
// Good day, James!
Hinweise
Die Konsole ist ein Betriebssystemfenster, in dem Benutzer mit dem Betriebssystem oder einer textbasierten Konsolenanwendung interagieren, indem sie Texteingaben über die Computertastatur eingeben und die Textausgabe aus dem Computerterminal lesen. Im betriebssystemspezifischen Windows wird die Konsole beispielsweise als Eingabeaufforderungsfenster bezeichnet und akzeptiert MS-DOS-Befehle. Die -Klasse bietet grundlegende Unterstützung für Anwendungen, die Zeichen aus der Konsole lesen Console und in diese schreiben.
Informationen zum Entwickeln mit der Console -Klasse finden Sie in den folgenden Abschnitten:
Konsolen-E/A-Streams
Wenn eine Konsolenanwendung gestartet wird, ordnet das Betriebssystem der Konsole automatisch drei E/A-Datenströme zu: Standardeingabestream, Standardausgabestream und Standardfehlerausgabestream. Ihre Anwendung kann Benutzereingaben aus dem Standardeingabestream lesen. Schreiben normaler Daten in den Standardausgabestream; und schreiben Fehlerdaten in den Standardfehlerausgabestream. Diese Streams werden Ihrer Anwendung als Werte der Eigenschaften Console.In Console.Out , und Console.Error präsentiert.
Standardmäßig ist der Wert der -Eigenschaft ein -Objekt, das die Tastatur darstellt, und die Werte der Eigenschaften und sind Objekte, die In System.IO.TextReader ein Out Error System.IO.TextWriter Konsolenfenster darstellen. Sie können diese Eigenschaften jedoch auf Streams festlegen, die nicht das Konsolenfenster oder die Tastatur darstellen. Beispielsweise können Sie diese Eigenschaften auf Streams festlegen, die Dateien darstellen. Rufen Sie die Standardeingabe, Standardausgabe oder Standardfehlerstream umgeleitet, die Console.SetIn, Console.SetOut, oder Console.SetError Methode bzw. E/A-Vorgänge, die diese Datenströme verwenden, werden synchronisiert, was bedeutet, dass mehrere Threads aus den Streams lesen oder in diese schreiben können. Dies bedeutet, dass Methoden, die normalerweise asynchron sind, z. B. , synchron ausgeführt werden, wenn das -Objekt TextReader.ReadLineAsync einen Konsolenstream darstellt.
Hinweis
Verwenden Sie die -Klasse Console nicht, um die Ausgabe in unbeaufsichtigten Anwendungen wie Serveranwendungen anzuzeigen. Aufrufe von Methoden wie Console.Write und Console.WriteLine haben in GUI-Anwendungen keine Auswirkungen.
Console Klassenmitglieder, die normal funktionieren, wenn der zugrunde liegende Stream an eine Konsole weitergeleitet wird, können eine Ausnahme auslösen, wenn der Stream z. B. an eine Datei umgeleitet wird. Programmieren Sie Ihre Anwendung, um System.IO.IOException Ausnahmen zu abfangen, wenn Sie einen Standardstream umleiten. Sie können auch die Eigenschaften , und verwenden, um zu bestimmen, ob ein Standardstream umgeleitet wird, bevor Sie einen Vorgang ausführen, IsOutputRedirected IsInputRedirected der eine Ausnahme IsErrorRedirected System.IO.IOException auslöst.
Manchmal ist es hilfreich, die Member der Streamobjekte explizit auf aufruft, die durch die In Eigenschaften , und dargestellt Out Error werden. Beispielsweise liest die -Methode standardmäßig Console.ReadLine Eingaben aus dem Standardeingabestream. Auf ähnliche Weise schreibt die -Methode Daten in den Standardausgabestream, und auf die Daten folgt die Standardzeichenfolge für die Zeilenbeendigung, die unter Console.WriteLine zu finden Environment.NewLine ist. Die -Klasse stellt jedoch keine entsprechende Methode zum Schreiben von Daten in den Standardfehlerausgabestream oder eine Eigenschaft zum Ändern der Zeilenbeendigungszeichenfolge für In diesen Stream Console geschriebene Daten zur Verfügung.
Sie können dieses Problem beheben, indem Sie die TextWriter.NewLine -Eigenschaft der - oder Out Error -Eigenschaft auf eine andere Zeilenabschlusszeichenfolge festlegen. Die folgende C#-Anweisung legt beispielsweise die Zeilenbeendigungszeichenfolge für den Standardfehlerausgabestream auf zwei Wagenrücklauf- und Zeilenfeedsequenzen fest:
Console.Error.NewLine = "\r\n\r\n";
Sie können dann wie in der folgenden C#-Anweisung explizit die -Methode des WriteLine Fehlerausgabestreamobjekts aufrufen:
Console.Error.WriteLine();
Bildschirmpuffer und Konsolenfenster
Zwei eng miteinander verbundene Features der Konsole sind der Bildschirmpuffer und das Konsolenfenster. Text wird tatsächlich aus Streams gelesen oder in Streams geschrieben, die sich im Besitz der Konsole befinden, aber aus einem Bereich, der sich im Besitz der Konsole befindet, zu lesen oder in diesen geschrieben zu sein, der als Bildschirmpuffer bezeichnet wird. Der Bildschirmpuffer ist ein Attribut der Konsole und als rechteckiges Raster von Zeilen und Spalten organisiert, in dem jede Rasterschnittmenge oder Zeichenzelle ein Zeichen enthalten kann. Jedes Zeichen hat eine eigene Vordergrundfarbe, und jede Zeichenzelle hat eine eigene Hintergrundfarbe.
Der Bildschirmpuffer wird über einen rechteckigen Bereich angezeigt, der als Konsolenfenster bezeichnet wird. Das Konsolenfenster ist ein weiteres Attribut der Konsole. es ist nicht die Konsole selbst, die ein Betriebssystemfenster ist. Das Konsolenfenster ist in Zeilen und Spalten angeordnet, ist kleiner oder gleich der Größe des Bildschirmpuffers und kann verschoben werden, um verschiedene Bereiche des zugrunde liegenden Bildschirmpuffers anzuzeigen. Wenn der Bildschirmpuffer größer als das Konsolenfenster ist, zeigt die Konsole automatisch Bildlaufleisten an, damit das Konsolenfenster über dem Bildschirmpufferbereich neu positioniert werden kann.
Ein Cursor gibt die Bildschirmpufferposition an, an der Derzeit Text gelesen oder geschrieben wird. Der Cursor kann ausgeblendet oder sichtbar gemacht werden, und seine Höhe kann geändert werden. Wenn der Cursor sichtbar ist, wird die Position des Konsolenfensters automatisch verschoben, sodass der Cursor immer angezeigt wird.
Der Ursprung für Zeichenzellenkoordinaten im Bildschirmpuffer ist die obere linke Ecke, und die Positionen des Cursors und des Konsolenfensters werden relativ zu diesem Ursprung gemessen. Verwenden Sie nullbasierte Indizes, um Positionen anzugeben. Das heißt, geben Sie die oberste Zeile als Zeile 0 und die spalte ganz links als Spalte 0 an. Der Höchstwert für die Zeilen- und Spaltenindizes ist Int16.MaxValue .
Unicode-Unterstützung für die Konsole
Im Allgemeinen liest die Konsole Eingaben und schreibt die Ausgabe mithilfe der aktuellen Konsolencodepage, die das System locale standardmäßig definiert. 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 genau darstellen. Dieses Problem wird anhand des folgenden Beispiels veranschaulicht. Es wird versucht, die Zeichen des kyrillischen Alphabets von U+0410 bis U+044F in der Konsole anzuzeigen. Wenn Sie das Beispiel auf einem System ausführen, das Konsolencodepage 437 verwendet, wird jedes Zeichen durch ein Fragezeichen (?) ersetzt, da kyrillische Zeichen nicht den Zeichen in Codepage 437 zuordnen.
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] = (char)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
'
' ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
' ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
' ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
open System
// Create a char List for the modern Cyrillic alphabet,
// from U+0410 to U+044F.
let chars =
[ for codePoint in 0x0410 .. 0x044F do
Convert.ToChar codePoint ]
printfn "Current code page: %i\n" Console.OutputEncoding.CodePage
// Display the characters.
for ch in chars do
printf "%c " ch
if Console.CursorLeft >= 70 then Console.WriteLine()
// The example displays the following output:
// Current code page: 437
//
// ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
// ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
// ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
Zusätzlich zur Unterstützung von Codepages unterstützt die Console -Klasse die UTF-8-Codierung mit der UTF8Encoding -Klasse. Ab der .NET Framework 4.5 unterstützt die -Klasse auch Console die UTF-16-Codierung mit der UnicodeEncoding -Klasse. Zum Anzeigen von Unicode-Zeichen in der Konsole. Legen Sie die OutputEncoding -Eigenschaft entweder auf oder UTF8Encoding UnicodeEncoding fest.
Die Unterstützung von Unicode-Zeichen erfordert, dass der Encoder ein bestimmtes Unicode-Zeichen erkennt, und erfordert auch eine Schriftart mit den Symbolen, die zum Rendern dieses Zeichens erforderlich sind. Damit Unicode-Zeichen erfolgreich in der Konsole angezeigt werden können, muss die Konsolenschriftart auf eine Nicht-Raster- oder TrueType-Schriftart wie Consolas oder Lucida Console festgelegt werden. Das folgende Beispiel zeigt, wie Sie die Schriftart programmgesteuert von einer Rasterschriftart in Lucida Console ändern können.
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
module Example
open System
open System.Runtime.InteropServices
[<Literal>]
let STD_OUTPUT_HANDLE = -11
[<Literal>]
let TMPF_TRUETYPE = 4
[<Literal>]
let LF_FACESIZE = 32
let INVALID_HANDLE_VALUE = IntPtr(-1)
[<Struct>]
[<StructLayout(LayoutKind.Sequential)>]
type COORD =
val mutable X: int16
val mutable Y: int16
internal new(x: int16, y: int16) =
{ X = x
Y = y }
[<Struct>]
[<StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)>]
type CONSOLE_FONT_INFO_EX =
val mutable cbSize: uint32
val mutable nFont: uint32
val mutable dwFontSize: COORD
val mutable FontFamily: int
val mutable FontWeight: int
[<MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)>]
val mutable FaceName: string
[<DllImport("kernel32.dll", SetLastError = true)>]
extern IntPtr GetStdHandle(int nStdHandle)
[<DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)>]
extern bool GetCurrentConsoleFontEx(IntPtr consoleOutput, bool maximumWindow, CONSOLE_FONT_INFO_EX lpConsoleCurrentFontEx)
[<DllImport("kernel32.dll", SetLastError = true)>]
extern bool SetCurrentConsoleFontEx(IntPtr consoleOutput, bool maximumWindow, CONSOLE_FONT_INFO_EX consoleCurrentFontEx)
[<EntryPoint>]
let main argv =
let fontName = "Lucida Console"
let hnd = GetStdHandle(STD_OUTPUT_HANDLE)
if hnd <> INVALID_HANDLE_VALUE then
let mutable info = CONSOLE_FONT_INFO_EX()
info.cbSize <- uint32 (Marshal.SizeOf(info))
// First determine whether there's already a TrueType font.
if (GetCurrentConsoleFontEx(hnd, false, info)) then
if (((info.FontFamily) &&& TMPF_TRUETYPE) = TMPF_TRUETYPE) then
Console.WriteLine("The console already is using a TrueType font.")
else
// Set console font to Lucida Console.
let mutable newInfo = CONSOLE_FONT_INFO_EX()
newInfo.cbSize <- uint32 (Marshal.SizeOf(newInfo))
newInfo.FontFamily <- TMPF_TRUETYPE
newInfo.FaceName <- fontName
// Get some settings from current font.
newInfo.dwFontSize <- COORD(info.dwFontSize.X, info.dwFontSize.Y)
newInfo.FontWeight <- info.FontWeight
SetCurrentConsoleFontEx(hnd, false, newInfo) |> ignore
Console.WriteLine("The console is now using a TrueType font.")
// Return zero for success
0
TrueType-Schriftarten können jedoch nur eine Teilmenge von Glyphen anzeigen. Beispielsweise zeigt die Schriftart Lucida Console nur 643 der ca. 64.000 verfügbaren Zeichen von U+0021 bis U+FB02 an. Um zu sehen, welche Zeichen eine bestimmte Schriftart unterstützt, öffnen Sie das Schriftarten-Applet in Systemsteuerung, wählen Sie die Option Zeichen suchen aus, und wählen Sie die Schriftart aus, deren Zeichensatz Sie in der Liste Schriftart des Fensters Zeichentabelle untersuchen möchten.
Windows verwendet Schriftartverknüpfungen, um Glyphen anzuzeigen, die in einer bestimmten Schriftart nicht verfügbar sind. Informationen zum Verknüpfen von Schriftarten zum Anzeigen zusätzlicher Zeichensätze finden Sie unter Globalization Step-by-Step: Fonts. Verknüpfte Schriftarten werden im HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink der Registrierung definiert. Jeder diesem Unterschlüssel zugeordnete Eintrag entspricht dem Namen einer Basisschriftart, und sein Wert ist ein Zeichenfolgenarray, das die Schriftartdateien und die Schriftarten definiert, die mit der Basisschriftart verknüpft sind. Jedes Member des Arrays definiert eine verknüpfte Schriftart und hat das Formular font-file-name,font-name. Das folgende Beispiel veranschaulicht, wie Sie programmgesteuert eine verknüpfte Schriftart namens SimSun definieren können, die in einer Schriftartdatei namens simsun.ttc gefunden wird, die vereinfachte Han-Zeichen anzeigt.
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
open System
open Microsoft.Win32
let valueName = "Lucida Console"
let newFont = "simsun.ttc,SimSun"
let key =
Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink", true)
if isNull key then
printfn "Font linking is not enabled."
else
// Determine if the font is a base font.
let names = key.GetValueNames()
let (fonts, kind, toAdd) =
if names |> Array.exists (fun s -> s.Equals(valueName, StringComparison.OrdinalIgnoreCase)) then
// Get the value's type.
let kind = key.GetValueKind(valueName)
// Type should be RegistryValueKind.MultiString, but we can't be sure.
let fonts =
match kind with
| RegistryValueKind.String -> [| key.GetValue(valueName) :?> string |]
| RegistryValueKind.MultiString -> (key.GetValue(valueName) :?> string array)
| _ -> [||]
// Determine whether SimSun is a linked font.
let toAdd =
not (fonts |> Array.exists (fun s -> s.IndexOf("SimSun", StringComparison.OrdinalIgnoreCase) >= 0))
(fonts, kind, toAdd)
else
// Font is not a base font.
([||], RegistryValueKind.Unknown, true)
if toAdd then
// Font is not a linked font.
let newFonts = Array.append fonts [| newFont |]
// Change REG_SZ to REG_MULTI_SZ.
if kind = RegistryValueKind.String then key.DeleteValue(valueName, false)
key.SetValue(valueName, newFonts, RegistryValueKind.MultiString)
printfn "SimSun added to the list of linked fonts."
else
printfn "Font is already linked."
if not (isNull key) then key.Close()
Die Unicode-Unterstützung für die Konsole hat die folgenden Einschränkungen:
UTF-32-Codierung wird nicht unterstützt. Die einzigen unterstützten Unicode-Codierungen sind UTF-8 und UTF-16, die jeweils durch die Klassen UTF8Encoding und UnicodeEncoding dargestellt werden.
Die bidirektionale Ausgabe wird nicht unterstützt.
Die Anzeige von Zeichen außerhalb der grundlegenden mehrsprachigen Ebene (d. h. von Ersatzzeichenpaaren) wird nicht unterstützt, auch wenn sie in einer verknüpften Schriftartdatei definiert sind.
Die Anzeige von Zeichen in komplexen Skripts wird nicht unterstützt.
Das Kombinieren von Zeichenfolgen (d. h. Zeichen, die aus einem Basiszeichen und mindestens einem kombinierenden Zeichen bestehen) wird als separate Zeichen angezeigt. Um diese Einschränkung zu umgehen, können Sie die anzuzeigende Zeichenfolge normalisieren, indem Sie die -Methode aufrufen, String.Normalize bevor Sie die Ausgabe an die Konsole senden. Im folgenden Beispiel wird eine Zeichenfolge, die die kombinierende Zeichenfolge U+0061 U+0308 enthält, in der Konsole als zwei Zeichen angezeigt, bevor die Ausgabezeichenfolge normalisiert wird, und als einzelnes Zeichen nach dem Aufrufen der String.Normalize -Methode.
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" ' äopen System let chars = [| '\u0061'; '\u0308' |] let combining = String chars Console.WriteLine combining let combining2 = combining.Normalize() Console.WriteLine combining2 // The example displays the following output: // a" // äBeachten Sie, dass die Normalisierung nur dann eine sinnvolle Lösung ist, wenn der Unicode-Standard für das Zeichen eine vorkonfiguriert Form enthält, die einer bestimmten kombinierenden Zeichenfolge entspricht.
Wenn eine Schriftart ein Glyphen für einen Codepunkt im privaten Verwendungsbereich enthält, wird dieses Glyph angezeigt. Da Jedoch Zeichen im privaten Verwendungsbereich anwendungsspezifisch sind, ist dies möglicherweise nicht das erwartete Glyphe.
Im folgenden Beispiel wird ein Bereich von Unicode-Zeichen in der Konsole angezeigt. Im Beispiel werden drei Befehlszeilenparameter akzeptiert: der Anfang des anzuzeigenden Bereichs, das Ende des anzuzeigenden Bereichs und die Verwendung der aktuellen Konsolencodierung ( ) oder false der UTF-16-Codierung ( true ). Es wird davon ausgegangen, dass die Konsole eine TrueType-Schriftart verwendet.
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($" {(char)(0x20)} ");
}
else if (end < cur) {
Console.Write($" {(char)(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($" {(char)(0x20)} ");
// Display a space for code points in the private use area.
else if (CharUnicodeInfo.GetUnicodeCategory(chars[0]) ==
UnicodeCategory.PrivateUse)
Console.Write($" {(char)(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($" {(char)(0x20)} ");
else
Console.Write($" {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 Ӱ ӱ Ӳ ӳ - Ӵ ӵ Ӷ ӷ -- Ӹ ӹ Ӻ ӻ - Ӽ ӽ Ӿ ӿ
module DisplayChars
open System
open System.IO
open System.Globalization
open System.Text
type uint = uint32
let inline roundDownToMultipleOf b u = u - (u % b)
let inline roundUpToMultipleOf b u = roundDownToMultipleOf b u |> (+) b
let displayRange (start: uint) (``end``: uint) =
let upperRange = 0x10FFFFu
let surrogateStart = 0xD800u
let surrogateEnd = 0xDFFFu
let start, ``end`` =
if ``end`` <= start then ``end``, start
else start, ``end``
// Check whether the start or end range is outside of last plane.
if start > upperRange then
invalidArg "start"
(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{1:X5})", start, upperRange))
if ``end`` > upperRange then
invalidArg "end"
(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) then
raise
(ArgumentException
(String.Format
("0x{0:X5}-0x{1:X5} includes the surrogate pair range 0x{2:X5}-0x{3:X5}", start, ``end``,
surrogateStart, surrogateEnd)))
let last = roundUpToMultipleOf 0x10u ``end``
let first = roundDownToMultipleOf 0x10u start
let rows = (last - first) / 0x10u
for r in 0u .. (rows - 1u) do
// Display the row header.
printf "%05x " (first + 0x10u * r)
for c in 0u .. (0x10u - 1u) do
let cur = (first + 0x10u * r + c)
if cur < start || ``end`` < cur then
printf " %c " (Convert.ToChar 0x20)
else
// the cast to int is safe, since we know that val <= upperRange.
let chars = Char.ConvertFromUtf32(int cur)
// Display a space for code points that are not valid characters.
if CharUnicodeInfo.GetUnicodeCategory(chars[0]) = UnicodeCategory.OtherNotAssigned then
printf " %c " (Convert.ToChar 0x20)
else
// Display a space for code points in the private use area.
if CharUnicodeInfo.GetUnicodeCategory(chars[0]) = UnicodeCategory.PrivateUse then
printf " %c " (Convert.ToChar 0x20)
else if chars.Length > 1
&& CharUnicodeInfo.GetUnicodeCategory(chars, 0) = UnicodeCategory.OtherNotAssigned then
printf " %c " (Convert.ToChar 0x20)
else printf " %s " chars
match c with
| 3u
| 11u -> printf "-"
| 7u -> printf "--"
| _ -> ()
Console.WriteLine()
if (0u < r && r % 0x10u = 0u) then Console.WriteLine()
[<EntryPoint>]
let main args =
// Get the current encoding so we can restore it.
let originalOutputEncoding = Console.OutputEncoding
try
try
let parsedArgs =
match args.Length with
| 2 ->
Some
{| setOutputEncodingToUnicode = true
rangeStart = uint.Parse(args[0], NumberStyles.HexNumber)
rangeEnd = uint.Parse(args[1], NumberStyles.HexNumber) |}
| 3 ->
let parseHexNumberOrThrow (value: string) parameterName =
(uint.TryParse(value, NumberStyles.HexNumber, null))
|> function
| (false, _) ->
invalidArg parameterName (String.Format("{0} is not a valid hexadecimal number.", value))
| (true, value) -> value
let setOutputEncodingToUnicode =
match bool.TryParse args[2] with
| true, value -> value
| false, _ -> true
Some
{| setOutputEncodingToUnicode = setOutputEncodingToUnicode
rangeStart = parseHexNumberOrThrow args[0] "rangeStart"
rangeEnd = parseHexNumberOrThrow args[1] "rangeEnd" |}
| _ ->
printfn "Usage: %s <%s> <%s> [%s]" (Environment.GetCommandLineArgs()[0]) "startingCodePointInHex"
"endingCodePointInHex" "<setOutputEncodingToUnicode?{true|false, default:false}>"
None
match parsedArgs with
| None -> ()
| Some parsedArgs ->
if parsedArgs.setOutputEncodingToUnicode then
// 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 <- UnicodeEncoding(not BitConverter.IsLittleEndian, false)
printfn "\nOutput encoding set to UTF-16"
with :? IOException ->
printfn "Output encoding set to UTF-8"
Console.OutputEncoding <- UTF8Encoding()
else
printfn "The console encoding is %s (code page %i)" (Console.OutputEncoding.EncodingName)
(Console.OutputEncoding.CodePage)
displayRange parsedArgs.rangeStart parsedArgs.rangeEnd
with :? ArgumentException as ex -> Console.WriteLine(ex.Message)
finally
// Restore console environment.
Console.OutputEncoding <- originalOutputEncoding
0
// 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änge
Die Console -Klasse enthält die folgenden Methoden zum Lesen der Konsoleneingabe und zum Schreiben der Konsolenausgabe:
Die Überladungen der ReadKey -Methode lesen ein einzelnes Zeichen.
Die ReadLine -Methode liest eine gesamte Eingabezeile.
Die -Methode überlädt eine Instanz eines Werttyps, eines Zeichenarrays oder einer Reihe von Objekten in eine formatierte oder unformatierte Zeichenfolge und schreibt diese Zeichenfolge dann in die Write Konsole.
Ein paralleler Satz von Methodenüberladungen gibt dieselbe Zeichenfolge wie die WriteLine Write Überladungen aus, fügt aber auch eine Zeilenabschlusszeichenfolge hinzu.
Die Console -Klasse enthält auch Methoden und Eigenschaften zum Ausführen der folgenden Vorgänge:
Hier können Sie die Größe des Bildschirmpuffers erhalten oder festlegen. Mit den Eigenschaften und können Sie die Pufferhöhe bzw. -breite erhalten oder festlegen, und mit der -Methode können Sie die Puffergröße in einem BufferHeight BufferWidth einzigen SetBufferSize Methodenaufruf festlegen.
Hier können Sie die Größe des Konsolenfensters anzeigen oder festlegen. Mit den Eigenschaften und können Sie die Fensterhöhe bzw. -breite erhalten oder festlegen, und mit der -Methode können Sie die Fenstergröße in einem WindowHeight WindowWidth einzigen SetWindowSize Methodenaufruf festlegen.
Hier können Sie die Größe des Cursors erhalten oder festlegen. Die CursorSize -Eigenschaft gibt die Höhe des Cursors in einer Zeichenzelle an.
Hier können Sie die Position des Konsolenfensters relativ zum Bildschirmpuffer festlegen oder festlegen. Mit den Eigenschaften und können Sie die oberste Zeile und die spalte ganz links des Bildschirmpuffers, die im Konsolenfenster angezeigt werden, erhalten oder festlegen. Mit der -Methode können Sie diese Werte in einem einzigen Methodenaufruf WindowTop WindowLeft SetWindowPosition festlegen.
Rufen Sie die Position des Cursors ab, oder legen Sie sie fest, indem Sie die Eigenschaften und abrufen oder festlegen, oder legen Sie die Position des CursorTop CursorLeft Cursors fest, indem Sie die -Methode SetCursorPosition aufrufen.
Verschieben oder löschen Sie Daten im Bildschirmpuffer, indem Sie die MoveBufferArea - oder Clear -Methode aufrufen.
Rufen Sie die Vordergrund- und Hintergrundfarben mithilfe der Eigenschaften und ab, oder setzen Sie den Hintergrund und den Vordergrund auf ihre Standardfarben zurück, indem ForegroundColor BackgroundColor Sie die -Methode ResetColor aufrufen.
Geben Sie den Sound eines Signaltons über den Konsolenlautlauter wieder, indem Sie die -Methode Beep aufrufen.
Hinweise zu .NET Core
In .NET Framework Desktop verwendet die -Klasse die von und zurückgegebene Codierung, bei der es sich in der Regel um Console GetConsoleCP eine GetConsoleOutputCP Codepagecodierung handelt. Beispielcode auf Systemen, deren Kultur Englisch (USA) ist, ist Codepage 437 die Codierung, die standardmäßig verwendet wird. .NET Core macht jedoch möglicherweise nur eine begrenzte Teilmenge dieser Codierungen verfügbar. Wenn dies der Fall ist, Encoding.UTF8 wird als Standardcodierung für die Konsole verwendet.
Wenn Ihre App von bestimmten Codepagecodierungen abhängt, können Sie sie trotzdem verfügbar machen, indem Sie die folgenden Schritte ausführen, bevor Sie Methoden Console aufrufen:
Fügen Sie ihrem Projekt einen Verweis System.Text.Encoding.CodePages.dll Assembly hinzu.
Rufen Sie das EncodingProvider -Objekt aus der CodePagesEncodingProvider.Instance -Eigenschaft ab.
Übergeben Sie EncodingProvider das -Objekt an Encoding.RegisterProvider die -Methode, um die vom Codierungsanbieter unterstützten zusätzlichen Codierungen verfügbar zu machen.
Die -Klasse verwendet dann automatisch die Standardsystemcodierung anstelle von UTF8, vorausgesetzt, Sie haben den Codierungsanbieter registriert, bevor Sie Console Console Ausgabemethoden aufrufen.
Eigenschaften
| BackgroundColor |
Ruft die Hintergrundfarbe der Konsole ab oder legt diese fest. |
| BufferHeight |
Ruft die Höhe des Pufferbereichs ab oder legt diese fest. |
| BufferWidth |
Ruft die Breite des Pufferbereichs ab oder legt diese fest. |
| CapsLock |
Ruft einen Wert ab, der angibt, ob die FESTSTELLTASTE-Tastaturumschalttaste aktiviert oder deaktiviert ist. |
| CursorLeft |
Ruft die Spaltenposition des Cursors im Pufferbereich ab oder legt diese fest. |
| CursorSize |
Ruft die Höhe des Cursors innerhalb einer Zeichenzelle ab oder legt diese fest. |
| CursorTop |
Ruft die Zeilenposition des Cursors im Pufferbereich ab oder legt diese fest. |
| CursorVisible |
Ruft einen Wert ab, der angibt, ob der Cursor sichtbar ist, oder legt diesen fest. |
| Error |
Ruft den Standard-Fehlerausgabestream ab. |
| ForegroundColor |
Ruft die Vordergrundfarbe der Konsole ab oder legt diese fest. |
| In |
Ruft den Standardeingabestream ab. |
| InputEncoding |
Ruft die Codierung ab, die die Konsole verwendet, um die Eingabe zu lesen, oder legt diese fest. |
| IsErrorRedirected |
Ruft einen Wert ab, der angibt, ob der Fehlerausgabedatenstrom von dem Standardfehlerstream umgeleitet wurde. |
| IsInputRedirected |
Ruft einen Wert ab, der angibt, ob die Eingabe aus dem Standardeingabestream umgeleitet wurde. |
| IsOutputRedirected |
Ruft einen Wert ab, der angibt, ob die Ausgabe aus dem Standardausgabestream umgeleitet wurde. |
| KeyAvailable |
Ruft einen Wert ab, der angibt, ob ein Tastendruck im Eingabestream vorhanden ist. |
| LargestWindowHeight |
Ruft die entsprechend der aktuellen Schriftart und Bildschirmauflösung größtmögliche Anzahl von Konsolenfensterzeilen ab. |
| LargestWindowWidth |
Ruft die entsprechend der aktuellen Schriftart und Bildschirmauflösung größtmögliche Anzahl von Konsolenfensterspalten ab. |
| NumberLock |
Ruft einen Wert ab, der angibt, ob die NUM-Tastaturumschalttaste aktiviert oder deaktiviert ist. |
| Out |
Ruft den Standardausgabestream ab. |
| OutputEncoding |
Ruft die Codierung ab, die die Konsole verwendet, um die Ausgabe zu schreiben, oder legt diese fest. |
| Title |
Ruft den auf der Konsolentitelleiste anzuzeigenden Titel ab oder legt diesen fest. |
| 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. |
| WindowHeight |
Ruft die Höhe des Konsolenfensterbereichs ab oder legt diese fest. |
| WindowLeft |
Ruft die am weitesten links stehende Position des Konsolenfensterbereichs im Verhältnis zum Bildschirmpuffer ab oder legt diese fest. |
| WindowTop |
Ruft die oberste Position des Konsolenfensterbereichs im Verhältnis zum Bildschirmpuffer ab oder legt diese fest. |
| WindowWidth |
Ruft die Breite des Konsolenfensters ab oder legt diese fest. |
Methoden
| Beep() |
Gibt den Sound eines Signaltons auf dem Konsolenlautsprecher wieder. |
| Beep(Int32, Int32) |
Gibt den Sound eines Signaltons mit einer angegebenen Frequenz und Dauer auf dem Konsolenlautsprecher wieder. |
| Clear() |
Löscht die Anzeigeinformationen aus dem Konsolenpuffer und dem entsprechenden Konsolenfenster. |
| GetCursorPosition() |
Ruft die Position des Cursors ab. |
| MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32) |
Kopiert einen angegebenen Quellbereich des Bildschirmpuffers in einen angegebenen Zielbereich. |
| MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor) |
Kopiert einen angegebenen Quellbereich des Bildschirmpuffers in einen angegebenen Zielbereich. |
| OpenStandardError() |
Ruft den Standardfehlerstream ab. |
| OpenStandardError(Int32) |
Ruft den Standardfehlerstream ab, der auf eine angegebene Puffergröße festgelegt wird. |
| OpenStandardInput() |
Ruft den Standardeingabestream ab. |
| OpenStandardInput(Int32) |
Ruft den Standardeingabestream ab, der auf eine angegebene Puffergröße festgelegt wird. |
| OpenStandardOutput() |
Ruft den Standardausgabestream ab. |
| OpenStandardOutput(Int32) |
Ruft den Standardausgabestream ab, der auf eine angegebene Puffergröße festgelegt wird. |
| Read() |
Liest das nächste Zeichen aus dem Standardeingabestream. |
| ReadKey() |
Ruft die nächste vom Benutzer gedrückte Zeichen- oder Funktionstaste ab. Die gedrückte Taste wird im Konsolenfenster angezeigt. |
| ReadKey(Boolean) |
Ruft die nächste vom Benutzer gedrückte Zeichen- oder Funktionstaste ab. Die gedrückte Taste wird optional im Konsolenfenster angezeigt. |
| ReadLine() |
Liest die nächste Zeile von Zeichen aus dem Standardeingabestream. |
| ResetColor() |
Legt die Vordergrund- und Hintergrundkonsolenfarben auf die entsprechenden Standardwerte fest. |
| SetBufferSize(Int32, Int32) |
Legt die Höhe und die Breite des Bildschirmpufferbereichs auf die angegebenen Werte fest. |
| SetCursorPosition(Int32, Int32) |
Legt die Position des Cursors fest. |
| SetError(TextWriter) |
Legt die Error-Eigenschaft auf den angegebenen TextWriter fest. |
| SetIn(TextReader) |
Legt die In-Eigenschaft auf den angegebenen TextReader fest. |
| SetOut(TextWriter) |
Legt die Out-Eigenschaft fest, die auf das TextWriter-Objekt ausgerichtet ist. |
| SetWindowPosition(Int32, Int32) |
Legt die Position des Konsolenfensters relativ zum Bildschirmpuffer fest. |
| SetWindowSize(Int32, Int32) |
Legt die Höhe und die Breite des Konsolenfensters auf die angegebenen Werte fest. |
| Write(Boolean) |
Schreibt die Textdarstellung des angegebenen booleschen Werts in den Standardausgabestream. |
| Write(Char) |
Schreibt das angegebene Unicode-Zeichen in den Standardausgabestream. |
| Write(Char[]) |
Schreibt das angegebene Array von Unicode-Zeichen in den Standardausgabestream. |
| Write(Char[], Int32, Int32) |
Schreibt das angegebene Unterarray von Unicode-Zeichen in den Standardausgabestream. |
| Write(Decimal) |
Schreibt die Textdarstellung des angegebenen Decimal-Werts in den Standardausgabestream. |
| Write(Double) |
Schreibt die Textdarstellung der angegebenen Gleitkommazahl mit doppelter Genauigkeit in den Standardausgabestream. |
| Write(Int32) |
Schreibt die Textdarstellung der angegebenen 32-Bit-Ganzzahl mit Vorzeichen in den Standardausgabestream. |
| Write(Int64) |
Schreibt die Textdarstellung der angegebenen 64-Bit-Ganzzahl mit Vorzeichen in den Standardausgabestream. |
| Write(Object) |
Schreibt die Textdarstellung des angegebenen Objekts in den Standardausgabestream. |
| Write(Single) |
Schreibt die Textdarstellung der angegebenen Gleitkommazahl mit einfacher Genauigkeit in den Standardausgabestream. |
| Write(String) |
Schreibt die angegebene Zeichenfolge in den Standardausgabestream. |
| Write(String, Object) |
Schreibt die Textdarstellung des angegebenen Objekts unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream. |
| Write(String, Object, Object) |
Schreibt die Textdarstellung der angegebenen Objekte unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream. |
| Write(String, Object, Object, Object) |
Schreibt die Textdarstellung der angegebenen Objekte unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream. |
| 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. |
| Write(String, Object[]) |
Schreibt die Textdarstellung des angegebenen Arrays von Objekten unter Verwendung der angegebenen Formatinformationen in den Standardausgabestream. |
| Write(UInt32) |
Schreibt die Textdarstellung der angegebenen 32-Bit-Ganzzahl ohne Vorzeichen in den Standardausgabestream. |
| Write(UInt64) |
Schreibt die Textdarstellung der angegebenen 64-Bit-Ganzzahl ohne Vorzeichen in den Standardausgabestream. |
| WriteLine() |
Schreibt das aktuelle Zeichen für den Zeilenabschluss in den Standardausgabestream. |
| WriteLine(Boolean) |
Schreibt die Textdarstellung des angegebenen booleschen Werts, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Char) |
Schreibt das angegebene Unicode-Zeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Char[]) |
Schreibt das angegebenen Array von Unicode-Zeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Char[], Int32, Int32) |
Schreibt das angegebene Unterarray von Unicode-Zeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Decimal) |
Schreibt die Textdarstellung des angegebenen Decimal-Werts, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Double) |
Schreibt die Textdarstellung der angegebenen Gleitkommazahl mit doppelter Genauigkeit, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Int32) |
Schreibt die Textdarstellung der angegebenen 32-Bit-Ganzzahl mit Vorzeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Int64) |
Schreibt die Textdarstellung der angegebenen 64-Bit-Ganzzahl mit Vorzeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Object) |
Schreibt die Textdarstellung des angegebenen Objekts, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(Single) |
Schreibt die Textdarstellung der angegebenen Gleitkommazahl mit einfacher Genauigkeit, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(String) |
Schreibt den angegebenen Zeichenfolgenwert, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| WriteLine(UInt32) |
Schreibt die Textdarstellung der angegebenen 32-Bit-Ganzzahl ohne Vorzeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
| WriteLine(UInt64) |
Schreibt die Textdarstellung der angegebenen 64-Bit-Ganzzahl ohne Vorzeichen, gefolgt vom aktuellen Zeichen für den Zeilenabschluss, in den Standardausgabestream. |
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). |
Gilt für:
Threadsicherheit
Dieser Typ ist threadsicher.