Console Console Console Console Class

Definición

Representa los flujos de entrada, salida y error estándar para las aplicaciones de consola.Represents the standard input, output, and error streams for console applications. Esta clase no puede heredarse.This class cannot be inherited.

public ref class Console abstract sealed
public static class Console
type Console = class
Public Class Console
Herencia
ConsoleConsoleConsoleConsole

Ejemplos

En el ejemplo siguiente se muestra cómo leer y escribir datos en los flujos de entrada y salida estándar.The following example demonstrates how to read data from, and write data to, the standard input and output streams. Tenga en cuenta que estos flujos se pueden redirigir SetIn mediante SetOut los métodos y.Note that these streams can be redirected by using the SetIn and SetOut methods.

using namespace System;

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

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

Comentarios

La consola de es una ventana del sistema operativo en la que los usuarios interactúan con el sistema operativo o con una aplicación de consola basada en texto mediante la entrada de texto mediante el teclado del equipo y la lectura de la salida de texto del terminal del equipo.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 ejemplo, en el sistema operativo Windows, la consola de se denomina ventana del símbolo del sistema y acepta comandos de MS-DOS.For example, in the Windows operating system, the console is called the Command Prompt window and accepts MS-DOS commands. La Console clase proporciona compatibilidad básica para las aplicaciones que leen caracteres de la consola y escriben caracteres en ella.The Console class provides basic support for applications that read characters from, and write characters to, the console.

Para obtener información sobre el desarrollo Console con la clase, vea las siguientes secciones:For information about developing with the Console class, see the following sections:

Flujos de e/s de consolaConsole I/O Streams

Cuando se inicia una aplicación de consola, el sistema operativo asocia automáticamente tres flujos de e/s a la consola: flujo de entrada estándar, flujo de salida estándar y flujo de salida de error estándar.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. La aplicación puede leer los datos proporcionados por el usuario desde el flujo de entrada estándar. escribir datos normales en el flujo de salida estándar; y escriba los datos de error en el flujo de salida de error estándar.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. Estas secuencias se presentan a la aplicación como los valores de las Console.Inpropiedades Console.Out, y Console.Error .These streams are presented to your application as the values of the Console.In, Console.Out, and Console.Error properties.

De forma predeterminada, el valor de In la propiedad es System.IO.TextReader un objeto que representa el teclado y los valores de las Out propiedades Error y son System.IO.TextWriter objetos que representan una ventana de consola.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. Sin embargo, puede establecer estas propiedades en secuencias que no representen la ventana o el teclado de la consola. por ejemplo, puede establecer estas propiedades en secuencias que representan archivos.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 redirigir la entrada estándar, la salida estándar o el flujo de error estándar, Console.SetInllame Console.SetOutal método Console.SetError , o, respectivamente.To redirect the standard input, standard output, or standard error stream, call the Console.SetIn, Console.SetOut, or Console.SetError method, respectively. Las operaciones de e/s que usan estas secuencias se sincronizan, lo que significa que varios subprocesos pueden leer o escribir en las secuencias.I/O operations that use these streams are synchronized, which means that multiple threads can read from, or write to, the streams. Esto significa que los métodos que normalmente son asíncronos, como TextReader.ReadLineAsync, se ejecutan de forma sincrónica si el objeto representa una secuencia de consola.This means that methods that are ordinarily asynchronous, such as TextReader.ReadLineAsync, execute synchronously if the object represents a console stream.

Nota

No utilice la clase Console para mostrar los resultados en aplicaciones desatendidas, como las aplicaciones de servidor.Do not use the Console class to display output in unattended applications, such as server applications. Las llamadas a métodos como Console.Write y Console.WriteLine no tienen ningún efecto en las aplicaciones GUI.Calls to methods such as Console.Write and Console.WriteLine have no effect in GUI applications.

Consolelos miembros de clase que funcionan normalmente cuando el flujo subyacente se dirige a una consola pueden producir una excepción si la secuencia se redirige, por ejemplo, a un archivo.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 la aplicación para System.IO.IOException que detecte excepciones si redirige un flujo estándar.Program your application to catch System.IO.IOException exceptions if you redirect a standard stream. También IsOutputRedirectedpuede usar las propiedades, IsInputRedirectedy IsErrorRedirected para determinar si se redirige un flujo estándar antes de realizar una operación que produce una System.IO.IOException excepción.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.

