Console Console Console Console Class

Definice

Představuje standardní vstupní, výstupní a chybové proudy pro konzolové aplikace.Represents the standard input, output, and error streams for console applications. Tuto třídu nelze zdědit.This class cannot be inherited.

public ref class Console abstract sealed
public static class Console
type Console = class
Public Class Console
Dědičnost
ConsoleConsoleConsoleConsole

Příklady

Následující příklad ukazuje, jak číst data z a zapsat data do, standardní vstupní a výstupní datové proudy.The following example demonstrates how to read data from, and write data to, the standard input and output streams. Všimněte si, že tyto datové proudy lze přesměrovat pomocí SetIn metod a. SetOutNote that these streams can be redirected by using the SetIn and SetOut methods.

using namespace System;

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

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

Poznámky

Konzola nástroje je okno operačního systému, kde uživatelé komunikují s operačním systémem nebo s textovou konzolovou aplikací, a to tak, že zadají textový vstup přes klávesnici počítače a přečtou textový výstup z terminálu počítače.The console is an operating system window where users interact with the operating system or with a text-based console application by entering text input through the computer keyboard, and by reading text output from the computer terminal. Například v operačním systému Windows se konzola nazývá okno příkazového řádku a akceptuje příkazy systému MS-DOS.For example, in the Windows operating system, the console is called the Command Prompt window and accepts MS-DOS commands. Console Třída poskytuje základní podporu pro aplikace, které čtou znaky z, a zapisuje znaky do konzoly.The Console class provides basic support for applications that read characters from, and write characters to, the console.

Informace o vývoji s Console třídou naleznete v následujících částech:For information about developing with the Console class, see the following sections:

Vstupně-výstupní datové proudy konzolyConsole I/O Streams

Když se spustí Konzolová aplikace, operační systém automaticky přidruží tři vstupně-výstupní proudy s konzolou: standardní vstupní proud, standardní výstupní proud a standardní chybový proud výstupu.When a console application starts, the operating system automatically associates three I/O streams with the console: standard input stream, standard output stream, and standard error output stream. Vaše aplikace může číst vstup uživatele ze standardního vstupního streamu. zapsat normální data do standardního výstupního proudu; a zápis chybových dat do standardního výstupního datového proudu chyb.Your application can read user input from the standard input stream; write normal data to the standard output stream; and write error data to the standard error output stream. Tyto datové proudy jsou prezentovány vaší aplikaci jako hodnoty Console.Invlastností, Console.Outa. Console.ErrorThese streams are presented to your application as the values of the Console.In, Console.Out, and Console.Error properties.

In Ve výchozím nastavení System.IO.TextReader je hodnota vlastnosti objekt, který představuje klávesnici, Out a hodnoty vlastností a Error jsou System.IO.TextWriter objekty, které představují okno konzoly.By default, the value of the In property is a System.IO.TextReader object that represents the keyboard, and the values of the Out and Error properties are System.IO.TextWriter objects that represent a console window. Tyto vlastnosti však můžete nastavit na datové proudy, které nepředstavuje okno konzoly nebo klávesnici. Můžete například nastavit tyto vlastnosti na proudy, které reprezentují soubory.However, you can set these properties to streams that do not represent the console window or keyboard; for example, you can set these properties to streams that represent files. Chcete-li přesměrovat standardní vstupní, standardní výstup nebo standardní chybový proud, Console.SetInzavolejte Console.SetOutmetodu, Console.SetError nebo v uvedeném pořadí.To redirect the standard input, standard output, or standard error stream, call the Console.SetIn, Console.SetOut, or Console.SetError method, respectively. I/O operace, které používají tyto datové proudy, jsou synchronizovány, což znamená, že více vláken může číst nebo zapisovat do datových proudů.I/O operations that use these streams are synchronized, which means that multiple threads can read from, or write to, the streams. To znamená, že metody, které jsou obvykle asynchronní, TextReader.ReadLineAsyncnapříklad, jsou spouštěny synchronně, pokud objekt představuje datový proud konzoly.This means that methods that are ordinarily asynchronous, such as TextReader.ReadLineAsync, execute synchronously if the object represents a console stream.

Poznámka

Nepoužívejte Console třídu k zobrazení výstupu v bezobslužných aplikacích, jako jsou například serverové aplikace.Do not use the Console class to display output in unattended applications, such as server applications. Volání metod, jako je Console.Write a Console.WriteLine nemají žádný vliv na aplikace grafického uživatelského rozhraní.Calls to methods such as Console.Write and Console.WriteLine have no effect in GUI applications.

Consolečleny třídy, které pracují normálně, když je podkladový datový proud směrován do konzoly, mohou vyvolat výjimku, pokud je datový proud přesměrován do souboru, například.Console class members that work normally when the underlying stream is directed to a console might throw an exception if the stream is redirected, for example, to a file. Naprogramujte aplikaci, System.IO.IOException aby zachytával výjimky při přesměrování standardního streamu.Program your application to catch System.IO.IOException exceptions if you redirect a standard stream. Můžete také použít IsOutputRedirectedvlastnosti, IsInputRedirecteda IsErrorRedirected k určení, zda je standardní datový proud System.IO.IOException přesměrován před provedením operace, která vyvolá výjimku.You can also use the IsOutputRedirected, IsInputRedirected, and IsErrorRedirected properties to determine whether a standard stream is redirected before performing an operation that throws an System.IO.IOException exception.

