Console Osztály

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Console.dll

Forrás:

Console.cs

A konzolalkalmazások szabványos bemenetét, kimenetét és hibastreameit jelöli. Ez az osztály nem örökölhető.

public ref class Console abstract sealed

public static class Console

type Console = class

Public Class Console

Öröklődés

Object

Console

Példák

Az alábbi példa bemutatja, hogyan olvashat be adatokat a standard bemeneti és kimeneti adatfolyamokból, és hogyan írhat be adatokat. Vegye figyelembe, hogy ezek a streamek a SetIn és SetOut metódusok használatával átirányíthatók.

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 Example4
    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!

Megjegyzések

A konzol egy operációsrendszer-ablak, ahol a felhasználók az operációs rendszerrel vagy egy szövegalapú konzolalkalmazással lépnek kapcsolatba a számítógép billentyűzetén keresztül beírt szövegbevitellel, valamint a számítógép termináljáról származó szövegkimenet beolvasásával. A Windows operációs rendszerben például a konzolt parancssori ablaknak nevezzük, és elfogadja MS-DOS parancsokat. Az Console osztály alapvető támogatást nyújt azoknak az alkalmazásoknak, amelyek karaktereket olvasnak a konzolról, és beírnak karaktereket.

A konzol bemenet/kimeneti folyamatai

A konzolalkalmazás indításakor az operációs rendszer automatikusan három I/O-streamet társít a konzolhoz: standard bemeneti streamet, standard kimeneti streamet és standard hibakimeneti adatfolyamot. Az alkalmazás képes a felhasználói bemenetek olvasására a standard bemeneti adatfolyamból; normál adatok írása a standard kimeneti adatfolyamba; és írja be a hibaadatokat a standard hibakimeneti adatfolyamba. Ezek a streamek az Console.In, Console.Out, és Console.Error tulajdonságok értékeiként jelennek meg az alkalmazásod számára.

Alapértelmezés szerint a In tulajdonság értéke egy System.IO.TextReader objektum, amely a billentyűzetet képviseli, és a Out és Error tulajdonságok értékei System.IO.TextWriter objektumok, amelyek egy konzolablakot képviselnek. Ezeket a tulajdonságokat azonban beállíthatja olyan streamekre, amelyek nem a konzolablakot vagy a billentyűzetet jelölik; Ezeket a tulajdonságokat beállíthatja például fájloknak szánt streamekre. A standard bemenet, a standard kimenet vagy a standard hibafolyam átirányításához hívja meg az Console.SetIn, Console.SetOutvagy Console.SetError metódust. Az ezeket a streameket használó I/O-műveletek szinkronizálva vannak, ami azt jelenti, hogy több szál is olvashat vagy írhat a streamekből. Ez azt jelenti, hogy azok a metódusok, amelyek általában aszinkronok, például TextReader.ReadLineAsyncszinkron módon futnak, ha az objektum egy konzolstreamet jelöl.

Megjegyzés:

Ne használja az osztályt a Console felügyelet nélküli alkalmazások, például kiszolgálóalkalmazások kimenetének megjelenítésére. Olyan metódusok hívása, mint például Console.Write és Console.WriteLine, nincsen hatása a GUI-alkalmazásokban.

Console Azok az osztálytagok, amelyek normálisan működnek, amikor az alapul szolgáló streamet egy konzolra irányítják, kivételt jelenthetnek, ha a streamet például egy fájlba irányítják át. Programozza az alkalmazást, hogy kezelje a System.IO.IOException kivételeket, ha egy standard adatfolyamot irányít át. A IsOutputRedirected, IsInputRedirected és IsErrorRedirected tulajdonságokat is használhatja annak meghatározására, hogy a rendszer átirányít-e egy standard streamet, mielőtt egy System.IO.IOException kivételt eredményező műveletet hajtana végre.