A veces resulta útil llamar explícitamente a los miembros de los objetos de secuencia representados por Error las Inpropiedades, Outy.It is sometimes useful to explicitly call the members of the stream objects represented by the In, Out, and Error properties. Por ejemplo, de forma predeterminada, Console.ReadLine el método lee la entrada del flujo de entrada estándar.For example, by default, the Console.ReadLine method reads input from the standard input stream. Del mismo modo Console.WriteLine , el método escribe datos en el flujo de salida estándar y los datos van seguidos de la cadena de finalización de línea predeterminada, que es un retorno de carro y avance de línea ("\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"). Sin embargo, Console la clase no proporciona un método correspondiente para escribir datos en el flujo de salida de error estándar o una propiedad para cambiar la cadena de finalización de línea para los datos escritos en la secuencia.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.

Puede resolver este problema estableciendo la TextWriter.NewLine propiedad de la Out propiedad o Error en otra cadena de finalización de línea.You can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. Por ejemplo, la siguiente C# instrucción establece la cadena de finalización de línea para el flujo de salida de error estándar en dos secuencias de retorno de carro y avance de línea: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";

Después, puede llamar explícitamente WriteLine al método del objeto de flujo de salida de error, como C# en la siguiente instrucción:You can then explicitly call the WriteLine method of the error output stream object, as in the following C# statement:

Console.Error.WriteLine();

Búfer de pantalla y ventana de la consolaScreen Buffer and Console Window

Dos características estrechamente relacionadas de la consola son el búfer de pantalla y la ventana de la consola.Two closely related features of the console are the screen buffer and the console window. En realidad, el texto se lee o se escribe en secuencias propiedad de la consola, pero parece que se leen o se escriben en un área propiedad de la consola, que se denomina búfer de pantalla.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. El búfer de pantalla es un atributo de la consola de y se organiza como una cuadrícula rectangular de filas y columnas donde cada intersección de la cuadrícula, o celda de carácter, puede contener un carácter.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 carácter tiene su propio color de primer plano y cada celda de carácter tiene su propio color de fondo.Each character has its own foreground color, and each character cell has its own background color.

El búfer de pantalla se ve a través de una región rectangular denominada ventana de la consola.The screen buffer is viewed through a rectangular region called the console window. La ventana de la consola es otro atributo de la consola; no es la propia consola, que es una ventana del sistema operativo.The console window is another attribute of the console; it is not the console itself, which is an operating system window. La ventana de la consola se organiza en filas y columnas, es menor o igual que el tamaño del búfer de pantalla y se puede desplace para ver distintas áreas del búfer de pantalla subyacente.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. Si el búfer de pantalla es mayor que la ventana de la consola, la consola muestra automáticamente las barras de desplazamiento, por lo que se puede cambiar la posición de la ventana de la consola en el área del búfer de pantalla.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.

Un cursor indica la posición del búfer de pantalla en la que el texto se lee o escribe actualmente.A cursor indicates the screen buffer position where text is currently read or written. El cursor se puede ocultar o hacer visible y se puede cambiar su alto.The cursor can be hidden or made visible, and its height can be changed. Si el cursor está visible, la posición de la ventana de la consola se mueve automáticamente para que el cursor esté siempre en la vista.If the cursor is visible, the console window position is moved automatically so the cursor is always in view.

El origen de las coordenadas de celda de caracteres en el búfer de pantalla es la esquina superior izquierda y las posiciones del cursor y la ventana de la consola se miden en relación con ese origen.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 de base cero para especificar las posiciones; es decir, especifique la fila superior como fila 0 y la columna situada más a la izquierda como columna 0.Use zero-based indexes to specify positions; that is, specify the topmost row as row 0, and the leftmost column as column 0. El valor máximo de los índices de fila y columna es Int16.MaxValue.The maximum value for the row and column indexes is Int16.MaxValue.

Compatibilidad con Unicode para la consolaUnicode Support for the Console