Někdy je užitečné explicitně volat členy objektů streamu reprezentovaných Invlastnostmi, Outa Error .It is sometimes useful to explicitly call the members of the stream objects represented by the In, Out, and Error properties. Například ve výchozím nastavení Console.ReadLine metoda čte vstup ze standardního vstupního datového proudu.For example, by default, the Console.ReadLine method reads input from the standard input stream. Console.WriteLine Podobně Metoda zapisuje data do standardního výstupního proudu a data jsou následovány výchozím řetězcem ukončení řádku, což je návrat vozíku a posun řádku ("\r\n").Similarly, the Console.WriteLine method writes data to the standard output stream, and the data is followed by the default line termination string, which is a carriage return and line feed ("\r\n"). Console Třída však neposkytuje odpovídající metodu pro zápis dat do standardního výstupního datového proudu, nebo vlastnost pro změnu ukončovacího řetězce řádku pro data zapsaná do tohoto datového proudu.However, the Console class does not provide a corresponding method to write data to the standard error output stream, or a property to change the line termination string for data written to that stream.

Tento problém lze vyřešit nastavením TextWriter.NewLine vlastnosti Out nebo Error vlastnosti na jiný řetězec ukončení řádku.You can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. Například následující C# příkaz nastaví řetězec ukončení řádku pro standardní chybový datový proud na dvě návraty na začátek řádku a posloupnosti kanálu čáry:For example, the following C# statement sets the line termination string for the standard error output stream to two carriage return and line feed sequences:

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

Pak můžete explicitně volat WriteLine metodu výstupního datového proudu chyb, jak je uvedeno v následujícím C# příkazu:You can then explicitly call the WriteLine method of the error output stream object, as in the following C# statement:

Console.Error.WriteLine();

Vyrovnávací paměť obrazovky a okno konzolyScreen Buffer and Console Window

Dvě úzce související funkce konzoly jsou vyrovnávací paměť obrazovky a okno konzoly.Two closely related features of the console are the screen buffer and the console window. Text se ve skutečnosti čte nebo zapisuje do datových proudů vlastněných konzolou, ale zdá se, že se čte nebo zapisuje do oblasti vlastněné konzolou s názvem vyrovnávací paměť obrazovky.Text is actually read from or written to streams owned by the console, but appear to be read from or written to an area owned by the console called the screen buffer. Vyrovnávací paměť obrazovky je atributem konzoly a je uspořádána jako obdélníková mřížka řádků a sloupců, kde každá průsečíka mřížky nebo znaková buňka může obsahovat znak.The screen buffer is an attribute of the console, and is organized as a rectangular grid of rows and columns where each grid intersection, or character cell, can contain a character. Každý znak má svou vlastní barvu popředí a každá buňka s znakem má svou vlastní barvu pozadí.Each character has its own foreground color, and each character cell has its own background color.

Vyrovnávací paměť obrazovky se zobrazí v obdélníkové oblasti, která se nazývá okno konzoly.The screen buffer is viewed through a rectangular region called the console window. Okno konzoly je další atribut konzoly. Nejedná se o konzolu, což je okno operačního systému.The console window is another attribute of the console; it is not the console itself, which is an operating system window. Okno konzoly je uspořádáno v řádcích a sloupcích, je menší než nebo rovno velikosti vyrovnávací paměti obrazovky a lze jej přesunout k zobrazení různých oblastí základní vyrovnávací paměti obrazovky.The console window is arranged in rows and columns, is less than or equal to the size of the screen buffer, and can be moved to view different areas of the underlying screen buffer. Pokud je vyrovnávací paměť obrazovky větší než okno konzoly, konzola automaticky zobrazí posuvníky, takže okno konzoly lze přemístit v oblasti vyrovnávací paměti obrazovky.If the screen buffer is larger than the console window, the console automatically displays scroll bars so the console window can be repositioned over the screen buffer area.

Ukazatel myši indikuje umístění vyrovnávací paměti obrazovky, kde je text aktuálně čten nebo napsán.A cursor indicates the screen buffer position where text is currently read or written. Kurzor může být skrytý nebo viditelný a jeho výška může být změněna.The cursor can be hidden or made visible, and its height can be changed. Pokud je kurzor viditelný, pozice okna konzoly je automaticky přesunuta, aby byl kurzor vždy zobrazen.If the cursor is visible, the console window position is moved automatically so the cursor is always in view.

Počátek souřadnic buňky znaků ve vyrovnávací paměti obrazovky je v levém horním rohu a pozice kurzoru a okna konzoly jsou měřeny relativně k tomuto původu.The origin for character cell coordinates in the screen buffer is the upper left corner, and the positions of the cursor and the console window are measured relative to that origin. K určení pozic použijte indexy založené na nule. To znamená, že zadáte horní řádek jako řádek 0 a sloupec nejvíce vlevo jako sloupec 0.Use zero-based indexes to specify positions; that is, specify the topmost row as row 0, and the leftmost column as column 0. Maximální hodnota pro indexy řádků a sloupců je Int16.MaxValue.The maximum value for the row and column indexes is Int16.MaxValue.

Podpora kódování Unicode pro konzoluUnicode Support for the Console