Néha hasznos lehet explicit módon meghívni a streamobjektumok tagjait, amelyeket a In, Out, és Error tulajdonságok jelölnek. A metódus például alapértelmezés szerint beolvassa a Console.ReadLine bemenetet a standard bemeneti adatfolyamból. Hasonlóképpen, a Console.WriteLine metódus adatokat ír a standard kimeneti adatfolyamba, és az adatokat az alapértelmezett vonalzáró sztring követi, amely a következő helyen található: Environment.NewLine. Az Console osztály azonban nem biztosít megfelelő metódust az adatok szabványos hibakimeneti adatfolyamba való írásához, vagy az adott adatfolyamba írt adatok sorkizárási sztringjének módosítására szolgáló tulajdonságot.

Ezt a problémát úgy oldhatja meg, hogy a TextWriter.NewLine vagy a Out tulajdonságot egy másik sormegszüntetési sztringre állítja. A következő C# utasítás például a standard hibakimeneti adatfolyam vonalvégzítési sztringét két kocsivissza- és sorbetöltési sorozatra állítja be:

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

Ezután explicit módon meghívhatja a WriteLine kimeneti streamobjektum metódusát, ahogyan az alábbi C# utasításban is látható:

Console.Error.WriteLine();

Képernyőpuffer és konzolablak

A konzol két szorosan kapcsolódó funkciója a képernyőpuffer és a konzolablak. A szöveget valójában a konzol tulajdonában lévő stream-ekből olvassák be, vagy ezekbe írják bele, de úgy tűnik, hogy a konzol által birtokolt területről olvassák be, amit képernyőpuffernek hívnak. A képernyőpuffer a konzol attribútuma, és sorokat és oszlopokat tartalmazó téglalap alakú rácsként van rendszerezve, ahol minden rács metszete vagy karaktercellája tartalmazhat egy karaktert. Minden karakternek saját előtérszíne van, és minden karaktercellának saját háttérszíne van.

A képernyőpuffer egy téglalap alakú, úgynevezett konzolablakon keresztül tekinthető meg. A konzolablak a konzol egy másik attribútuma; ez nem maga a konzol, amely egy operációs rendszer ablaka. A konzolablak sorokba és oszlopokba van rendezve, kisebb vagy egyenlő a képernyőpuffer méretével, és áthelyezhető az alapul szolgáló képernyőpuffer különböző területeinek megtekintéséhez. Ha a képernyőpuffer nagyobb, mint a konzolablak, a konzol automatikusan megjeleníti a görgetősávokat, hogy a konzolablak áthelyezhető legyen a képernyő pufferterületére.

A kurzor azt a képernyőpuffer-pozíciót jelzi, ahol a szöveg éppen olvasható vagy írható. A kurzor lehet rejtett vagy látható, és a magassága módosítható. Ha a kurzor látható, a konzolablak helyzete automatikusan elmozdul, így a kurzor mindig látható.

A képernyőpufferben lévő karaktercellák koordinátáinak forrása a bal felső sarok, a kurzor és a konzolablak pozíciói pedig az adott forráshoz viszonyítva vannak mérve. Nulla alapú indexek használata pozíciók megadásához; azaz adja meg a legfelső sort 0 sorként, a bal szélső oszlopot pedig 0 oszlopként. A sor- és oszlopindexek maximális értéke .Int16.MaxValue

Unicode-támogatás a konzolhoz

A konzol általában az aktuális konzolkódlap használatával olvassa be a bemenetet és írja a kimenetet, amelyet a rendszer területi beállítása alapértelmezés szerint meghatároz. A kódlapok csak a rendelkezésre álló Unicode-karakterek egy részhalmazát képesek kezelni, így ha olyan karaktereket próbál megjeleníteni, amelyeket nem egy adott kódlap képez le, a konzol nem tudja megjeleníteni az összes karaktert, és nem tudja pontosan megjeleníteni őket. Az alábbi példa ezt a problémát szemlélteti. Megpróbálja megjeleníteni a cirill betű karaktereit az U+0410-től az U+044F-től a konzolig. Ha a példát egy olyan rendszeren futtatja, amely a 437-as konzolkódot használja, minden karaktert kérdőjel (?) vált fel, mert a cirill karakterek nem a 437-as kódlap karaktereihez vannak megfeleltetve.

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

A kódlapok támogatása mellett az osztály támogatja az Console UTF-8 kódolást az osztály és az UTF8Encoding UTF-16 kódolással az UnicodeEncoding osztálysal. Unicode-karakterek megjelenítése a konzolon. Beállítja a(z) OutputEncoding tulajdonságot vagy UTF8Encoding-re, vagy UnicodeEncoding-re.