En general, la consola lee la entrada y escribe la salida mediante la página de códigos de la consola actual, que define de forma predeterminada la configuración regional del sistema.In general, the console reads input and writes output by using the current console code page, which the system locale defines by default. Una página de códigos solo puede controlar un subconjunto de caracteres Unicode disponibles, por lo que, si intenta mostrar caracteres que no están asignados por una página de códigos determinada, la consola no podrá mostrar todos los caracteres o representarlos con precisión.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. El siguiente ejemplo ilustra este problema.The following example illustrates this problem. Intenta mostrar los caracteres del alfabeto cirílico de U + 0410 a U + 044F en la consola.It tries to display the characters of the Cyrillic alphabet from U+0410 to U+044F to the console. Si ejecuta el ejemplo en un sistema que usa la página de códigos 437 de la consola, cada carácter se sustituye por un signo de interrogación (?), ya que los caracteres cirílicos no se asignan a los caracteres de la página de códigos 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
'       
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?

Además de admitir las páginas de códigos, Console la clase admite la codificación UTF-8 con UTF8Encoding la clase.In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. A partir de la .NET Framework 4,5, Console la clase también admite la codificación UTF-16 con UnicodeEncoding la clase.Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. Para mostrar los caracteres Unicode en la consola.To display Unicode characters to the console. la OutputEncoding propiedad se establece UTF8Encoding en o UnicodeEncoding.you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

La compatibilidad con caracteres Unicode requiere que el codificador reconozca un carácter Unicode determinado y también requiere una fuente con los glifos necesarios para representar ese carácter.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 mostrar correctamente los caracteres Unicode en la consola, la fuente de la consola debe establecerse en una fuente no rasterizada o TrueType, como consolas o lucida Console.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. En el ejemplo siguiente se muestra cómo se puede cambiar mediante programación la fuente de una fuente de trama a la consola 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

Sin embargo, las fuentes TrueType solo pueden mostrar un subconjunto de glifos.However, TrueType fonts can display only a subset of glyphs. Por ejemplo, la fuente de consola lucida muestra solo 643 de los 64.000 caracteres disponibles aproximadamente de U + 0021 a 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 qué caracteres admite una fuente determinada, abra el applet fuentes en el panel de control, elija la opción Buscar un carácter y elija la fuente cuyo juego de caracteres desea examinar en la lista fuente del mapa de caracteres . ventana.To see which characters a particular font supports, open the Fonts applet in Control Panel, choose the Find a character option, and choose the font whose character set you'd like to examine in the Font list of the Character Map window.

Windows usa la vinculación de fuentes para mostrar glifos que no están disponibles en una fuente determinada.Windows uses font linking to display glyphs that are not available in a particular font. Para obtener información sobre la vinculación de fuentes para mostrar juegos de caracteres adicionales, vea globalización paso a paso: Fuentes.For information about font linking to display additional character sets, see Globalization Step-by-Step: Fonts. Las fuentes vinculadas se definen en la subclave HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink del registro.Linked fonts are defined in the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink subkey of the registry. Cada entrada asociada a esta subclave corresponde al nombre de una fuente base y su valor es una matriz de cadena que define los archivos de fuentes y las fuentes que están vinculadas a la fuente 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 miembro de la matriz define una fuente vinculada y toma la forma Font-File-Name,Font-Name.Each member of the array defines a linked font and takes the form font-file-name,font-name. En el ejemplo siguiente se muestra cómo puede definir mediante programación una fuente vinculada denominada SimSun que se encuentra en un archivo de fuentes denominado simsun. TTC que muestra caracteres de ha simplificado.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