Obecně platí, že konzola nástroje čte vstup a zapisuje výstup pomocí aktuální znakové stránky konzoly, která standardně definuje národní prostředí systému.In general, the console reads input and writes output by using the current console code page, which the system locale defines by default. Znaková stránka může zpracovat pouze podmnožinu dostupných znaků Unicode, takže pokud se pokusíte zobrazit znaky, které nejsou namapované konkrétní znakovou stránkou, konzola nebude moci zobrazit všechny znaky, nebo je reprezentovat přesně.A code page can handle only a subset of available Unicode characters, so if you try to display characters that are not mapped by a particular code page, the console won't be able to display all characters or represent them accurately. Následující příklad ukazuje tento problém.The following example illustrates this problem. V konzole se pokusí zobrazit znaky v cyrilici od U + 0410 do U + 044F.It tries to display the characters of the Cyrillic alphabet from U+0410 to U+044F to the console. Pokud spustíte příklad v systému, který používá znakovou stránku konzoly 437, každý znak je nahrazen otazníkem (?), protože znaky cyrilice nemapují na znaky v kódové stránce 437.If you run the example on a system that uses console code page 437, each character is replaced by a question mark (?), because Cyrillic characters do not map to the characters in code page 437.

using System;

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

Kromě podpůrných znakových stránek Console třída podporuje kódování UTF-8 UTF8Encoding s třídou.In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. Počínaje .NET Framework 4,5 Console třída také podporuje kódování UTF-16 UnicodeEncoding s třídou.Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. Zobrazení znaků Unicode v konzole nástroje.To display Unicode characters to the console. Nastavte OutputEncoding vlastnost na buď UTF8Encoding nebo UnicodeEncoding.you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

Podpora znaků Unicode vyžaduje kodér pro rozpoznání konkrétního znaku Unicode a také vyžaduje písmo, které má glyfy potřebné k vykreslení daného znaku.Support for Unicode characters requires the encoder to recognize a particular Unicode character, and also requires a font that has the glyphs needed to render that character. Chcete-li úspěšně zobrazit znaky Unicode v konzole nástroje, musí být písmo konzoly nastaveno na nerastrové nebo písmo TrueType, jako je například Consolas nebo Lucida konzola.To successfully display Unicode characters to the console, the console font must be set to a non-raster or TrueType font such as Consolas or Lucida Console. Následující příklad ukazuje, jak můžete programově změnit písmo z rastrového písma na konzolu Lucida.The following example shows how you can programmatically change the font from a raster font to Lucida Console.

using System;
using System.Runtime.InteropServices;

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

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

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

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

Písma TrueType ale můžou zobrazit jenom podmnožinu glyfů.However, TrueType fonts can display only a subset of glyphs. Například písmo konzoly Lucida zobrazí pouze 643 přibližně 64 000 dostupných znaků od U + 0021 do U + FB02.For example, the Lucida Console font displays only 643 of the approximately 64,000 available characters from U+0021 to U+FB02. Chcete-li zjistit, které znaky konkrétní písmo podporuje, otevřete aplet písma v Ovládacích panelech, vyberte možnost najít znak a vyberte písmo, jehož znaková sada se má prošetřit, v seznamu písem mapy znaků . okno.To see which characters a particular font supports, open the Fonts applet in Control Panel, choose the Find a character option, and choose the font whose character set you'd like to examine in the Font list of the Character Map window.

Systém Windows používá propojení písma k zobrazení glyfů, které nejsou k dispozici v konkrétním písmu.Windows uses font linking to display glyphs that are not available in a particular font. Informace o propojení písem pro zobrazení dalších znakových sad naleznete v tématu globalizace krok za krokem: Písma.For information about font linking to display additional character sets, see Globalization Step-by-Step: Fonts. Propojená písma jsou definována v podklíči HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink registru.Linked fonts are defined in the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink subkey of the registry. Každá položka, která je přidružená k tomuto podklíči, odpovídá názvu základního písma a jeho hodnota je pole řetězců definující soubory písem a písma, která jsou propojena se základním písmem.Each entry associated with this subkey corresponds to the name of a base font, and its value is a string array that defines the font files and the fonts that are linked to the base font. Každý člen pole definuje propojené písmo a má formát Font-File-Name,Font-name.Each member of the array defines a linked font and takes the form font-file-name,font-name. Následující příklad ukazuje, jak programově definovat propojené písmo s názvem SimSun nalezené v souboru písma s názvem SimSun. TTC, který zobrazuje zjednodušené znaky Han.The following example illustrates how you can programmatically define a linked font named SimSun found in a font file named simsun.ttc that displays Simplified Han characters.

using Microsoft.Win32;
using System;

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

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

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

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

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

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

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

