Console Console Console Console Class

Definição

Representa os fluxos de entrada, saída e erro padrão para aplicativos de console.Represents the standard input, output, and error streams for console applications. Essa classe não pode ser herdada.This class cannot be inherited.

public ref class Console abstract sealed
public static class Console
type Console = class
Public Class Console
Herança
ConsoleConsoleConsoleConsole

Exemplos

O exemplo a seguir demonstra como ler dados de e gravar dados em, os fluxos de entrada e saída padrão.The following example demonstrates how to read data from, and write data to, the standard input and output streams. Observe que esses fluxos podem ser redirecionados usando os SetIn métodos e. 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!

Comentários

O console é uma janela do sistema operacional onde os usuários interagem com o sistema operacional ou com um aplicativo de console baseado em texto digitando entrada de texto por meio do teclado do computador e lendo a saída de texto do terminal do computador.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. Por exemplo, no sistema operacional Windows, o console do é chamado de janela de prompt de comando e aceita comandos do MS-DOS.For example, in the Windows operating system, the console is called the Command Prompt window and accepts MS-DOS commands. A Console classe fornece suporte básico para aplicativos que lêem caracteres de e gravam caracteres no console do.The Console class provides basic support for applications that read characters from, and write characters to, the console.

Para obter informações sobre como desenvolver Console com a classe, consulte as seguintes seções:For information about developing with the Console class, see the following sections:

Fluxos de E/S de consoleConsole I/O Streams

Quando um aplicativo de console é iniciado, o sistema operacional automaticamente associa três fluxos de e/s ao console: fluxo de entrada padrão, fluxo de saída padrão e fluxo de saída de erro padrão.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. Seu aplicativo pode ler a entrada do usuário do fluxo de entrada padrão; gravar dados normais no fluxo de saída padrão; e grave dados de erro no fluxo de saída de erro padrão.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. Esses fluxos são apresentados ao seu aplicativo como os valores das Console.InPropriedades, Console.Oute. Console.ErrorThese streams are presented to your application as the values of the Console.In, Console.Out, and Console.Error properties.

Por padrão, o In valor da propriedade é um System.IO.TextReader objeto que representa o teclado Out e os valores das propriedades e Error são System.IO.TextWriter objetos que representam uma janela de console.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. No entanto, você pode definir essas propriedades para fluxos que não representam a janela do console ou o teclado; por exemplo, você pode definir essas propriedades para fluxos que representam arquivos.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. Para redirecionar a entrada padrão, a saída padrão ou o fluxo de erro Console.SetInpadrão Console.SetOut, chame Console.SetError o método, ou, respectivamente.To redirect the standard input, standard output, or standard error stream, call the Console.SetIn, Console.SetOut, or Console.SetError method, respectively. As operações de e/s que usam esses fluxos são sincronizadas, o que significa que vários threads podem ler ou gravar os fluxos.I/O operations that use these streams are synchronized, which means that multiple threads can read from, or write to, the streams. Isso significa que os métodos que são normalmente assíncronos, TextReader.ReadLineAsynccomo, são executados de forma síncrona se o objeto representa um fluxo de console.This means that methods that are ordinarily asynchronous, such as TextReader.ReadLineAsync, execute synchronously if the object represents a console stream.

Observação

Não use a classe Console para exibir a saída em aplicativos autônomos, como aplicativos de servidor.Do not use the Console class to display output in unattended applications, such as server applications. Chamadas para métodos como Console.Write e Console.WriteLine não têm efeito em aplicativos de GUI.Calls to methods such as Console.Write and Console.WriteLine have no effect in GUI applications.

ConsoleMembros de classe que funcionam normalmente quando o fluxo subjacente é direcionado para um console do podem gerar uma exceção se o fluxo for redirecionado, por exemplo, para um arquivo.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. Programe seu aplicativo para System.IO.IOException capturar exceções se você redirecionar um fluxo padrão.Program your application to catch System.IO.IOException exceptions if you redirect a standard stream. Você também pode usar as IsOutputRedirectedpropriedades IsInputRedirected, e IsErrorRedirected para determinar se um fluxo padrão é redirecionado antes de executar uma operação que gera uma System.IO.IOException exceção.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.