La compatibilidad con Unicode para la consola de tiene las siguientes limitaciones:Unicode support for the console has the following limitations:

  • No se admite la codificación UTF-32.UTF-32 encoding is not supported. Las únicas codificaciones Unicode admitidas son UTF-8 y UTF-16, que están representadas UTF8Encoding por UnicodeEncoding las clases y, respectivamente.The only supported Unicode encodings are UTF-8 and UTF-16, which are represented by the UTF8Encoding and UnicodeEncoding classes, respectively.

  • No se admite la salida bidireccional.Bidirectional output is not supported.

  • No se admite la presentación de caracteres fuera del plano básico multilingüe (es decir, de pares suplentes), incluso si se definen en un archivo de fuente 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.

  • No se admite la presentación de caracteres en scripts complejos.Display of characters in complex scripts is not supported.

  • La combinación de secuencias de caracteres (es decir, caracteres que se componen de un carácter base y uno o más caracteres de combinación) se muestran como caracteres independientes.Combining character sequences (that is, characters that consist of a base character and one or more combining characters) are displayed as separate characters. Para evitar esta limitación, puede normalizar la cadena que se va a mostrar llamando al String.Normalize método antes de enviar la salida a la consola.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. En el ejemplo siguiente, se muestra una cadena que contiene la secuencia de caracteres de combinación u + 0061 u + 0308 en la consola como dos caracteres antes de normalizar la cadena de salida, y como un solo String.Normalize carácter después de llamar al método.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"
    '       ä
    

    Tenga en cuenta que la normalización es una solución viable solo si el estándar Unicode del carácter incluye un formulario prediseñado que corresponde a una secuencia de caracteres que se combina en particular.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.

  • Si una fuente proporciona un glifo para un punto de código en el área de uso privado, se mostrará dicho glifo.If a font provides a glyph for a code point in the private use area, that glyph will be displayed. Sin embargo, dado que los caracteres del área de uso privado son específicos de la aplicación, es posible que este no sea el glifo esperado.However, because characters in the private use area are application-specific, this may not be the expected glyph.

En el ejemplo siguiente se muestra un intervalo de caracteres Unicode en la consola.The following example displays a range of Unicode characters to the console. En el ejemplo se aceptan tres parámetros de la línea de comandos: el inicio del intervalo que se va a mostrar, el final del intervalo que se va a mostrar y si sefalseva a usar la codificación de la consolatrueactual () o la codificación UTF-16 ().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). Se supone que la consola usa una fuente 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  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ

Operaciones comunesCommon Operations

La Console clase contiene los siguientes métodos para leer la entrada de la consola y escribir la salida de la consola:The Console class contains the following methods for reading console input and writing console output:

  • Las sobrecargas del ReadKey método leen un carácter individual.The overloads of the ReadKey method read an individual character.

  • El ReadLine método lee una línea de entrada completa.The ReadLine method reads an entire line of input.

  • Las Write sobrecargas del método convierten una instancia de un tipo de valor, una matriz de caracteres o un conjunto de objetos en una cadena con formato o sin formato y, a continuación, escriben esa cadena en la consola.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.

  • Un conjunto paralelo de WriteLine sobrecargas de método genera la misma cadena que Write las sobrecargas, pero también agrega una cadena de finalización de línea.A parallel set of WriteLine method overloads output the same string as the Write overloads but also add a line termination string.

La Console clase también contiene métodos y propiedades para realizar las operaciones siguientes:The Console class also contains methods and properties to perform the following operations:

  • Obtiene o establece el tamaño del búfer de pantalla.Get or set the size of the screen buffer. Las BufferHeight propiedades BufferWidth y permiten obtener o establecer el alto y el ancho del búfer, respectivamente, y SetBufferSize el método permite establecer el tamaño del búfer en una única llamada al 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.

  • Obtiene o establece el tamaño de la ventana de la consola.Get or set the size of the console window. Las WindowHeight propiedades WindowWidth y permiten obtener o establecer el alto y ancho de la ventana, respectivamente, y SetWindowSize el método permite establecer el tamaño de la ventana en una única llamada al 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.

  • Obtiene o establece el tamaño del cursor.Get or set the size of the cursor. La CursorSize propiedad especifica el alto del cursor en una celda de carácter.The CursorSize property specifies the height of the cursor in a character cell.

  • Obtiene o establece la posición de la ventana de la consola con respecto al búfer de pantalla.Get or set the position of the console window relative to the screen buffer. Las WindowTop propiedades WindowLeft y permiten obtener o establecer la fila superior y la columna situada más a la izquierda del búfer de pantalla que aparece en la ventana SetWindowPosition de la consola, y el método permite establecer estos valores en una única llamada al 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.

  • Obtiene o establece la posición del cursor al obtener o establecer CursorTop las propiedades y CursorLeft , o establecer la posición del cursor llamando al 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.

  • Mueva o borre los datos en el búfer de pantalla llamando MoveBufferArea al Clear método o.Move or clear data in the screen buffer by calling the MoveBufferArea or Clear method.

  • Obtenga o establezca los colores de primer plano y de fondo ForegroundColor mediante BackgroundColor las propiedades y, o bien restablezca el fondo y el primer plano a sus ResetColor colores predeterminados llamando al 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.

  • Reproducir el sonido de un bip a través del altavoz de la consola Beep llamando al método.Play the sound of a beep through the console speaker by calling the Beep method.