Podpora kódování Unicode pro konzolu má následující omezení:Unicode support for the console has the following limitations:

  • Kódování UTF-32 se nepodporuje.UTF-32 encoding is not supported. Jediným podporovaným kódováním Unicode jsou UTF-8 a UTF-16, které jsou reprezentované UTF8Encoding třídami a UnicodeEncoding v uvedeném pořadí.The only supported Unicode encodings are UTF-8 and UTF-16, which are represented by the UTF8Encoding and UnicodeEncoding classes, respectively.

  • Obousměrný výstup není podporován.Bidirectional output is not supported.

  • Zobrazení znaků mimo základní vícejazyčné roviny (tj. náhradní páry) není podporováno, i když jsou definována v propojeném souboru písma.Display of characters outside the Basic Multilingual Plane (that is, of surrogate pairs) is not supported, even if they are defined in a linked font file.

  • Zobrazení znaků ve složitých skriptech není podporováno.Display of characters in complex scripts is not supported.

  • Kombinování znakových sekvencí (tj. znaků, které se skládají ze základního znaku a jednoho nebo více kombinací znaků), se zobrazují jako samostatné znaky.Combining character sequences (that is, characters that consist of a base character and one or more combining characters) are displayed as separate characters. Chcete-li toto omezení obejít, můžete normalizovat řetězec, který se má zobrazit, String.Normalize voláním metody před odesláním výstupu do konzoly.To work around this limitation, you can normalize the string to be displayed by calling the String.Normalize method before sending output to the console. V následujícím příkladu je řetězec, který obsahuje posloupnost znaků kombinace U + 0061 u + 0308, zobrazen do konzoly jako dva znaky před normalizovaním výstupního řetězce a jako jeden znak po String.Normalize volání metody.In the following example, a string that contains the combining character sequence U+0061 U+0308 is displayed to the console as two characters before the output string is normalized, and as a single character after the String.Normalize method is called.

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

    Normalizace je životaschopné řešení pouze v případě, že standard Unicode pro daný znak obsahuje předem složený formulář, který odpovídá konkrétní posloupnosti znaků kombinování.Note that normalization is a viable solution only if the Unicode standard for the character includes a pre-composed form that corresponds to a particular combining character sequence.

  • Pokud písmo poskytuje glyf pro bod kódu v oblasti soukromé použití, zobrazí se tento glyf.If a font provides a glyph for a code point in the private use area, that glyph will be displayed. Vzhledem k tomu, že znaky v oblasti privátního použití jsou specifické pro aplikaci, nemusí se jednat o očekávaný glyf.However, because characters in the private use area are application-specific, this may not be the expected glyph.

Následující příklad zobrazuje rozsah znaků Unicode pro konzolu.The following example displays a range of Unicode characters to the console. V příkladu se akceptují tři parametry příkazového řádku: začátek rozsahu, který se má zobrazit, konec rozsahu, který se má zobrazit, a zda se má použít aktuální kódovánífalsekonzoly () nebo kódování UTF-true16 ().The example accepts three command-line parameters: the start of the range to display, the end of the range to display, and whether to use the current console encoding (false) or UTF-16 encoding (true). Předpokládá, že konzola používá písmo TrueType.It assumes that the console is using a TrueType font.

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

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

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

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

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

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

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

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

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

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

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

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

Běžné operaceCommon Operations

Console Třída obsahuje následující metody pro čtení vstupu z konzoly a zápis výstupu konzoly:The Console class contains the following methods for reading console input and writing console output:

  • Přetížení ReadKey metody čtou jednotlivý znak.The overloads of the ReadKey method read an individual character.

  • ReadLine Metoda přečte celý řádek vstupu.The ReadLine method reads an entire line of input.

  • Write Metoda přetížení převádí instanci typu hodnoty, pole znaků nebo sadu objektů na formátovaný nebo neformátovaný řetězec a pak tento řetězec zapíše do konzoly.The Write method overloads convert an instance of a value type, an array of characters, or a set of objects to a formatted or unformatted string, and then write that string to the console.

  • Paralelní množina WriteLine metod přetížení výstupuje stejný řetězec Write jako přetížení, ale také přidá ukončovací řetězec řádku.A parallel set of WriteLine method overloads output the same string as the Write overloads but also add a line termination string.

Console Třída také obsahuje metody a vlastnosti pro provedení následujících operací:The Console class also contains methods and properties to perform the following operations:

  • Získá nebo nastaví velikost vyrovnávací paměti obrazovky.Get or set the size of the screen buffer. Vlastnosti BufferHeight SetBufferSize a BufferWidth umožňují získat nebo nastavit výšku a šířku vyrovnávací paměti a metoda umožňuje nastavit velikost vyrovnávací paměti v jednom volání metody.The BufferHeight and BufferWidth properties let you get or set the buffer height and width, respectively, and the SetBufferSize method lets you set the buffer size in a single method call.

  • Získá nebo nastaví velikost okna konzoly.Get or set the size of the console window. Vlastnosti WindowHeight SetWindowSize a WindowWidth umožňují získat nebo nastavit výšku a šířku okna a metoda umožňuje nastavit velikost okna v jednom volání metody.The WindowHeight and WindowWidth properties let you get or set the window height and width, respectively, and the SetWindowSize method lets you set the window size in a single method call.

  • Získá nebo nastaví velikost kurzoru.Get or set the size of the cursor. CursorSize Vlastnost určuje výšku kurzoru v buňce znaků.The CursorSize property specifies the height of the cursor in a character cell.

  • Získá nebo nastaví umístění okna konzoly relativně ke vyrovnávací paměti obrazovky.Get or set the position of the console window relative to the screen buffer. Vlastnosti WindowTop SetWindowPosition a WindowLeft umožňují získat nebo nastavit horní řádek a sloupec nejvíce vlevo vyrovnávací paměti obrazovky, která se zobrazí v okně konzoly, a metoda vám umožní nastavit tyto hodnoty v jednom volání metody.The WindowTop and WindowLeft properties let you get or set the top row and leftmost column of the screen buffer that appears in the console window, and the SetWindowPosition method lets you set these values in a single method call.

  • Získat nebo nastavit pozici kurzoru pomocí získání nebo nastavení CursorTop vlastností a CursorLeft nebo nastavením pozice kurzoru voláním SetCursorPosition metody.Get or set the position of the cursor by getting or setting the CursorTop and CursorLeft properties, or set the position of the cursor by calling the SetCursorPosition method.

  • Přesunutí nebo vymazání dat ve vyrovnávací paměti obrazovky voláním MoveBufferArea metody nebo. ClearMove or clear data in the screen buffer by calling the MoveBufferArea or Clear method.

  • Získejte nebo nastavte barvy popředí a pozadí pomocí ForegroundColor vlastností a BackgroundColor nebo obnovte pozadí a popředí na ResetColor výchozí barvy voláním metody.Get or set the foreground and background colors by using the ForegroundColor and BackgroundColor properties, or reset the background and foreground to their default colors by calling the ResetColor method.

  • Přehrání zvuku pípnutí prostřednictvím mluvčího v konzole voláním Beep metody.Play the sound of a beep through the console speaker by calling the Beep method.