Às vezes, é útil chamar explicitamente os membros dos objetos de fluxo representados pelas Inpropriedades Out, e Error .It is sometimes useful to explicitly call the members of the stream objects represented by the In, Out, and Error properties. Por exemplo, por padrão, o Console.ReadLine método lê a entrada do fluxo de entrada padrão.For example, by default, the Console.ReadLine method reads input from the standard input stream. Da mesma forma Console.WriteLine , o método grava dados no fluxo de saída padrão e os dados são seguidos pela cadeia de caracteres de terminação de linha padrão, que é um retorno de carro e alimentação de linha ("\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"). No entanto Console , a classe não fornece um método correspondente para gravar dados no fluxo de saída de erro padrão ou uma propriedade para alterar a cadeia de terminação de linha para dados gravados nesse fluxo.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.

Você pode resolver esse problema definindo a TextWriter.NewLine propriedade Out da propriedade ou Error para outra cadeia de terminação de linha.You can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. Por exemplo, a instrução C# a seguir define a cadeia de terminação de linha para o fluxo de saída de erro padrão para duas sequências de retorno de carro e alimentação de linha: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";

Você pode chamar explicitamente o WriteLine método do objeto de fluxo de saída de erro, como na seguinte C# instrução:You can then explicitly call the WriteLine method of the error output stream object, as in the following C# statement:

Console.Error.WriteLine();

Buffer de tela e janela do consoleScreen Buffer and Console Window

Dois recursos bem relacionados do console são o buffer de tela e a janela do console.Two closely related features of the console are the screen buffer and the console window. O texto é realmente lido ou gravado em fluxos de Propriedade do console do, mas parece ser lido ou gravado em uma área de Propriedade do console chamado buffer de tela.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. O buffer de tela é um atributo do console do e é organizado como uma grade retangular de linhas e colunas em que cada interseção de grade, ou célula de caractere, pode conter um caractere.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. Cada caractere tem sua própria cor de primeiro plano e cada célula de caractere tem sua própria cor de plano de fundo.Each character has its own foreground color, and each character cell has its own background color.

O buffer de tela é exibido por meio de uma região retangular chamada de janela do console.The screen buffer is viewed through a rectangular region called the console window. A janela do console é outro atributo do console do; Ele não é o próprio console, que é uma janela do sistema operacional.The console window is another attribute of the console; it is not the console itself, which is an operating system window. A janela do console é organizada em linhas e colunas, é menor ou igual ao tamanho do buffer da tela e pode ser movida para exibir áreas diferentes do buffer de tela subjacente.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. Se o buffer da tela for maior do que a janela do console, o console do exibirá automaticamente as barras de rolagem para que a janela do console possa ser reposicionada na área de buffer da tela.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.

Um cursor indica a posição do buffer de tela em que o texto está lido ou gravado no momento.A cursor indicates the screen buffer position where text is currently read or written. O cursor pode ser ocultado ou ficar visível e sua altura pode ser alterada.The cursor can be hidden or made visible, and its height can be changed. Se o cursor estiver visível, a posição da janela do console será movida automaticamente, de modo que o cursor esteja sempre na exibição.If the cursor is visible, the console window position is moved automatically so the cursor is always in view.

A origem das coordenadas de célula de caracteres no buffer de tela é o canto superior esquerdo, e as posições do cursor e da janela do console são medidas relativas a essa origem.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. Usar índices com base em zero para especificar posições; ou seja, especifique a linha superior como a linha 0 e a coluna mais à esquerda como coluna 0.Use zero-based indexes to specify positions; that is, specify the topmost row as row 0, and the leftmost column as column 0. O valor máximo para os índices de linha e coluna Int16.MaxValueé.The maximum value for the row and column indexes is Int16.MaxValue.

Suporte Unicode para o consoleUnicode Support for the Console

Em geral, o console lê a entrada e grava a saída usando a página de código do console atual, que a localidade do sistema define por padrão.In general, the console reads input and writes output by using the current console code page, which the system locale defines by default. Uma página de código pode manipular apenas um subconjunto de caracteres Unicode disponíveis, portanto, se você tentar exibir caracteres que não são mapeados por uma página de código específica, o console não poderá exibir todos os caracteres ou representá-los com precisão.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. O exemplo a seguir ilustra esse problema.The following example illustrates this problem. Ele tenta exibir os caracteres do alfabeto cirílico de U + 0410 para U + 044F para o console.It tries to display the characters of the Cyrillic alphabet from U+0410 to U+044F to the console. Se você executar o exemplo em um sistema que usa a página de código do console 437, cada caractere será substituído por um ponto de interrogação (?), porque os caracteres cirílicos não são mapeados para os caracteres na página de código 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
'       
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?