A Unicode-karakterek támogatása megköveteli, hogy a kódoló felismerjen egy adott Unicode-karaktert, és olyan betűtípust is igényel, amely tartalmazza az adott karakter megjelenítéséhez szükséges karakterjeleket. Ha unicode karaktereket szeretne megjeleníteni a konzolon, a konzol betűtípusát nem raszter vagy TrueType betűtípusra kell állítani, például Consolas vagy Lucida Console. Az alábbi példa bemutatja, hogyan módosíthatja programozott módon a betűtípust raszteres betűtípusról Lucida Console-ra.

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 Example5
    ' <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

A TrueType betűtípusok azonban csak a karakterjelek egy részhalmazát jeleníthetik meg. A Lucida-konzol betűtípusa például csak 643 karaktert jelenít meg az U+0021 és U+FB02 közötti körülbelül 64 000 karakterből. Ha meg szeretné tekinteni, hogy egy adott betűtípus mely karaktereket támogatja, nyissa meg a Betűtípusok kisalkalmazást a Vezérlőpulton, válassza a Karakter keresése lehetőséget, és válassza ki azt a betűtípust, amelynek a karakterkészletét meg szeretné vizsgálni a Karaktertérkép ablak Betűtípuslistájában.

A Windows betűtípus-csatolással jeleníti meg az adott betűtípusban nem elérhető karakterjeleket. Font-linkelési információkért, amelyek további karakterkészletek megjelenítését teszik lehetővé, lásd: Globalization Step-by-Step: Fonts. A csatolt betűtípusok a beállításjegyzék HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink alkulcsában vannak definiálva. Az alkulcshoz társított minden bejegyzés egy alapbetűtípus nevét adja meg, és értéke egy karakterlánc-tömb, amely meghatározza az alapbetűtípushoz kapcsolódó betűfájlokat és az alapbetűtípushoz csatolt betűtípusokat. A tömb minden tagja egy csatolt betűtípust határoz meg, és a betűtípus-fájlnév,betűtípus-név formátumot veszi fel. Az alábbi példa bemutatja, hogyan definiálhat programozott módon egy SimSun nevű csatolt betűtípust egy simsun.ttc nevű betűtípusfájlban, amely egyszerűsített Han-karaktereket jelenít meg.

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 Example2
    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)) Then
                ' 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()

A konzol Unicode-támogatása a következő korlátozásokkal rendelkezik:

• Az UTF-32 kódolás nem támogatott. Az egyetlen támogatott Unicode-kódolás az UTF-8 és az UTF-16, amelyeket az és az UTF8EncodingUnicodeEncoding osztályok jelölnek.

• A kétirányú kimenet nem támogatott.

• Az alapszintű többnyelvű síkon kívüli karakterek (azaz helyettesítő párok) megjelenítése nem támogatott, még akkor sem, ha egy csatolt betűtípusfájlban vannak definiálva.

• A karakterek megjelenítése összetett szkriptekben nem támogatott.

• A karaktersorozatok (azaz az alapkarakterekből és egy vagy több egyesítő karakterből álló karakterek) egyesítése külön karakterként jelenik meg. A korlátozás megkerüléséhez normalizálhatja a megjelenítendő sztringet úgy, hogy meghívja a metódust, String.Normalize mielőtt kimenetet küldene a konzolnak. Az alábbi példában az U+0061 U+0308 kombinációs karaktersorozatot tartalmazó sztring két karakterként jelenik meg a konzolon a kimeneti sztring normalizálása előtt, a metódus meghívása után String.Normalize pedig egyetlen karakterként.

  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 Example3
      Public Sub Main()
          Dim chars() As Char = {ChrW(&H61), ChrW(&H308)}
  
          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"
  //       ä
  

  A normalizálás csak akkor használható megoldás, ha a karakter Unicode szabványa tartalmaz egy előre összeállított űrlapot, amely egy adott egyesítő karaktersorozatnak felel meg.