.NET Core.NET CorePoznámkaNotes

V .NET Framework na ploše Console používá třída kódování vracené pomocí GetConsoleCP a GetConsoleOutputCP, což je obvykle kódování znakové stránky.In the .NET Framework on the desktop, the Console class uses the encoding returned by GetConsoleCP and GetConsoleOutputCP, which typically is a code page encoding. Například kód v systémech, jejichž jazyková verze je English (USA), je znaková stránka 437 kódování, které je používáno ve výchozím nastavení.For example code, on systems whose culture is English (United States), code page 437 is the encoding that is used by default. .NET Core.NET Core Může však mít k dispozici pouze omezené podmnožiny těchto kódování.However, .NET Core.NET Core may make only a limited subset of these encodings available. V takovém případě Encoding.UTF8 se používá jako výchozí kódování pro konzolu.Where this is the case, Encoding.UTF8 is used as the default encoding for the console.

Pokud vaše aplikace závisí na konkrétním kódování znakové stránky, můžete je stále zpřístupnit pomocí následujícího postupu před voláním libovolných Console metod:If your app depends on specific code page encodings, you can still make them available by doing the following before you call any Console methods:

  1. Přidejte odkaz na sestavení System. text. Encoding. CodePages. dll do vašeho projektu.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Načtěte CodePagesEncodingProvider.Instance objekt z vlastnosti. EncodingProviderRetrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Předejte Encoding.RegisterProvider objekt metodě, aby bylo k dispozici další kódování podporovaná zprostředkovatelem kódování. EncodingProviderPass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

Třída pak automaticky použije výchozí kódování systému místo UTF8, za předpokladu, že jste zaregistrováni zprostředkovatele kódování před Console voláním metod výstupu. ConsoleThe Console class will then automatically use the default system encoding rather than UTF8, provided that you have registered the encoding provider before calling any Console output methods.

Vlastnosti

BackgroundColor BackgroundColor BackgroundColor BackgroundColor

Získá nebo nastaví barvu pozadí konzoly.Gets or sets the background color of the console.

BufferHeight BufferHeight BufferHeight BufferHeight

Získá nebo nastaví výšku oblasti vyrovnávací paměti.Gets or sets the height of the buffer area.

BufferWidth BufferWidth BufferWidth BufferWidth

Získá nebo nastaví šířku oblasti vyrovnávací paměti.Gets or sets the width of the buffer area.

CapsLock CapsLock CapsLock CapsLock

Načte hodnotu, která označuje, jestli je přepínač klávesnice Caps Lock zapnutý nebo vypnutý.Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft CursorLeft CursorLeft CursorLeft

Získá nebo nastaví pozici sloupce kurzoru v oblasti vyrovnávací paměti.Gets or sets the column position of the cursor within the buffer area.

CursorSize CursorSize CursorSize CursorSize

Získá nebo nastaví výšku kurzoru v rámci buňky znaků.Gets or sets the height of the cursor within a character cell.

CursorTop CursorTop CursorTop CursorTop

Získá nebo nastaví pozici řádku kurzoru v oblasti vyrovnávací paměti.Gets or sets the row position of the cursor within the buffer area.

CursorVisible CursorVisible CursorVisible CursorVisible

Získá nebo nastaví hodnotu označující, zda je kurzor viditelný.Gets or sets a value indicating whether the cursor is visible.

Error Error Error Error

Načte standardní výstupní chybový datový proud.Gets the standard error output stream.

ForegroundColor ForegroundColor ForegroundColor ForegroundColor

Získá nebo nastaví barvu popředí konzoly.Gets or sets the foreground color of the console.

In In In In

Získá standardní vstupní datový proud.Gets the standard input stream.

InputEncoding InputEncoding InputEncoding InputEncoding

Získá nebo nastaví kódování, které konzola používá ke čtení vstupu.Gets or sets the encoding the console uses to read input.

IsErrorRedirected IsErrorRedirected IsErrorRedirected IsErrorRedirected

Získá hodnotu, která označuje, zda byl výstupní datový proud chyby přesměrován ze standardního streamu chyb.Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected IsInputRedirected IsInputRedirected IsInputRedirected

Načte hodnotu, která označuje, zda byl vstup přesměrován ze standardního vstupního datového proudu.Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected IsOutputRedirected IsOutputRedirected IsOutputRedirected

Získá hodnotu, která označuje, zda byl výstup přesměrován ze standardního výstupního datového proudu.Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable KeyAvailable KeyAvailable KeyAvailable

Načte hodnotu, která označuje, jestli je ve vstupním proudu k dispozici klávesová zpráva.Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight LargestWindowHeight LargestWindowHeight LargestWindowHeight

Získá největší možný počet řádků okna konzoly na základě aktuálního rozlišení písma a obrazovky.Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth LargestWindowWidth LargestWindowWidth LargestWindowWidth

Získá největší možný počet sloupců okna konzoly na základě aktuálního rozlišení písma a obrazovky.Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock NumberLock NumberLock NumberLock