Núcleo de .NET.NET CoreApunteNotes

En el .NET Framework en el escritorio, la Console clase utiliza la codificación devuelta por GetConsoleCP y GetConsoleOutputCP, que normalmente es una codificación de página de códigos.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. En el ejemplo de código, en los sistemas cuya referencia cultural es inglés (Estados Unidos), la página de códigos 437 es la codificación que se utiliza de forma predeterminada.For example code, on systems whose culture is English (United States), code page 437 is the encoding that is used by default. Sin embargo Núcleo de .NET.NET Core , puede hacer que solo esté disponible un subconjunto limitado de estas codificaciones.However, Núcleo de .NET.NET Core may make only a limited subset of these encodings available. En este caso, Encoding.UTF8 se usa como codificación predeterminada de la consola.Where this is the case, Encoding.UTF8 is used as the default encoding for the console.

Si su aplicación depende de codificaciones de páginas de códigos específicas, puede hacer que estén disponibles haciendo lo siguiente antes de llamar a cualquier Console 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. Agregue una referencia al ensamblado System. Text. Encoding. webprojects. dll en el proyecto.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Recupere EncodingProvider el objeto de CodePagesEncodingProvider.Instance la propiedad.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Pase el EncodingProvider objeto Encoding.RegisterProvider al método para hacer que las codificaciones adicionales admitidas por el proveedor de codificación estén disponibles.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

La Console clase usará automáticamente la codificación predeterminada del sistema en lugar de UTF8, siempre que haya registrado el proveedor de codificación antes de llamar a cualquier Console método de salida.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.

Propiedades

BackgroundColor BackgroundColor BackgroundColor BackgroundColor

Obtiene o establece el color de fondo de la consola.Gets or sets the background color of the console.

BufferHeight BufferHeight BufferHeight BufferHeight

Obtiene o establece el alto del área del búfer.Gets or sets the height of the buffer area.

BufferWidth BufferWidth BufferWidth BufferWidth

Obtiene o establece el ancho del área del búfer.Gets or sets the width of the buffer area.

CapsLock CapsLock CapsLock CapsLock

Obtiene un valor que indica si se activa o desactiva la alternancia de teclado de BLOQ MAYÚS.Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft CursorLeft CursorLeft CursorLeft

Obtiene o establece la posición en columnas del cursor en el área del búfer.Gets or sets the column position of the cursor within the buffer area.

CursorSize CursorSize CursorSize CursorSize

Obtiene o establece el alto del cursor en una celda de carácter.Gets or sets the height of the cursor within a character cell.

CursorTop CursorTop CursorTop CursorTop

Obtiene o establece la posición en filas del cursor en el área del búfer.Gets or sets the row position of the cursor within the buffer area.

CursorVisible CursorVisible CursorVisible CursorVisible

Obtiene o establece un valor que indica si el cursor es visible.Gets or sets a value indicating whether the cursor is visible.

Error Error Error Error

Obtiene el flujo de salida de error estándar.Gets the standard error output stream.

ForegroundColor ForegroundColor ForegroundColor ForegroundColor

Obtiene o establece el color de primer plano de la consola.Gets or sets the foreground color of the console.

In In In In

Obtiene el flujo de entrada estándar.Gets the standard input stream.

InputEncoding InputEncoding InputEncoding InputEncoding

Obtiene o establece la codificación que usa la consola para leer la entrada.Gets or sets the encoding the console uses to read input.

IsErrorRedirected IsErrorRedirected IsErrorRedirected IsErrorRedirected

Obtiene un valor que indica si el flujo de salida de errores se ha redirigido desde el flujo de errores estándar.Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected IsInputRedirected IsInputRedirected IsInputRedirected

Obtiene un valor que indica si la entrada se ha redirigido desde el flujo de entrada estándar.Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected IsOutputRedirected IsOutputRedirected IsOutputRedirected

Obtiene un valor que indica si la salida se ha redirigido desde el flujo de salida estándar.Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable KeyAvailable KeyAvailable KeyAvailable

Obtiene un valor que indica si hay disponible una acción de presionar una tecla en el flujo de entrada.Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight LargestWindowHeight LargestWindowHeight LargestWindowHeight