• Ha egy betűtípus egy karakterjelet ad meg egy kódponthoz a magánhasználati területen, az a karakterjel jelenik meg. Mivel azonban a magánhasználati területen lévő karakterek alkalmazásspecifikusak, előfordulhat, hogy nem ez a várt glif.

Az alábbi példa Unicode-karakterekből álló tartományt jelenít meg a konzolon. A példa három parancssori paramétert fogad el: a megjelenítendő tartomány kezdetét, a megjelenítendő tartomány végét, valamint azt, hogy az aktuális konzolkódolást (false) vagy az UTF-16 kódolást (true) használja-e. Feltételezi, hogy a konzol TrueType betűtípust használ.

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  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ

Gyakori műveletek

Az Console osztály a következő metódusokat tartalmazza a konzol bemenetének olvasásához és a konzol kimenetének írásához:

• A ReadKey metódus túlterhelése egyéni karaktert olvas.

• A ReadLine metódus egy teljes sornyi bemenetet olvas be.

• A Write metódus túlterheli egy értéktípus egy példányát, egy karaktertömböt vagy objektumkészletet formázott vagy formázatlan sztringgé, majd ezt a sztringet a konzolra írja.

• A WriteLine metódusok párhuzamos túlterhelési készlete ugyanazt a karakterláncot adja ki, mint a Write túlterhelések, de egy sorvégződés karakterláncot is hozzáad.

Az Console osztály metódusokat és tulajdonságokat is tartalmaz a következő műveletek végrehajtásához:

• Kérje le vagy állítsa be a képernyőpuffer méretét. A BufferHeight tulajdonságok lehetővé teszik a puffer magasságának és szélességének lekérését vagy beállítását, a BufferWidth metódus pedig lehetővé teszi a pufferméret beállítását egyetlen metódushívásbanSetBufferSize.

• A konzolablak méretének lekérése vagy beállítása. WindowHeight A WindowWidth tulajdonságok lehetővé teszik az ablak magasságának és szélességének lekérését vagy beállítását, a SetWindowSize metódussal pedig egyetlen metódushívásban állíthatja be az ablakméretet.

• A kurzor méretének lekérése vagy beállítása. A CursorSize tulajdonság a kurzor magasságát adja meg egy karaktercellában.

• A konzolablak pozíciójának lekérése vagy beállítása a képernyőpufferhez képest. WindowTop A WindowLeft tulajdonságok segítségével lekérheti vagy beállíthatja a képernyőpuffer felső sorát és bal szélső oszlopát, amely a konzolablakban jelenik meg, és a SetWindowPosition metódus lehetővé teszi, hogy ezeket az értékeket egyetlen metódushívásban állítsa be.

• A kurzor pozíciójának lekéréséhez vagy beállításához használja a CursorTop és CursorLeft tulajdonságokat, vagy állítsa be a kurzor pozícióját a SetCursorPosition metódus meghívásával.

• A képernyőpufferben lévő adatok áthelyezése vagy törlése a MoveBufferArea metódus meghívásával Clear .

• Az ForegroundColor és BackgroundColor tulajdonságok segítségével lekérheti vagy beállíthatja az előtér- és háttérszíneket, vagy alaphelyzetbe állíthatja az előteret és a hátteret alapértelmezett színekre az ResetColor metódus meghívásával.

• Hangjelzés lejátszása a konzol hangszóróján a Beep metódus meghívásával.

Alapértelmezett kódolások

Azokban az esetekben, amikor .NET a kódlapkódolások csak korlátozott részhalmazát teszi elérhetővé, a konzol alapértelmezett kódolásaként a Encoding.UTF8 használható.

Ha az alkalmazás adott kódlapkódolásoktól függ, akkor is elérhetővé teheti őket a következő lépésekkel, mielőtt bármilyen Console metódust meghív:

1. Kérje le az EncodingProvider objektumot a CodePagesEncodingProvider.Instance tulajdonságból.

2. Adja át az EncodingProvider objektumot a Encoding.RegisterProvider metódusnak, hogy elérhetővé tegye a kódolásszolgáltató által támogatott további kódolásokat.

Az Console osztály ezután automatikusan az alapértelmezett rendszerkódolást fogja használni az UTF8 helyett, feltéve, hogy regisztrálta a kódolási szolgáltatót, mielőtt bármilyen Console kimeneti metódust meghívna.