Načte hodnotu, která označuje, jestli je zapnutý nebo vypnutý přepínač NUM LOCK.Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out Out Out Out

Získá standardní výstupní datový proud.Gets the standard output stream.

OutputEncoding OutputEncoding OutputEncoding OutputEncoding

Získá nebo nastaví kódování, které konzola používá k zápisu výstupu.Gets or sets the encoding the console uses to write output.

Title Title Title Title

Získá nebo nastaví název, který se zobrazí v záhlaví konzoly.Gets or sets the title to display in the console title bar.

TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput

Získává nebo nastavuje hodnotu, která označuje, jestli je kombinace Control modifikační klávesy a C klíče konzoly (CTRL + C) považována za běžný vstup nebo jako přerušení, která je zpracovávána operačním systémem.Gets or sets a value indicating whether the combination of the Control modifier key and C console key (Ctrl+C) is treated as ordinary input or as an interruption that is handled by the operating system.

WindowHeight WindowHeight WindowHeight WindowHeight

Získá nebo nastaví výšku oblasti okna konzoly.Gets or sets the height of the console window area.

WindowLeft WindowLeft WindowLeft WindowLeft

Získá nebo nastaví pozici zcela vlevo v oblasti okna konzoly vzhledem k vyrovnávací paměti obrazovky.Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop WindowTop WindowTop WindowTop

Získá nebo nastaví horní pozici oblasti okna konzoly vzhledem ke vyrovnávací paměti obrazovky.Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth WindowWidth WindowWidth WindowWidth

Získá nebo nastaví šířku okna konzoly.Gets or sets the width of the console window.

Metody

Beep() Beep() Beep() Beep()

Hraje zvuk pípnutí přes mluvčí konzoly.Plays the sound of a beep through the console speaker.

Beep(Int32, Int32) Beep(Int32, Int32) Beep(Int32, Int32) Beep(Int32, Int32)

Hraje zvuk signálu zadané frekvence a trvání prostřednictvím mluvčího v konzole.Plays the sound of a beep of a specified frequency and duration through the console speaker.

Clear() Clear() Clear() Clear()

Vymaže vyrovnávací paměť konzoly a odpovídající okno konzoly informací o zobrazení.Clears the console buffer and corresponding console window of display information.

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

Zkopíruje zadanou zdrojovou oblast vyrovnávací paměti obrazovky do zadané cílové oblasti.Copies a specified source area of the screen buffer to a specified destination area.

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

Zkopíruje zadanou zdrojovou oblast vyrovnávací paměti obrazovky do zadané cílové oblasti.Copies a specified source area of the screen buffer to a specified destination area.

OpenStandardError() OpenStandardError() OpenStandardError() OpenStandardError()

Získá standardní chybový proud.Acquires the standard error stream.

OpenStandardError(Int32) OpenStandardError(Int32) OpenStandardError(Int32) OpenStandardError(Int32)

Získá standardní chybový proud, který je nastaven na zadanou velikost vyrovnávací paměti.Acquires the standard error stream, which is set to a specified buffer size.

OpenStandardInput() OpenStandardInput() OpenStandardInput() OpenStandardInput()

Získá standardní vstupní datový proud.Acquires the standard input stream.

OpenStandardInput(Int32) OpenStandardInput(Int32) OpenStandardInput(Int32) OpenStandardInput(Int32)

Získá standardní vstupní datový proud, který je nastaven na zadanou velikost vyrovnávací paměti.Acquires the standard input stream, which is set to a specified buffer size.

OpenStandardOutput() OpenStandardOutput() OpenStandardOutput() OpenStandardOutput()

Získá standardní výstupní datový proud.Acquires the standard output stream.

OpenStandardOutput(Int32) OpenStandardOutput(Int32) OpenStandardOutput(Int32) OpenStandardOutput(Int32)

Získá standardní výstupní datový proud, který je nastaven na zadanou velikost vyrovnávací paměti.Acquires the standard output stream, which is set to a specified buffer size.

Read() Read() Read() Read()

Přečte další znak ze standardního vstupního streamu.Reads the next character from the standard input stream.

ReadKey() ReadKey() ReadKey() ReadKey()

Obdrží další znak nebo funkční klávesu, které jsou stisknuty uživatelem.Obtains the next character or function key pressed by the user. Stisknutí klávesy se zobrazí v okně konzoly.The pressed key is displayed in the console window.

ReadKey(Boolean) ReadKey(Boolean) ReadKey(Boolean) ReadKey(Boolean)

Obdrží další znak nebo funkční klávesu, které jsou stisknuty uživatelem.Obtains the next character or function key pressed by the user. Stisknutí klávesy se volitelně zobrazí v okně konzoly.The pressed key is optionally displayed in the console window.

ReadLine() ReadLine() ReadLine() ReadLine()

Přečte další řádek znaků ze standardního vstupního streamu.Reads the next line of characters from the standard input stream.

ResetColor() ResetColor() ResetColor() ResetColor()

Nastaví barvy konzoly popředí a pozadí na jejich výchozí hodnoty.Sets the foreground and background console colors to their defaults.

SetBufferSize(Int32, Int32) SetBufferSize(Int32, Int32) SetBufferSize(Int32, Int32) SetBufferSize(Int32, Int32)

Nastaví výšku a šířku oblasti vyrovnávací paměti obrazovky na zadané hodnoty.Sets the height and width of the screen buffer area to the specified values.

SetCursorPosition(Int32, Int32) SetCursorPosition(Int32, Int32) SetCursorPosition(Int32, Int32) SetCursorPosition(Int32, Int32)