Obtiene el máximo número posible de filas para la ventana de la consola, basado en la fuente y la resolución de pantalla actuales.Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth LargestWindowWidth LargestWindowWidth LargestWindowWidth

Obtiene el máximo número posible de columnas para la ventana de la consola, basado en la fuente y la resolución de pantalla actuales.Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock NumberLock NumberLock NumberLock

Obtiene un valor que indica si está activada o desactivada la alternancia de teclado de BLOQ NUM.Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out Out Out Out

Obtiene el flujo de salida estándar.Gets the standard output stream.

OutputEncoding OutputEncoding OutputEncoding OutputEncoding

Obtiene o establece la codificación que usa la consola para escribir la salida.Gets or sets the encoding the console uses to write output.

Title Title Title Title

Obtiene o establece el título que se va a mostrar en la barra de título de la consola.Gets or sets the title to display in the console title bar.

TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput

Obtiene o establece un valor que indica si la combinación de la tecla modificadora Control y de la tecla de consola C (Ctrl+C) se trata como una entrada ordinaria o como una interrupción controlada por el sistema operativo.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

Obtiene o establece el alto del área de la ventana de la consola.Gets or sets the height of the console window area.

WindowLeft WindowLeft WindowLeft WindowLeft

Obtiene o establece la posición más a la izquierda del área de la ventana de la consola con respecto al búfer de pantalla.Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop WindowTop WindowTop WindowTop

Obtiene o establece la posición superior del área de la ventana de la consola con respecto al búfer de pantalla.Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth WindowWidth WindowWidth WindowWidth

Obtiene o establece el ancho de la ventana de la consola.Gets or sets the width of the console window.

Métodos

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

Reproduce el sonido de un bip a través del altavoz de la consola.Plays the sound of a beep through the console speaker.

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

Reproduce el sonido de un bip con una frecuencia y duración especificadas a través del altavoz de la consola.Plays the sound of a beep of a specified frequency and duration through the console speaker.

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

Borra la información que se muestra en el búfer de pantalla y en la correspondiente ventana de la consola.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 un área de origen especificada del búfer de pantalla en un área de destino determinada.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 un área de origen especificada del búfer de pantalla en un área de destino determinada.Copies a specified source area of the screen buffer to a specified destination area.

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

Adquiere el flujo de error estándar.Acquires the standard error stream.

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

Adquiere el flujo de error estándar, que se establece en un tamaño de búfer especificado.Acquires the standard error stream, which is set to a specified buffer size.

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

Adquiere el flujo de entrada estándar.Acquires the standard input stream.

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

Adquiere el flujo de entrada estándar, que se establece en un tamaño de búfer especificado.Acquires the standard input stream, which is set to a specified buffer size.

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

Adquiere el flujo de salida estándar.Acquires the standard output stream.

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

Adquiere el flujo de salida estándar, que se establece en un tamaño de búfer especificado.Acquires the standard output stream, which is set to a specified buffer size.

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

Lee el siguiente carácter del flujo de entrada estándar.Reads the next character from the standard input stream.

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

Obtiene la siguiente tecla de carácter o de función presionada por el usuario.Obtains the next character or function key pressed by the user. La tecla presionada se muestra en la ventana de la consola.The pressed key is displayed in the console window.

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

Obtiene la siguiente tecla de carácter o de función presionada por el usuario.Obtains the next character or function key pressed by the user. Opcionalmente, la tecla presionada se muestra en la ventana de la consola.The pressed key is optionally displayed in the console window.

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

Lee la siguiente línea de caracteres del flujo de entrada estándar.Reads the next line of characters from the standard input stream.

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

Establece los colores de primer plano y de fondo de la consola en sus valores predeterminados.Sets the foreground and background console colors to their defaults.

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

Establece el alto y el ancho del área del búfer de pantalla en los 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)

Establece la posición del cursor.Sets the position of the cursor.

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

Establece la propiedad Error en el objeto TextWriter especificado.Sets the Error property to the specified TextWriter object.

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

Establece la propiedad In en el objeto TextReader especificado.Sets the In property to the specified TextReader object.

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

Establece la propiedad Out para establecer el destino del objeto TextWriter.Sets the Out property to target the TextWriter object.

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