Tulajdonságok

Name	Description
BackgroundColor	Lekéri vagy beállítja a konzol háttérszínét.
BufferHeight	Lekéri vagy beállítja a pufferterület magasságát.
BufferWidth	Lekéri vagy beállítja a pufferterület szélességét.
CapsLock	Beolvas egy értéket, amely jelzi, hogy a CAPS LOCK billentyűzet kapcsolója be van-e kapcsolva vagy ki van-e kapcsolva.
CursorLeft	Lekéri vagy beállítja a kurzor oszloppozícióját a pufferterületen belül.
CursorSize	Lekéri vagy beállítja a kurzor magasságát egy karaktercellán belül.
CursorTop	Lekéri vagy beállítja a kurzor sorpozícióját a pufferterületen belül.
CursorVisible	Beolvas vagy beállít egy értéket, amely jelzi, hogy a kurzor látható-e.
Error	Lekéri a standard hiba kimeneti adatfolyamát.
ForegroundColor	Lekéri vagy beállítja a konzol előtérszínét.
In	Lekéri a standard bemeneti adatfolyamot.
InputEncoding	Lekéri vagy beállítja a konzol által a bemenet olvasásához használt kódolást.
IsErrorRedirected	Olyan értéket kap, amely jelzi, hogy a hibakimeneti adatfolyam átirányítva lett-e a standard hibastreamből.
IsInputRedirected	Olyan értéket kap, amely jelzi, hogy a bemenet átirányítva lett-e a standard bemeneti adatfolyamból.
IsOutputRedirected	Olyan értéket kap, amely jelzi, hogy a kimenet átirányítva lett-e a standard kimeneti adatfolyamból.
KeyAvailable	Beolvas egy értéket, amely jelzi, hogy elérhető-e egy billentyű lenyomása a bemeneti adatfolyamban.
LargestWindowHeight	Az aktuális betűtípus és képernyőfelbontás alapján lekéri a lehető legtöbb konzolablaksort.
LargestWindowWidth	A lehető legtöbb konzolablak-oszlopot kapja meg az aktuális betűtípus és képernyőfelbontás alapján.
NumberLock	Beolvas egy értéket, amely jelzi, hogy a NUM LOCK billentyűzet kapcsolója be van-e kapcsolva vagy ki van-e kapcsolva.
Out	Lekéri a standard kimeneti streamet.
OutputEncoding	Lekéri vagy beállítja a konzol által a kimenet írásához használt kódolást.
Title	Lekéri vagy beállítja a cím megjelenítését a konzol címsorában.
TreatControlCAsInput	Lekéri vagy beállít egy értéket, amely jelzi, hogy a módosítókulcs és Control a C konzolkulcs (Ctrl+C) kombinációja normál bemenetként vagy az operációs rendszer által kezelt megszakításként van-e kezelve.
WindowHeight	Lekéri vagy beállítja a konzolablak területének magasságát.
WindowLeft	Lekéri vagy beállítja a konzolablak területének bal szélső pozícióját a képernyőpufferhez képest.
WindowTop	Lekéri vagy beállítja a konzolablak területének felső pozícióját a képernyőpufferhez képest.
WindowWidth	Lekéri vagy beállítja a konzolablak szélességét.

Metódusok