Nastaví pozici kurzoru.Sets the position of the cursor.

SetError(TextWriter) SetError(TextWriter) SetError(TextWriter) SetError(TextWriter)

Nastaví vlastnost na zadaný TextWriter objekt. ErrorSets the Error property to the specified TextWriter object.

SetIn(TextReader) SetIn(TextReader) SetIn(TextReader) SetIn(TextReader)

Nastaví vlastnost na zadaný TextReader objekt. InSets the In property to the specified TextReader object.

SetOut(TextWriter) SetOut(TextWriter) SetOut(TextWriter) SetOut(TextWriter)

Nastaví vlastnost pro cílení na TextWriterobjekt. OutSets the Out property to target the TextWriter object.

SetWindowPosition(Int32, Int32) SetWindowPosition(Int32, Int32) SetWindowPosition(Int32, Int32) SetWindowPosition(Int32, Int32)

Nastaví umístění okna konzoly relativně ke vyrovnávací paměti obrazovky.Sets the position of the console window relative to the screen buffer.

SetWindowSize(Int32, Int32) SetWindowSize(Int32, Int32) SetWindowSize(Int32, Int32) SetWindowSize(Int32, Int32)

Nastaví výšku a šířku okna konzoly na zadané hodnoty.Sets the height and width of the console window to the specified values.

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

Zapíše textovou reprezentaci zadaných objektů a seznamu parametrů s proměnlivou délkou do standardního výstupního datového proudu pomocí zadaných informací o formátu.Writes the text representation of the specified objects and variable-length parameter list to the standard output stream using the specified format information.

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

Zapíše textovou reprezentaci zadaných objektů do standardního výstupního datového proudu pomocí zadaných informací o formátu.Writes the text representation of the specified objects to the standard output stream using the specified format information.

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

Zapíše textovou reprezentaci zadaných objektů do standardního výstupního datového proudu pomocí zadaných informací o formátu.Writes the text representation of the specified objects to the standard output stream using the specified format information.

Write(String, Object[]) Write(String, Object[]) Write(String, Object[]) Write(String, Object[])

Zapíše textovou reprezentaci zadaného pole objektů do standardního výstupního datového proudu pomocí zadaných informací o formátu.Writes the text representation of the specified array of objects to the standard output stream using the specified format information.

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

Zapíše textovou reprezentaci zadaného objektu do standardního výstupního datového proudu pomocí zadaných informací o formátu.Writes the text representation of the specified object to the standard output stream using the specified format information.

Write(UInt64) Write(UInt64) Write(UInt64) Write(UInt64)

Zapíše textovou reprezentaci zadané hodnoty 64 unsigned integer do standardního výstupního proudu.Writes the text representation of the specified 64-bit unsigned integer value to the standard output stream.

Write(UInt32) Write(UInt32) Write(UInt32) Write(UInt32)

Zapíše textovou reprezentaci zadané hodnoty 32 unsigned integer do standardního výstupního proudu.Writes the text representation of the specified 32-bit unsigned integer value to the standard output stream.

Write(String) Write(String) Write(String) Write(String)

Zapíše zadanou řetězcovou hodnotu do standardního výstupního proudu.Writes the specified string value to the standard output stream.

Write(Char[], Int32, Int32) Write(Char[], Int32, Int32) Write(Char[], Int32, Int32) Write(Char[], Int32, Int32)

Zapíše zadané podpole znaků Unicode do standardního výstupního proudu.Writes the specified subarray of Unicode characters to the standard output stream.

Write(Object) Write(Object) Write(Object) Write(Object)

Zapíše textovou reprezentaci zadaného objektu do standardního výstupního proudu.Writes the text representation of the specified object to the standard output stream.

Write(Single) Write(Single) Write(Single) Write(Single)

Zapíše text reprezentující zadanou hodnotu s jednoduchou přesností a plovoucí desetinnou čárkou do standardního výstupního proudu.Writes the text representation of the specified single-precision floating-point value to the standard output stream.

Write(Char) Write(Char) Write(Char) Write(Char)

Zapíše zadanou hodnotu znaku Unicode do standardního výstupního proudu.Writes the specified Unicode character value to the standard output stream.

Write(Char[]) Write(Char[]) Write(Char[]) Write(Char[])

Zapíše zadané pole znaků Unicode do standardního výstupního proudu.Writes the specified array of Unicode characters to the standard output stream.

Write(Boolean) Write(Boolean) Write(Boolean) Write(Boolean)

Zapíše textovou reprezentaci zadané logické hodnoty do standardního výstupního proudu.Writes the text representation of the specified Boolean value to the standard output stream.

Write(Double) Write(Double) Write(Double) Write(Double)

Zapíše textovou reprezentaci zadané hodnoty s plovoucí desetinnou čárkou s dvojitou přesností do standardního výstupního proudu.Writes the text representation of the specified double-precision floating-point value to the standard output stream.

Write(Int32) Write(Int32) Write(Int32) Write(Int32)

Zapíše textovou reprezentaci zadaného celého čísla se znaménkem (32) do standardního výstupního proudu.Writes the text representation of the specified 32-bit signed integer value to the standard output stream.

Write(Int64) Write(Int64) Write(Int64) Write(Int64)

Zapíše textovou reprezentaci zadaného celého čísla se znaménkem (64) do standardního výstupního proudu.Writes the text representation of the specified 64-bit signed integer value to the standard output stream.