Além das páginas de código de suporte, Console a classe dá suporte à codificação UTF- UTF8Encoding 8 com a classe.In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. A partir do .NET Framework 4,5, a Console classe também dá suporte à codificação UTF-16 UnicodeEncoding com a classe.Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. Para exibir caracteres Unicode para o console.To display Unicode characters to the console. Você define a OutputEncoding propriedade UTF8Encoding como ou UnicodeEncoding.you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

O suporte para caracteres Unicode requer que o codificador reconheça um caractere Unicode específico e também requer uma fonte que tenha os glifos necessários para renderizar esse caractere.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. Para exibir com êxito os caracteres Unicode para o console, a fonte do console deve ser definida como uma fonte não rasterizada ou TrueType, como o console consolas ou lucida.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. O exemplo a seguir mostra como você pode alterar programaticamente a fonte de uma fonte de varredura para o console da 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

No entanto, as fontes TrueType podem exibir apenas um subconjunto de glifos.However, TrueType fonts can display only a subset of glyphs. Por exemplo, a fonte do console lucida exibe apenas 643 dos aproximadamente 64.000 caracteres disponíveis de U + 0021 para U + FB02.For example, the Lucida Console font displays only 643 of the approximately 64,000 available characters from U+0021 to U+FB02. Para ver quais caracteres uma fonte específica dá suporte, abra o miniaplicativo fontes no painel de controle, escolha a opção localizar um caractere e escolha a fonte cujo conjunto de caracteres você deseja examinar na lista fonte do mapa de caracteres Window.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.

O Windows usa a vinculação de fontes para exibir glifos que não estão disponíveis em uma fonte específica.Windows uses font linking to display glyphs that are not available in a particular font. Para obter informações sobre a vinculação de fontes para exibir conjuntos de caracteres adicionais, consulte a globalização passo a passo: Fontes.For information about font linking to display additional character sets, see Globalization Step-by-Step: Fonts. As fontes vinculadas são definidas na subchave HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink do registro.Linked fonts are defined in the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink subkey of the registry. Cada entrada associada a essa subchave corresponde ao nome de uma fonte base e seu valor é uma matriz de cadeia de caracteres que define os arquivos de fonte e as fontes que estão vinculadas à fonte base.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. Cada membro da matriz define uma fonte vinculada e usa o formato Font-File-Name,font-name.Each member of the array defines a linked font and takes the form font-file-name,font-name. O exemplo a seguir ilustra como você pode definir de forma programática uma fonte vinculada chamada SimSun encontrada em um arquivo de fonte chamado SimSun. TTC que exibe caracteres Han simplificados.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

O suporte a Unicode para o console tem as seguintes limitações:Unicode support for the console has the following limitations:

  • Não há suporte para a codificação UTF-32.UTF-32 encoding is not supported. As únicas codificações Unicode com suporte são UTF-8 e UTF-16, que são representadas UTF8Encoding pelas UnicodeEncoding classes e, respectivamente.The only supported Unicode encodings are UTF-8 and UTF-16, which are represented by the UTF8Encoding and UnicodeEncoding classes, respectively.

  • Não há suporte para a saída bidirecional.Bidirectional output is not supported.

  • Não há suporte para a exibição de caracteres fora do plano multilíngüe básico (isto é, de pares substitutos), mesmo que eles estejam definidos em um arquivo de fonte vinculado.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.

  • Não há suporte para a exibição de caracteres em scripts complexos.Display of characters in complex scripts is not supported.

  • A combinação de sequências de caracteres (ou seja, caracteres que consistem em um caractere base e um ou mais caracteres de combinação) são exibidos como caracteres separados.Combining character sequences (that is, characters that consist of a base character and one or more combining characters) are displayed as separate characters. Para contornar essa limitação, você pode normalizar a cadeia de caracteres a ser exibida String.Normalize chamando o método antes de enviar a saída para o console.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. No exemplo a seguir, uma cadeia de caracteres que contém a sequência de caracteres de combinação u + 0061 u + 0308 é exibida para o console como dois caracteres antes que a cadeia de caracteres de saída seja normalizada String.Normalize e como um único caractere depois que o método é chamado.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"
    '       ä
    

    Observe que a normalização é uma solução viável somente se o padrão Unicode para o caractere incluir um formulário previamente composto que corresponde a uma sequência de caracteres de combinação específica.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.

  • Se uma fonte fornecer um glifo para um ponto de código na área de uso particular, esse glifo será exibido.If a font provides a glyph for a code point in the private use area, that glyph will be displayed. No entanto, como os caracteres na área de uso particular são específicos do aplicativo, esse pode não ser o glifo esperado.However, because characters in the private use area are application-specific, this may not be the expected glyph.