Name	Description
Beep()	Hangjelzést ad a konzol hangszóróján keresztül.
Beep(Int32, Int32)	Egy adott gyakoriságú és időtartamú hangjelzést játszik le a konzol hangszóróján keresztül.
Clear()	Törli a konzolpuffert és a megfelelő konzolablakot a megjelenítési információkból.
GetCursorPosition()	Lekéri a kurzor pozícióját.
MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor)	Másolja a képernyőpuffer megadott forrásterületét egy megadott célterületre.
MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32)	Másolja a képernyőpuffer megadott forrásterületét egy megadott célterületre.
OpenStandardError()	Beolvasja a standard hibastreamet.
OpenStandardError(Int32)	Beolvasja a szabványos hibafolyamot, amely egy megadott pufferméretre van beállítva.
OpenStandardInput()	Beolvasja a standard bemeneti adatfolyamot.
OpenStandardInput(Int32)	Beolvasja a szabványos bemeneti adatfolyamot, amely egy megadott pufferméretre van beállítva.
OpenStandardOutput()	Beolvasja a standard kimeneti streamet.
OpenStandardOutput(Int32)	Beolvasja a szabványos kimeneti adatfolyamot, amely egy megadott pufferméretre van beállítva.
Read()	Beolvassa a következő karaktert a standard bemeneti adatfolyamból.
ReadKey()	Beolvasja a felhasználó által lenyomott következő karaktert vagy függvénykulcsot. A lenyomott kulcs megjelenik a konzolablakban.
ReadKey(Boolean)	Beolvasja a felhasználó által lenyomott következő karaktert vagy függvénykulcsot. A lenyomott kulcs opcionálisan megjelenik a konzolablakban.
ReadLine()	Beolvassa a következő karaktersort a standard bemeneti adatfolyamból.
ResetColor()	Az előtér- és háttérkonzol színét az alapértelmezett értékre állítja.
SetBufferSize(Int32, Int32)	A képernyőpufferterület magasságát és szélességét a megadott értékekre állítja.
SetCursorPosition(Int32, Int32)	A kurzor pozícióját állítja be.
SetError(TextWriter)	Beállítja a Error tulajdonságot a megadott TextWriter objektumra.
SetIn(TextReader)	Beállítja a In tulajdonságot a megadott TextReader objektumra.
SetOut(TextWriter)	Beállítja a Out tulajdonságot, hogy megcélozza az TextWriter objektumot.
SetWindowPosition(Int32, Int32)	Beállítja a konzolablak helyzetét a képernyőpufferhez képest.
SetWindowSize(Int32, Int32)	A konzolablak magasságát és szélességét a megadott értékekre állítja.
Write(Boolean)	A megadott logikai érték szöveges ábrázolását írja a standard kimeneti streambe.
Write(Char)	A megadott Unicode-karakterértéket a standard kimeneti adatfolyamba írja.
Write(Char[], Int32, Int32)	Unicode-karakterek megadott alarráit írja a szabványos kimeneti adatfolyamba.
Write(Char[])	A Unicode-karakterek megadott tömbjének írása a standard kimeneti adatfolyamba.
Write(Decimal)	A megadott Decimal érték szöveges ábrázolását írja a standard kimeneti adatfolyamba.
Write(Double)	A megadott dupla pontosságú lebegőpontos érték szöveges ábrázolását írja a standard kimeneti adatfolyamba.
Write(Int32)	A megadott 32 bites aláírt egész szám szöveges ábrázolását írja a szabványos kimeneti adatfolyamba.
Write(Int64)	A megadott 64 bites aláírt egész szám szöveges ábrázolását írja a szabványos kimeneti adatfolyamba.
Write(Object)	A megadott objektum szöveges ábrázolását írja a standard kimeneti adatfolyamba.
Write(ReadOnlySpan<Char>)	A konzolalkalmazások szabványos bemenetét, kimenetét és hibastreameit jelöli. Ez az osztály nem örökölhető.
Write(Single)	A megadott egy pontosságú lebegőpontos érték szöveges ábrázolását írja a standard kimeneti adatfolyamba.
Write(String, Object, Object, Object)	A megadott objektumok szöveges ábrázolását a szabványos kimeneti adatfolyamba írja a megadott formátumadatok használatával.
Write(String, Object, Object)	A megadott objektumok szöveges ábrázolását a szabványos kimeneti adatfolyamba írja a megadott formátumadatok használatával.
Write(String, Object)	A megadott objektum szöveges ábrázolását a szabványos kimeneti adatfolyamba írja a megadott formátumadatok használatával.
Write(String, Object[])	A megadott objektumtömb szöveges ábrázolását írja a szabványos kimeneti adatfolyamba a megadott formátumadatok használatával.
Write(String, ReadOnlySpan<Object>)	A megadott objektumtartomány szöveges ábrázolását írja a szabványos kimeneti adatfolyamba a megadott formátumadatok használatával.
Write(String)	A megadott sztringértéket a standard kimeneti streambe írja.
Write(UInt32)	A megadott 32 bites aláíratlan egész szám szöveges ábrázolását írja a szabványos kimeneti adatfolyamba.
Write(UInt64)	A megadott 64 bites aláíratlan egész szám szöveges ábrázolását írja a szabványos kimeneti adatfolyamba.
WriteLine()	Az aktuális sor terminátorát a standard kimeneti streambe írja.
WriteLine(Boolean)	A megadott logikai érték szöveges ábrázolását, majd az aktuális sorleírót írja a standard kimeneti streambe.
WriteLine(Char)	A megadott Unicode-karaktert, majd az aktuális sor terminátorát írja a standard kimeneti streambe.
WriteLine(Char[], Int32, Int32)	A Unicode-karakterek megadott alarraját, majd az aktuális sor terminátorát írja a standard kimeneti adatfolyamba.
WriteLine(Char[])	A Unicode-karakterek megadott tömbjének, majd az aktuális sor terminátorának írása a standard kimeneti adatfolyamba.
WriteLine(Decimal)	A megadott Decimal érték szöveges ábrázolását, majd az aktuális sor terminátorát írja a standard kimeneti adatfolyamba.
WriteLine(Double)	A megadott két pontosságú lebegőpontos érték szöveges ábrázolását írja a standard kimeneti streambe, amelyet az aktuális sor terminátora követ.
WriteLine(Int32)	A megadott 32 bites aláírt egész szám szöveges ábrázolását írja a standard kimeneti streambe, amelyet az aktuális sor terminátora követ.
WriteLine(Int64)	A megadott 64 bites aláírt egész szám szöveges ábrázolását, majd az aktuális sor terminátorát írja a standard kimeneti streambe.
WriteLine(Object)	A megadott objektum szöveges ábrázolását, majd az aktuális sor terminátorát írja a standard kimeneti adatfolyamba.
WriteLine(ReadOnlySpan<Char>)	A konzolalkalmazások szabványos bemenetét, kimenetét és hibastreameit jelöli. Ez az osztály nem örökölhető.
WriteLine(Single)	A megadott egy pontosságú lebegőpontos érték szöveges ábrázolását írja le, amelyet az aktuális sor terminátora követ a standard kimeneti adatfolyamba.
WriteLine(String, Object, Object, Object)	A megadott objektumok szöveges ábrázolását, majd az aktuális sor terminátorát írja a szabványos kimeneti adatfolyamba a megadott formátuminformációk használatával.
WriteLine(String, Object, Object)	A megadott objektumok szöveges ábrázolását, majd az aktuális sor terminátorát írja a szabványos kimeneti adatfolyamba a megadott formátuminformációk használatával.
WriteLine(String, Object)	A megadott objektum szöveges ábrázolását, majd az aktuális vonal terminátorát írja a szabványos kimeneti adatfolyamba a megadott formátuminformációk használatával.
WriteLine(String, Object[])	A megadott objektumtömb szöveges ábrázolását, majd az aktuális sor terminátorát írja a szabványos kimeneti adatfolyamba a megadott formátuminformációk használatával.
WriteLine(String, ReadOnlySpan<Object>)	A megadott objektumtartomány szöveges ábrázolását, majd az aktuális vonal terminátorát írja a szabványos kimeneti adatfolyamba a megadott formátuminformációk használatával.
WriteLine(String)	A megadott sztringértéket, majd az aktuális sor terminátorát írja a standard kimeneti adatfolyamba.
WriteLine(UInt32)	A megadott 32 bites aláíratlan egész szám értékének szöveges ábrázolását, majd az aktuális sor terminátorát írja a standard kimeneti adatfolyamba.
WriteLine(UInt64)	A megadott 64 bites aláíratlan egész szám értékének szöveges ábrázolását, majd az aktuális sorkijelzőt írja a standard kimeneti streambe.

esemény

Name	Description
CancelKeyPress	Akkor fordul elő, ha a Control módosítókulcs (Ctrl) és a C konzolkulcs (C) vagy a Break billentyű egyidejű lenyomása (Ctrl+C vagy Ctrl+Break).

Szálbiztonság

Ez a típus szálbiztos.