Establece la posición de la ventana de la consola con respecto al búfer de pantalla.Sets the position of the console window relative to the screen buffer.

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

Establece el alto y el ancho de la ventana de la consola en los 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)

Escribe la representación de texto de los objetos especificados y la lista de parámetros de longitud variable en el flujo de salida estándar usando la información de formato especificada.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)

Escribe la representación de texto de los objetos especificados en el flujo de salida estándar usando la información de formato indicada.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)

Escribe la representación de texto de los objetos especificados en el flujo de salida estándar usando la información de formato indicada.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[])

Escribe la representación de texto de la matriz de objetos especificada en el flujo de salida estándar usando la información de formato especificada.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)

Escribe la representación de texto del objeto especificado en el flujo de salida estándar usando la información de formato indicada.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)

Escribe la representación de texto del valor entero de 64 bits sin signo especificado en el flujo de salida estándar.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)

Escribe la representación de texto del valor entero de 32 bits sin signo especificado en el flujo de salida estándar.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)

Escribe el valor de cadena especificado en el flujo de salida estándar.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)

Escribe la submatriz de caracteres Unicode especificada en el flujo de salida estándar.Writes the specified subarray of Unicode characters to the standard output stream.

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

Escribe la representación de texto del objeto especificado en el flujo de salida estándar.Writes the text representation of the specified object to the standard output stream.

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

Escribe la representación de texto del valor de punto flotante de precisión sencilla especificado en el flujo de salida estándar.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)

Escribe el valor del carácter Unicode especificado en el flujo de salida estándar.Writes the specified Unicode character value to the standard output stream.

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

Escribe la matriz especificada de caracteres Unicode en el flujo de salida estándar.Writes the specified array of Unicode characters to the standard output stream.

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

Escribe la representación de texto del valor booleano especificado en el flujo de salida estándar.Writes the text representation of the specified Boolean value to the standard output stream.

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

Escribe la representación de texto del valor de punto flotante de precisión doble especificado en el flujo de salida estándar.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)

Escribe la representación de texto del valor entero de 32 bits con signo especificado en el flujo de salida estándar.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)

Escribe la representación de texto del valor entero de 64 bits con signo especificado en el flujo de salida estándar.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)

Escribe la representación de texto del valor Decimal especificado en el flujo de salida estándar.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)

Escribe la representación de texto de los objetos especificados, seguida del terminador de línea actual, en el flujo de salida estándar usando la información de formato especificada.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)

Escribe el valor de cadena especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la submatriz de caracteres Unicode especificada, seguida del terminador de línea actual, en el flujo de salida estándar.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[])

Escribe la representación de texto de la matriz de objetos especificada, seguida del terminador de línea actual, en el flujo de salida estándar usando la información de formato especificada.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)

Escribe la representación de texto del objeto especificado, seguida del terminador de línea actual, en el flujo de salida estándar usando la información de formato especificada.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)

Escribe la representación de texto del valor entero de 64 bits sin signo especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la representación de texto del valor entero de 32 bits sin signo especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la representación de texto del valor de punto flotante de precisión sencilla especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la representación de texto del valor Decimal especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la representación de texto del valor entero de 64 bits con signo especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la representación de texto del valor entero de 32 bits con signo especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la representación de texto del valor de punto flotante de precisión doble especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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[])

Escribe la matriz de caracteres Unicode especificada, seguida del terminador de línea actual, en el flujo de salida estándar.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)

Escribe el carácter Unicode especificado, seguido del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la representación de texto del valor booleano especificado, seguida del terminador de línea actual, en el flujo de salida estándar.Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

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

Escribe el terminador de línea actual en el flujo de salida estándar.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)

Escribe la representación de texto de los objetos especificados, seguida del terminador de línea actual, en el flujo de salida estándar usando la información de formato especificada.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)

Escribe la representación de texto del objeto especificado, seguida del terminador de línea actual, en el flujo de salida estándar.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)

Escribe la representación de texto de los objetos especificados y la lista de parámetros de longitud variable, seguidas del terminador de línea actual, en el flujo de salida estándar usando la información de formato especificada.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

Se produce cuando la tecla modificadora Control (Ctrl) y la tecla de consola C (C) o la tecla Interrumpir se presionan simultáneamente (Ctrl+C o Ctrl+Inter).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).

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.This type is thread safe.