O exemplo a seguir exibe um intervalo de caracteres Unicode para o console.The following example displays a range of Unicode characters to the console. O exemplo aceita três parâmetros de linha de comando: o início do intervalo a ser exibido, o final do intervalo a ser exibido e se deseja usar a codificação do console atualfalse() ou a codificação 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). Ele assume que o console está usando uma fonte 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.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  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ

Operações comunsCommon Operations

A Console classe contém os seguintes métodos para ler a entrada do console e gravar a saída do console:The Console class contains the following methods for reading console input and writing console output:

  • As sobrecargas do ReadKey método lêem um caractere individual.The overloads of the ReadKey method read an individual character.

  • O ReadLine método lê uma linha inteira de entrada.The ReadLine method reads an entire line of input.

  • O Write método sobrecarrega a conversão de uma instância de um tipo de valor, uma matriz de caracteres ou um conjunto de objetos em uma cadeia de caracteres formatada ou não formatada e, em seguida, grava essa cadeia de caracteres no console.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.

  • Um conjunto paralelo de WriteLine sobrecargas de método gera a mesma cadeia de Write caracteres como as sobrecargas, mas também adiciona uma cadeia de caracteres de terminação de linha.A parallel set of WriteLine method overloads output the same string as the Write overloads but also add a line termination string.

A Console classe também contém métodos e propriedades para executar as seguintes operações:The Console class also contains methods and properties to perform the following operations:

  • Obter ou definir o tamanho do buffer da tela.Get or set the size of the screen buffer. As BufferHeight propriedades BufferWidth e permitem que você obtenha ou defina a altura e a largura do buffer, respectivamente SetBufferSize , e o método permite que você defina o tamanho do buffer em uma única chamada de método.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.

  • Obter ou definir o tamanho da janela do console.Get or set the size of the console window. As WindowHeight propriedades WindowWidth e permitem que você obtenha ou defina a altura e a largura da janela, respectivamente SetWindowSize , e o método permite que você defina o tamanho da janela em uma única chamada de método.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.

  • Obter ou definir o tamanho do cursor.Get or set the size of the cursor. A CursorSize propriedade especifica a altura do cursor em uma célula de caractere.The CursorSize property specifies the height of the cursor in a character cell.

  • Obtenha ou defina a posição da janela do console em relação ao buffer da tela.Get or set the position of the console window relative to the screen buffer. As WindowTop propriedades WindowLeft e permitem que você obtenha ou defina a linha superior e a coluna mais à esquerda do buffer de tela que aparece na janela do SetWindowPosition console e o método permite que você defina esses valores em uma única chamada de método.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.

  • Obtenha ou defina a posição do cursor obtendo ou definindo as CursorTop Propriedades e CursorLeft , ou defina a posição do cursor chamando o SetCursorPosition método.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.

  • Mova ou limpe os dados no buffer da tela chamando o MoveBufferArea método Clear ou.Move or clear data in the screen buffer by calling the MoveBufferArea or Clear method.

  • Obtenha ou defina as cores de primeiro plano e plano de ForegroundColor fundo BackgroundColor usando as propriedades e, ou redefina o plano de fundo e o primeiro ResetColor plano para suas cores padrão chamando o método.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.

  • Jogue o som de um aviso sonoro pelo alto-falante do console Beep chamando o método.Play the sound of a beep through the console speaker by calling the Beep method.

.NET Core.NET CoreRegistraNotes