Write(Decimal) Write(Decimal) Write(Decimal) Write(Decimal)

Zapíše textovou reprezentaci zadané Decimal hodnoty do standardního výstupního proudu.Writes the text representation of the specified Decimal value to the standard output stream.

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

Zapíše textovou reprezentaci zadaných objektů následovaný ukončovacím znakem aktuálního řádku do standardního výstupního datového proudu s použitím zadaných informací o formátu.Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(String) WriteLine(String) WriteLine(String) WriteLine(String)

Zapíše zadanou řetězcovou hodnotu následovaný ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the specified string value, followed by the current line terminator, to the standard output stream.

WriteLine(Char[], Int32, Int32) WriteLine(Char[], Int32, Int32) WriteLine(Char[], Int32, Int32) WriteLine(Char[], Int32, Int32)

Zapíše zadané podpole znaků Unicode následovaný ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the specified subarray of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(String, Object[]) WriteLine(String, Object[]) WriteLine(String, Object[]) WriteLine(String, Object[])

Zapíše textovou reprezentaci zadaného pole objektů následovaný ukončovacím znakem aktuálního řádku do standardního výstupního datového proudu s použitím zadaných informací o formátu.Writes the text representation of the specified array of objects, followed by the current line terminator, to the standard output stream using the specified format information.

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

Zapíše textovou reprezentaci zadaného objektu následovaný ukončovacím znakem aktuálního řádku do standardního výstupního datového proudu s použitím zadaných informací o formátu.Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(UInt64) WriteLine(UInt64) WriteLine(UInt64) WriteLine(UInt64)

Zapíše textovou reprezentaci zadané hodnoty 64 unsigned integer následovanou ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the text representation of the specified 64-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

WriteLine(UInt32) WriteLine(UInt32) WriteLine(UInt32) WriteLine(UInt32)

Zapíše textovou reprezentaci zadané hodnoty 32 unsigned integer následovanou ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the text representation of the specified 32-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Single) WriteLine(Single) WriteLine(Single) WriteLine(Single)

Zapíše textovou reprezentaci zadané hodnoty s jednoduchou přesností a s koncovým koncem řádku do standardního výstupního proudu.Writes the text representation of the specified single-precision floating-point value, followed by the current line terminator, to the standard output stream.

WriteLine(Decimal) WriteLine(Decimal) WriteLine(Decimal) WriteLine(Decimal)

Zapíše textovou reprezentaci zadané Decimal hodnoty následovaný ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the text representation of the specified Decimal value, followed by the current line terminator, to the standard output stream.

WriteLine(Int64) WriteLine(Int64) WriteLine(Int64) WriteLine(Int64)

Zapíše textovou reprezentaci zadaného celého čísla se znaménkem (64), za kterým následuje ukončovací znak aktuálního řádku, do standardního výstupního proudu.Writes the text representation of the specified 64-bit signed integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Int32) WriteLine(Int32) WriteLine(Int32) WriteLine(Int32)

Zapíše textovou reprezentaci zadaného celého čísla se znaménkem (32), za kterým následuje ukončovací znak aktuálního řádku, do standardního výstupního proudu.Writes the text representation of the specified 32-bit signed integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Double) WriteLine(Double) WriteLine(Double) WriteLine(Double)

Zapíše textovou reprezentaci zadané hodnoty s dvojitou přesností s plovoucí desetinnou čárkou následovanou ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the text representation of the specified double-precision floating-point value, followed by the current line terminator, to the standard output stream.

WriteLine(Char[]) WriteLine(Char[]) WriteLine(Char[]) WriteLine(Char[])

Zapíše zadané pole znaků Unicode následovaný ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the specified array of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(Char) WriteLine(Char) WriteLine(Char) WriteLine(Char)

Zapíše zadaný znak Unicode následovaný ukončovacím kódem aktuálního řádku a hodnotou do standardního výstupního proudu.Writes the specified Unicode character, followed by the current line terminator, value to the standard output stream.

WriteLine(Boolean) WriteLine(Boolean) WriteLine(Boolean) WriteLine(Boolean)

Zapíše textovou reprezentaci zadané logické hodnoty následovaný ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

WriteLine() WriteLine() WriteLine() WriteLine()

Zapíše ukončovací znak aktuálního řádku do standardního výstupního proudu.Writes the current line terminator to the standard output stream.

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

Zapíše textovou reprezentaci zadaných objektů následovaný ukončovacím znakem aktuálního řádku do standardního výstupního datového proudu s použitím zadaných informací o formátu.Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(Object) WriteLine(Object) WriteLine(Object) WriteLine(Object)

Zapíše textovou reprezentaci zadaného objektu následovaný ukončovacím znakem aktuálního řádku do standardního výstupního proudu.Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream.

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

Zapíše text reprezentující zadané objekty a seznam parametrů s proměnlivou délkou následovaný ukončovacím znakem aktuálního řádku do standardního výstupního datového proudu s použitím zadaných informací o formátu.Writes the text representation of the specified objects and variable-length parameter list, followed by the current line terminator, to the standard output stream using the specified format information.

Události

CancelKeyPress CancelKeyPress CancelKeyPress CancelKeyPress

Vyvolá se v Control případě, že je stisknuta modifikační klávesa (CTRL) a C buď klíč konzoly (C), nebo klávesa break (CTRL + C nebo CTRL + BREAK).Occurs when the Control modifier key (Ctrl) and either the C console key (C) or the Break key are pressed simultaneously (Ctrl+C or Ctrl+Break).

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.This type is thread safe.