Na .NET Framework na área de trabalho, a Console classe usa a codificação retornada por GetConsoleCP e GetConsoleOutputCP, que normalmente é uma codificação de página de código.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. Para o código de exemplo, em sistemas cuja cultura é inglês (Estados Unidos), a página de código 437 é a codificação usada por padrão.For example code, on systems whose culture is English (United States), code page 437 is the encoding that is used by default. No entanto, .NET Core.NET Core o pode tornar apenas um subconjunto limitado dessas codificações disponíveis.However, .NET Core.NET Core may make only a limited subset of these encodings available. Em que esse é o caso Encoding.UTF8 , é usado como a codificação padrão para o console.Where this is the case, Encoding.UTF8 is used as the default encoding for the console.

Se seu aplicativo depender de codificações de página de código específicas, você ainda poderá disponibilizá-los fazendo o seguinte antes de Console chamar qualquer método: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. Adicione uma referência ao assembly System. Text. Encoding. CodePageings. dll ao seu projeto.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Recupere o EncodingProvider objeto CodePagesEncodingProvider.Instance da propriedade.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Passe o EncodingProvider objeto para o Encoding.RegisterProvider método para tornar as codificações adicionais com suporte do provedor de codificação disponíveis.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

A Console classe usará automaticamente a codificação do sistema padrão em vez de UTF8, desde que você tenha registrado o provedor de codificação antes Console de chamar qualquer método de saída.The Console class will then automatically use the default system encoding rather than UTF8, provided that you have registered the encoding provider before calling any Console output methods.

Propriedades

BackgroundColor BackgroundColor BackgroundColor BackgroundColor

Obtém ou define a cor da tela de fundo do console.Gets or sets the background color of the console.

BufferHeight BufferHeight BufferHeight BufferHeight

Obtém ou define a altura da área de buffer.Gets or sets the height of the buffer area.

BufferWidth BufferWidth BufferWidth BufferWidth

Obtém ou define a largura da área de buffer.Gets or sets the width of the buffer area.

CapsLock CapsLock CapsLock CapsLock

Obtém um valor que indica se a alternância de teclado CAPS LOCK está ativada ou desativada.Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft CursorLeft CursorLeft CursorLeft

Obtém ou define a posição da coluna do cursor na área de buffer.Gets or sets the column position of the cursor within the buffer area.

CursorSize CursorSize CursorSize CursorSize

Obtém ou define a altura do cursor em uma célula do caractere.Gets or sets the height of the cursor within a character cell.

CursorTop CursorTop CursorTop CursorTop

Obtém ou define a posição da linha do cursor dentro da área de buffer.Gets or sets the row position of the cursor within the buffer area.

CursorVisible CursorVisible CursorVisible CursorVisible

Obtém ou define um valor que indica se o cursor está visível.Gets or sets a value indicating whether the cursor is visible.

Error Error Error Error

Obtém o fluxo de saída de erro padrão.Gets the standard error output stream.

ForegroundColor ForegroundColor ForegroundColor ForegroundColor

Obtém ou define a cor de primeiro plano do console.Gets or sets the foreground color of the console.

In In In In

Obtém o fluxo de entrada padrão.Gets the standard input stream.

InputEncoding InputEncoding InputEncoding InputEncoding

Obtém ou define a codificação usada pelo console para ler a entrada.Gets or sets the encoding the console uses to read input.

IsErrorRedirected IsErrorRedirected IsErrorRedirected IsErrorRedirected

Obtém um valor que indica se o fluxo de saída de erro foi redirecionado do fluxo de erro padrão.Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected IsInputRedirected IsInputRedirected IsInputRedirected

Obtém um valor que indica se a entrada foi redirecionada do fluxo de entrada padrão.Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected IsOutputRedirected IsOutputRedirected IsOutputRedirected

Obtém um valor que indica se a saída foi redirecionada do fluxo de saída padrão.Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable KeyAvailable KeyAvailable KeyAvailable

Obtém um valor que indica se um pressionamento de tecla está disponível no fluxo de entrada.Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight LargestWindowHeight LargestWindowHeight LargestWindowHeight

Obtém o maior número possível de linhas de janela do console, com base na fonte atual e resolução da tela.Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth LargestWindowWidth LargestWindowWidth LargestWindowWidth

Obtém o maior número possível de colunas de janela do console, com base na fonte atual e resolução da tela.Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock NumberLock NumberLock NumberLock

Obtém um valor que indica se a alternância de teclado NUM LOCK está ativada ou desativada.Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out Out Out Out

Obtém o fluxo de saída padrão.Gets the standard output stream.

OutputEncoding OutputEncoding OutputEncoding OutputEncoding

Obtém ou define a codificação usada pelo console para gravar a saída.Gets or sets the encoding the console uses to write output.

Title Title Title Title

Obtém ou define o título a ser exibido na barra de título do console.Gets or sets the title to display in the console title bar.

TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput

Obtém ou define um valor que indica se a combinação da tecla modificadora Control e da chave do console C (Ctrl + C) é tratada como uma entrada comum ou como uma interrupção tratada pelo sistema operacional.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

Obtém ou define a altura da área da janela do console.Gets or sets the height of the console window area.

WindowLeft WindowLeft WindowLeft WindowLeft

Obtém ou define a posição mais à esquerda da área da janela do console em relação ao buffer da tela.Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop WindowTop WindowTop WindowTop

Obtém ou define a posição superior da área da janela do console em relação ao buffer da tela.Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth WindowWidth WindowWidth WindowWidth

Obtém ou define a largura da janela do console.Gets or sets the width of the console window.

Métodos

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

Reproduz o som de um aviso sonoro por meio do alto-falante do console.Plays the sound of a beep through the console speaker.

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

Reproduz o som de um aviso sonoro de frequência e duração especificadas por meio do alto-falante do console.Plays the sound of a beep of a specified frequency and duration through the console speaker.

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

Limpa o buffer do console e a janela do console correspondente de informações de exibição.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)

Copia uma área de fonte especificada do buffer da tela para uma área de destino especificada.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)

Copia uma área de fonte especificada do buffer da tela para uma área de destino especificada.Copies a specified source area of the screen buffer to a specified destination area.

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

Adquire o fluxo de erro padrão.Acquires the standard error stream.

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

Adquire o fluxo de erro padrão, definido como um tamanho do buffer especificado.Acquires the standard error stream, which is set to a specified buffer size.

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

Adquire o fluxo de entrada padrão.Acquires the standard input stream.

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

Adquire o fluxo de entrada padrão, que é definido para um tamanho do buffer especificado.Acquires the standard input stream, which is set to a specified buffer size.

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

Adquire o fluxo de saída padrão.Acquires the standard output stream.

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

Adquire o fluxo de saída padrão, definido como um tamanho do buffer especificado.Acquires the standard output stream, which is set to a specified buffer size.

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

Lê o próximo caractere do fluxo de entrada padrão.Reads the next character from the standard input stream.

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

Obtém o próximo caractere ou tecla de função pressionada pelo usuário.Obtains the next character or function key pressed by the user. A tecla pressionada é exibida na janela do console.The pressed key is displayed in the console window.

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

Obtém o próximo caractere ou tecla de função pressionada pelo usuário.Obtains the next character or function key pressed by the user. A tecla pressionada é exibida opcionalmente na janela do console.The pressed key is optionally displayed in the console window.

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

Lê a próxima linha de caracteres do fluxo de entrada padrão.Reads the next line of characters from the standard input stream.

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

Define as cores do console de primeiro e segundo planos com os padrões.Sets the foreground and background console colors to their defaults.

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

Define a altura e largura da área de buffer da tela com os valores especificados.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)

Define a posição do cursor.Sets the position of the cursor.

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

Define a propriedade Error para o objeto TextWriter especificado.Sets the Error property to the specified TextWriter object.

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

Define a propriedade In para o objeto TextReader especificado.Sets the In property to the specified TextReader object.

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

Define a propriedade Out para direcionar o objeto TextWriter.Sets the Out property to target the TextWriter object.

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

Define a posição da janela do console em relação ao buffer da tela.Sets the position of the console window relative to the screen buffer.

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

Define a altura e largura da janela do console com os valores especificados.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)

Grava a representação de texto dos objetos especificados e a lista de parâmetros de tamanho variável no fluxo de saída padrão usando as informações de formato especificadas.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)

Grava a representação de texto dos objetos especificados no fluxo de saída padrão usando as informações de formato especificadas.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)

Grava a representação de texto dos objetos especificados no fluxo de saída padrão usando as informações de formato especificadas.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[])

Grava a representação de texto da matriz de objetos especificada, no fluxo de saída padrão usando as informações de formato especificadas.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)

Grava a representação de texto do objeto especificado no fluxo de saída padrão usando as informações de formato especificadas.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)

Grava a representação de texto do valor inteiro sem sinal de 64 bits no fluxo de saída padrão.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)

Grava a representação de texto do valor inteiro sem sinal de 32 bits especificado no fluxo de saída padrão.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)

Grava o valor da cadeia de caracteres especificada no fluxo de saída padrão.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)

Grava a submatriz especificada de caracteres Unicode no fluxo de saída padrão.Writes the specified subarray of Unicode characters to the standard output stream.

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

Grava a representação de texto do objeto especificado no fluxo de saída padrão.Writes the text representation of the specified object to the standard output stream.

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

Grava a representação de texto do valor de ponto flutuante de precisão simples especificado no fluxo de saída padrão.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)

Grava o valor do caractere Unicode especificado no fluxo de saída padrão.Writes the specified Unicode character value to the standard output stream.

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

Grava a matriz de caracteres Unicode especificada no fluxo de saída padrão.Writes the specified array of Unicode characters to the standard output stream.

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

Grava a representação de texto do valor booliano especificado, no fluxo de saída padrão.Writes the text representation of the specified Boolean value to the standard output stream.

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

Grava a representação de texto do valor de ponto flutuante de precisão dupla especificado no fluxo de saída padrão.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)

Grava a representação de texto do valor inteiro com sinal de 32 bits no fluxo de saída padrão.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)

Grava a representação de texto do valor inteiro com sinal de 64 bits no fluxo de saída padrão.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)

Grava a representação de texto do valor Decimal especificado, no fluxo de saída padrão.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)

Grava a representação de texto dos objetos especificados, seguido de um terminador de linha atual, no fluxo de saída padrão usando as informações de formato especificadas.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)

Grava o valor de cadeia de caracteres especificado, seguido pelo terminador de linha atual para o fluxo de saída padrão.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)

Grava a submatriz especificada de caracteres Unicode, seguida por um terminador de linha atual, no fluxo de saída padrão.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[])

Grava a representação de texto da matriz de objetos especificada, seguido por um terminador de linha atual, no fluxo de saída padrão usando as informações de formato especificadas.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)

Grava a representação de texto do objeto especificado, seguido de um terminador de linha atual, no fluxo de saída padrão usando as informações de formato especificadas.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)

Grava a representação de texto do valor inteiro sem sinal de 64 bits especificado, seguido do terminador de linha atual, no fluxo de saída padrão.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)

Grava a representação de texto do valor inteiro sem sinal de 32 bits especificado, seguido do terminador de linha atual, no fluxo de saída padrão.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)

Grava a representação de texto do valor de ponto flutuante de precisão simples, seguido do terminador de linha atual, no fluxo de saída padrão.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)

Grava a representação de texto do valor Decimal especificado, seguido do terminador de linha atual, no fluxo de saída padrão.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)

Grava a representação de texto do valor inteiro com sinal de 64 bits, seguido do terminador de linha atual, no fluxo de saída padrão.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)

Grava a representação de texto do valor inteiro com sinal de 32 bits, seguido do terminador de linha atual, no fluxo de saída padrão.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)

Grava a representação de texto do valor de ponto flutuante de precisão dupla, seguido do terminador de linha atual, no fluxo de saída padrão.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[])

Grava a matriz especificada de caracteres Unicode, seguida por um terminador de linha atual, no fluxo de saída padrão.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)

Grava o caractere Unicode especificado, seguido por um terminador de linha atual, valor para o fluxo de saída padrão.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)

Grava a representação de texto do valor booliano especificado, seguido do terminador de linha atual, no fluxo de saída padrão.Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

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

Grava o terminador de linha atual no fluxo de saída padrão.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)

Grava a representação de texto dos objetos especificados, seguido de um terminador de linha atual, no fluxo de saída padrão usando as informações de formato especificadas.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)

Grava a representação de texto do objeto especificado, seguido do terminador de linha atual, no fluxo de saída padrão.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)

Grava a representação de texto dos objetos especificados e a lista de parâmetros de tamanho variável, seguido do terminador de linha atual, no fluxo de saída padrão usando as informações de formato especificadas.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.

Eventos

CancelKeyPress CancelKeyPress CancelKeyPress CancelKeyPress

Ocorre quando a tecla modificadora Control (Ctrl) e a tecla do console C (C) ou a tecla Break são pressionadas simultaneamente (Ctrl + C ou 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).

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.