Console Clase

Definición

Representa los flujos de entrada, salida y error estándar para las aplicaciones de consola. Esta clase no puede heredarse.

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

Ejemplos

En el ejemplo siguiente se muestra cómo leer y escribir datos en los flujos de entrada y salida estándar. Tenga en cuenta que estas secuencias se pueden redirigir mediante los SetIn métodos y SetOut .

using namespace System;

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

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

open System

[<EntryPoint>]
let main argv =
    Console.Write("Hello ")
    Console.WriteLine("World!")
    Console.Write("Enter your name: ")
    let name = Console.ReadLine()
    Console.Write("Good day, ")
    Console.Write(name)
    Console.WriteLine("!")
    0
    
// The example displays output similar to the following:
//       Hello World!
//       Enter your name: James
//       Good day, James!

Comentarios

La consola 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 escribiendo la entrada de texto a través del teclado del equipo y leyendo la salida de texto desde el terminal del equipo. Por ejemplo, en el sistema operativo Windows, la consola se denomina ventana del símbolo del sistema y acepta comandos MS-DOS. La Console clase proporciona compatibilidad básica con las aplicaciones que leen caracteres de y escriben caracteres en la consola.

Para obtener información sobre el desarrollo con la Console clase , vea las secciones siguientes:

Secuencias de E/S de consola

Cuando se inicia una aplicación de consola, el sistema operativo asocia automáticamente tres secuencias de E/S con la consola: flujo de entrada estándar, flujo de salida estándar y flujo de salida de error estándar. La aplicación puede leer la entrada del usuario desde el flujo de entrada estándar; escribir datos normales en el flujo de salida estándar; y escriben datos de error en el flujo de salida de error estándar. Estas secuencias se presentan a la aplicación como los valores de las Console.Inpropiedades , Console.Outy Console.Error .

De forma predeterminada, el valor de la In propiedad es un System.IO.TextReader objeto que representa el teclado y los valores de las Out propiedades y Error son System.IO.TextWriter objetos que representan una ventana de consola. Sin embargo, puede establecer estas propiedades en secuencias que no representan la ventana o el teclado de la consola; por ejemplo, puede establecer estas propiedades en secuencias que representan archivos. Para redirigir la entrada estándar, la salida estándar o el flujo de error estándar, llame al Console.SetInmétodo , Console.SetOuto Console.SetError , respectivamente. Las operaciones de E/S que usan estas secuencias se sincronizan, lo que significa que varios subprocesos pueden leer o escribir en las secuencias. Esto significa que los métodos que normalmente son asincrónicos, como TextReader.ReadLineAsync, se ejecutan de forma sincrónica si el objeto representa una secuencia de consola.

Nota

No use la clase para mostrar la Console salida en aplicaciones desatendidas, como las aplicaciones de servidor. Las llamadas a métodos como Console.Write y Console.WriteLine no tienen ningún efecto en las aplicaciones de GUI.

Console Los miembros de clase que funcionan normalmente cuando la secuencia subyacente se dirige a una consola podría producir una excepción si la secuencia se redirige, por ejemplo, a un archivo. Programe la aplicación para detectar System.IO.IOException excepciones si redirige una secuencia estándar. También puede usar las IsOutputRedirectedpropiedades , IsInputRedirectedy IsErrorRedirected para determinar si se redirige una secuencia estándar antes de realizar una operación que produce una System.IO.IOException excepción.

A veces resulta útil llamar explícitamente a los miembros de los objetos de secuencia representados por las Inpropiedades , Outy Error . Por ejemplo, de forma predeterminada, el método lee la Console.ReadLine entrada del flujo de entrada estándar. Del mismo modo, el Console.WriteLine método escribe datos en el flujo de salida estándar y los datos van seguidos de la cadena de terminación de línea predeterminada, que se puede encontrar en Environment.NewLine. Sin embargo, la Console 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 terminación de línea para los datos escritos en esa secuencia.

Puede resolver este problema estableciendo la TextWriter.NewLine propiedad de la Out propiedad o Error en otra cadena de terminación de línea. Por ejemplo, la siguiente instrucción de C# establece la cadena de terminació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:

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

A continuación, puede llamar explícitamente al WriteLine método del objeto de flujo de salida de error, como en la siguiente instrucción de C#:

Console.Error.WriteLine();

Ventana Búfer de pantalla y consola

Dos características estrechamente relacionadas de la consola son el búfer de pantalla y la ventana de la consola. El texto se lee o escribe realmente en secuencias propiedad de la consola, pero parece leerse o escribirse en un área propiedad de la consola denominada búfer de pantalla. El búfer de pantalla es un atributo de la consola y se organiza como una cuadrícula rectangular de filas y columnas donde cada intersección de cuadrícula, o celda de caracteres, puede contener un carácter. Cada carácter tiene su propio color de primer plano y cada celda de caracteres tiene su propio color de fondo.

El búfer de pantalla se ve a través de una región rectangular denominada ventana de consola. La ventana de la consola es otro atributo de la consola; no es la propia consola, que es una ventana del sistema operativo. 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 mover para ver diferentes áreas del búfer de pantalla subyacente. Si el búfer de pantalla es mayor que la ventana de la consola, la consola muestra automáticamente las barras de desplazamiento para que la ventana de consola se pueda cambiar de posición sobre el área del búfer de pantalla.

Un cursor indica la posición del búfer de pantalla donde el texto se lee o escribe actualmente. El cursor se puede ocultar o hacer visible, y su alto se puede cambiar. Si el cursor está visible, la posición de la ventana de la consola se mueve automáticamente para que el cursor siempre esté en vista.

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. Utilice índices de base cero para especificar posiciones; es decir, especifique la fila más alta como fila 0 y la columna situada más a la izquierda como columna 0. El valor máximo de los índices de fila y columna es Int16.MaxValue.

Compatibilidad con Unicode para la consola

En general, la consola lee la entrada y escribe la salida mediante la página de códigos de la consola actual, que la configuración regional del sistema define de forma predeterminada. 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 ni representarlos con precisión. El siguiente ejemplo ilustra este problema. Intenta mostrar los caracteres del alfabeto cirílico de U+0410 a U+044F en la consola. Si ejecuta el ejemplo en un sistema que usa la página de códigos de consola 437, cada carácter se reemplaza por un signo de interrogación (?), porque los caracteres cirílicos no se asignan a los caracteres de la página de códigos 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] = (char)codePoint;
        codePoint++;
      }

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

// Create a char List for the modern Cyrillic alphabet,
// from U+0410 to U+044F.
let chars =
    [ for codePoint in 0x0410 .. 0x044F do
        Convert.ToChar codePoint ]

printfn "Current code page: %i\n" Console.OutputEncoding.CodePage
// Display the characters.
for ch in chars do
    printf "%c  " ch
    if Console.CursorLeft >= 70 then Console.WriteLine()

// The example displays the following output:
//    Current code page: 437
//
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?

Además de admitir páginas de códigos, la Console clase admite la codificación UTF-8 con la UTF8Encoding clase . A partir de .NET Framework 4.5, la Console clase también admite la codificación UTF-16 con la UnicodeEncoding clase . Para mostrar caracteres Unicode en la consola. se establece la OutputEncoding propiedad en UTF8Encoding o UnicodeEncoding.

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

open System
open System.Runtime.InteropServices

[<Literal>]
let STD_OUTPUT_HANDLE = -11

[<Literal>]
let TMPF_TRUETYPE = 4

[<Literal>]
let LF_FACESIZE = 32

let INVALID_HANDLE_VALUE = IntPtr(-1)


[<Struct>]
[<StructLayout(LayoutKind.Sequential)>]
type COORD =
    val mutable X: int16
    val mutable Y: int16

    internal new(x: int16, y: int16) =
        { X = x
          Y = y }

[<Struct>]
[<StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)>]
type CONSOLE_FONT_INFO_EX =
    val mutable cbSize: uint32
    val mutable nFont: uint32
    val mutable dwFontSize: COORD
    val mutable FontFamily: int
    val mutable FontWeight: int
    [<MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)>]
    val mutable FaceName: string

[<DllImport("kernel32.dll", SetLastError = true)>]
extern IntPtr GetStdHandle(int nStdHandle)

[<DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)>]
extern bool GetCurrentConsoleFontEx(IntPtr consoleOutput, bool maximumWindow, CONSOLE_FONT_INFO_EX lpConsoleCurrentFontEx)

[<DllImport("kernel32.dll", SetLastError = true)>]
extern bool SetCurrentConsoleFontEx(IntPtr consoleOutput, bool maximumWindow, CONSOLE_FONT_INFO_EX consoleCurrentFontEx)

[<EntryPoint>]
let main argv =
    let fontName = "Lucida Console"
    let hnd = GetStdHandle(STD_OUTPUT_HANDLE)
    if hnd <> INVALID_HANDLE_VALUE then
        let mutable info = CONSOLE_FONT_INFO_EX()
        info.cbSize <- uint32 (Marshal.SizeOf(info))
        // First determine whether there's already a TrueType font.
        if (GetCurrentConsoleFontEx(hnd, false, info)) then
            if (((info.FontFamily) &&& TMPF_TRUETYPE) = TMPF_TRUETYPE) then
                Console.WriteLine("The console already is using a TrueType font.")
            else
                // Set console font to Lucida Console.
                let mutable newInfo = CONSOLE_FONT_INFO_EX()
                newInfo.cbSize <- uint32 (Marshal.SizeOf(newInfo))
                newInfo.FontFamily <- TMPF_TRUETYPE
                newInfo.FaceName <- fontName
                // Get some settings from current font.
                newInfo.dwFontSize <- COORD(info.dwFontSize.X, info.dwFontSize.Y)
                newInfo.FontWeight <- info.FontWeight
                SetCurrentConsoleFontEx(hnd, false, newInfo) |> ignore
                Console.WriteLine("The console is now using a TrueType font.")

    // Return zero for success
    0

Sin embargo, las fuentes TrueType solo pueden mostrar un subconjunto de glifos. Por ejemplo, la fuente Lucida Console muestra solo 643 de los aproximadamente 64 000 caracteres disponibles de U+0021 a U+FB02. Para ver qué caracteres admite una fuente determinada, abra el applet Fuentes en 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 de la ventana Mapa de caracteres.

Windows usa la vinculación de fuentes para mostrar glifos que no están disponibles en una fuente determinada. Para obtener información sobre la vinculación de fuentes para mostrar juegos de caracteres adicionales, vea Globalización Paso a paso: Fuentes. Las fuentes vinculadas se definen en la subclave HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink del Registro. Cada entrada asociada a esta subclave corresponde al nombre de una fuente base y su valor es una matriz de cadenas que define los archivos de fuente y las fuentes que están vinculadas a la fuente base. Cada miembro de la matriz define una fuente vinculada y toma el formato font-file-name,font-name. En el ejemplo siguiente se muestra cómo se puede definir mediante programación una fuente vinculada denominada SimSun que se encuentra en un archivo de fuente denominado simsun.ttc que muestra caracteres Han simplificados.

using Microsoft.Win32;
using System;

public class Example
{
   public static void Main()
   {
      string valueName = "Lucida Console";
      string newFont = "simsun.ttc,SimSun";
      string[] fonts = null;
      RegistryValueKind kind = 0;
      bool toAdd;

      RegistryKey key = Registry.LocalMachine.OpenSubKey(
                 @"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink",
                 true);
      if (key == null) {
         Console.WriteLine("Font linking is not enabled.");
      }
      else {
         // Determine if the font is a base font.
         string[] names = key.GetValueNames();
         if (Array.Exists(names, s => s.Equals(valueName,
                                      StringComparison.OrdinalIgnoreCase))) {
            // Get the value's type.
            kind = key.GetValueKind(valueName);

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

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

            key.SetValue(valueName, fonts, RegistryValueKind.MultiString);
            Console.WriteLine("SimSun added to the list of linked fonts.");
         }
      }

      if (key != null) key.Close();
   }
}
Imports Microsoft.Win32

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

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

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

let valueName = "Lucida Console"
let newFont = "simsun.ttc,SimSun"

let key =
    Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink", true)
if isNull key then
    printfn "Font linking is not enabled."
else
    // Determine if the font is a base font.
    let names = key.GetValueNames()

    let (fonts, kind, toAdd) =
        if names |> Array.exists (fun s -> s.Equals(valueName, StringComparison.OrdinalIgnoreCase)) then
            // Get the value's type.
            let kind = key.GetValueKind(valueName)

            // Type should be RegistryValueKind.MultiString, but we can't be sure.
            let fonts =
                match kind with
                | RegistryValueKind.String -> [| key.GetValue(valueName) :?> string |]
                | RegistryValueKind.MultiString -> (key.GetValue(valueName) :?> string array)
                | _ -> [||]

            // Determine whether SimSun is a linked font.
            let toAdd =
                not (fonts |> Array.exists (fun s -> s.IndexOf("SimSun", StringComparison.OrdinalIgnoreCase) >= 0))

            (fonts, kind, toAdd)
        else
            // Font is not a base font.
            ([||], RegistryValueKind.Unknown, true)

    if toAdd then
        // Font is not a linked font.
        let newFonts = Array.append fonts [| newFont |]

        // Change REG_SZ to REG_MULTI_SZ.
        if kind = RegistryValueKind.String then key.DeleteValue(valueName, false)

        key.SetValue(valueName, newFonts, RegistryValueKind.MultiString)
        printfn "SimSun added to the list of linked fonts."
    else
        printfn "Font is already linked."


if not (isNull key) then key.Close()

La compatibilidad con Unicode para la consola tiene las siguientes limitaciones:

  • No se admite la codificación UTF-32. Las únicas codificaciones Unicode admitidas son UTF-8 y UTF-16, representadas por las UTF8Encoding clases y UnicodeEncoding , respectivamente.

  • No se admite la salida bidireccional.

  • No se admite la presentación de caracteres fuera del plano multilingüe básico (es decir, de pares suplentes), incluso si se definen en un archivo de fuente vinculado.

  • No se admite la visualización de caracteres en scripts complejos.

  • La combinación de secuencias de caracteres (es decir, caracteres que constan de un carácter base y uno o varios caracteres combinados) se muestran como caracteres independientes. Para evitar esta limitación, puede normalizar la cadena que se va a mostrar llamando al método antes de enviar la String.Normalize salida a la consola. En el ejemplo siguiente, se muestra una cadena que contiene la secuencia de caracteres combinada U+0061 U+0308 como dos caracteres antes de normalizar la cadena de salida y como un solo carácter después de llamar al String.Normalize método.

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

    Tenga en cuenta que la normalización es una solución viable solo si el estándar Unicode para el carácter incluye un formulario compuesto previamente que corresponde a una secuencia de caracteres combinada determinada.

  • Si una fuente proporciona un glifo para un punto de código en el área de uso privado, se mostrará ese glifo. Sin embargo, dado que los caracteres del área de uso privado son específicos de la aplicación, es posible que no sea el glifo esperado.

En el ejemplo siguiente se muestra un intervalo de caracteres Unicode en la consola. En el ejemplo se aceptan tres parámetros de línea de comandos: el inicio del intervalo que se va a mostrar, el final del intervalo que se va a mostrar y si se debe usar la codificación de consola actual (false) o la codificación UTF-16 (true). Se supone que la consola usa una fuente TrueType.

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

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

    try
    {
         switch(args.Length)
         {
            case 2:
               rangeStart = uint.Parse(args[0], NumberStyles.HexNumber);
               rangeEnd = uint.Parse(args[1], NumberStyles.HexNumber);
               setOutputEncodingToUnicode = true;
               break;
            case 3:
               if (! uint.TryParse(args[0], NumberStyles.HexNumber, null, out rangeStart))
                  throw new ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args[0]));

               if (!uint.TryParse(args[1], NumberStyles.HexNumber, null, out rangeEnd))
                  throw new ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args[1]));

               bool.TryParse(args[2], out setOutputEncodingToUnicode);
               break;
            default:
               Console.WriteLine("Usage: {0} <{1}> <{2}> [{3}]",
                                 Environment.GetCommandLineArgs()[0],
                                 "startingCodePointInHex",
                                 "endingCodePointInHex",
                                 "<setOutputEncodingToUnicode?{true|false, default:false}>");
               return;
         }

         if (setOutputEncodingToUnicode) {
            // This won't work before .NET Framework 4.5.
            try {
               // Set encoding using endianness of this system.
               // We're interested in displaying individual Char objects, so
               // we don't want a Unicode BOM or exceptions to be thrown on
               // invalid Char values.
               Console.OutputEncoding = new UnicodeEncoding(! BitConverter.IsLittleEndian, false);
               Console.WriteLine("\nOutput encoding set to UTF-16");
            }
            catch (IOException) {
               Console.OutputEncoding = new UTF8Encoding();
               Console.WriteLine("Output encoding set to UTF-8");
            }
         }
         else {
            Console.WriteLine("The console encoding is {0} (code page {1})",
                              Console.OutputEncoding.EncodingName,
                              Console.OutputEncoding.CodePage);
         }
         DisplayRange(rangeStart, rangeEnd);
      }
      catch (ArgumentException ex) {
         Console.WriteLine(ex.Message);
      }
      finally {
         // Restore console environment.
         Console.OutputEncoding = originalOutputEncoding;
      }
   }

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

      if (end <= start) {
         uint t = start;
         start = end;
         end = t;
      }

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

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

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

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

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

            switch (c) {
               case 3: case 11:
                  Console.Write("-");
                  break;
               case 7:
                  Console.Write("--");
                  break;
            }
         }

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

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

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

Public Module DisplayChars
   Public Sub Main(args() As String)
      Dim rangeStart As UInteger = 0
      Dim rangeEnd As UInteger = 0
      Dim setOutputEncodingToUnicode As Boolean = True
      ' Get the current encoding so we can restore it.
      Dim originalOutputEncoding As Encoding = Console.OutputEncoding

    Try
         Select Case args.Length
            Case 2
               rangeStart = UInt32.Parse(args(0), NumberStyles.HexNumber)
               rangeEnd = UInt32.Parse(args(1), NumberStyles.HexNumber)
               setOutputEncodingToUnicode = True
            Case 3
               If Not UInt32.TryParse(args(0), NumberStyles.HexNumber, Nothing, rangeStart) Then
                  Throw New ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args(0)))
               End If
               
               If Not UInt32.TryParse(args(1), NumberStyles.HexNumber, Nothing, rangeEnd) Then
                  Throw New ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args(1)))
               End If
               
               Boolean.TryParse(args(2), setOutputEncodingToUnicode)
            Case Else
               Console.WriteLine("Usage: {0} <{1}> <{2}> [{3}]", 
                                 Environment.GetCommandLineArgs()(0), 
                                 "startingCodePointInHex", 
                                 "endingCodePointInHex", 
                                 "<setOutputEncodingToUnicode?{true|false, default:false}>")
               Exit Sub
         End Select
   
         If setOutputEncodingToUnicode Then
            ' This won't work before .NET Framework 4.5.
            Try 
               ' Set encoding Imports endianness of this system.
               ' We're interested in displaying individual Char objects, so 
               ' we don't want a Unicode BOM or exceptions to be thrown on
               ' invalid Char values.
               Console.OutputEncoding = New UnicodeEncoding(Not BitConverter.IsLittleEndian, False) 
               Console.WriteLine("{0}Output encoding set to UTF-16", vbCrLf)
            Catch e As IOException
               Console.OutputEncoding = New UTF8Encoding()
               Console.WriteLine("Output encoding set to UTF-8")
            End Try
         Else
            Console.WriteLine("The console encoding is {0} (code page {1})", 
                              Console.OutputEncoding.EncodingName,
                              Console.OutputEncoding.CodePage)
         End If
         DisplayRange(rangeStart, rangeEnd)
      Catch ex As ArgumentException
         Console.WriteLine(ex.Message)
      Finally
         ' Restore console environment.
         Console.OutputEncoding = originalOutputEncoding
      End Try
   End Sub

   Public Sub DisplayRange(rangeStart As UInteger, rangeEnd As UInteger)
      Const upperRange As UInteger = &h10FFFF
      Const surrogateStart As UInteger = &hD800
      Const surrogateEnd As UInteger = &hDFFF
       
      If rangeEnd <= rangeStart Then
         Dim t As UInteger = rangeStart
         rangeStart = rangeEnd
         rangeEnd = t
      End If

      ' Check whether the start or end range is outside of last plane.
      If rangeStart > upperRange Then
         Throw New ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{1:X5})",
                                                   rangeStart, upperRange))                                   
      End If
      If rangeEnd > upperRange Then
         Throw New ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{0:X5})",
                                                   rangeEnd, upperRange))
      End If
      ' Since we're using 21-bit code points, we can't use U+D800 to U+DFFF.
      If (rangeStart < surrogateStart And rangeEnd > surrogateStart) OrElse (rangeStart >= surrogateStart And rangeStart <= surrogateEnd )
         Throw New ArgumentException(String.Format("0x{0:X5}-0x{1:X5} includes the surrogate pair range 0x{2:X5}-0x{3:X5}", 
                                                   rangeStart, rangeEnd, surrogateStart, surrogateEnd))         
      End If
      
      Dim last As UInteger = RoundUpToMultipleOf(&h10, rangeEnd)
      Dim first As UInteger = RoundDownToMultipleOf(&h10, rangeStart)

      Dim rows As UInteger = (last - first) \ &h10

      For r As UInteger = 0 To rows - 1
         ' Display the row header.
         Console.Write("{0:x5} ", first + &h10 * r)

         For c As UInteger = 1 To &h10
            Dim cur As UInteger = first + &h10 * r + c
            If cur  < rangeStart Then
               Console.Write(" {0} ", Convert.ToChar(&h20))
            Else If rangeEnd < cur Then
               Console.Write(" {0} ", Convert.ToChar(&h20))
            Else 
               ' the cast to int is safe, since we know that val <= upperRange.
               Dim chars As String = Char.ConvertFromUtf32(CInt(cur))
               ' Display a space for code points that are not valid characters.
               If CharUnicodeInfo.GetUnicodeCategory(chars(0)) = 
                                   UnicodeCategory.OtherNotAssigned Then
                  Console.Write(" {0} ", Convert.ToChar(&h20))
               ' Display a space for code points in the private use area.
               Else If CharUnicodeInfo.GetUnicodeCategory(chars(0)) =
                                        UnicodeCategory.PrivateUse Then
                 Console.Write(" {0} ", Convert.ToChar(&h20))
               ' Is surrogate pair a valid character?
               ' Note that the console will interpret the high and low surrogate
               ' as separate (and unrecognizable) characters.
               Else If chars.Length > 1 AndAlso CharUnicodeInfo.GetUnicodeCategory(chars, 0) = 
                                            UnicodeCategory.OtherNotAssigned Then
                  Console.Write(" {0} ", Convert.ToChar(&h20))
               Else
                  Console.Write(" {0} ", chars) 
               End If   
            End If
            
            Select Case c
               Case 3, 11
                  Console.Write("-")
               Case 7
                  Console.Write("--")
            End Select
         Next

         Console.WriteLine()
         If 0 < r AndAlso r Mod &h10 = 0
            Console.WriteLine()
         End If
      Next
   End Sub

   Private Function RoundUpToMultipleOf(b As UInteger, u As UInteger) As UInteger
      Return RoundDownToMultipleOf(b, u) + b
   End Function

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

open System
open System.IO
open System.Globalization
open System.Text

type uint = uint32

let inline roundDownToMultipleOf b u = u - (u % b)

let inline roundUpToMultipleOf b u = roundDownToMultipleOf b u |> (+) b

let displayRange (start: uint) (``end``: uint) =

    let upperRange = 0x10FFFFu
    let surrogateStart = 0xD800u
    let surrogateEnd = 0xDFFFu

    let start, ``end`` =
        if ``end`` <= start then ``end``, start
        else start, ``end``

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

    // Since we're using 21-bit code points, we can't use U+D800 to U+DFFF.
    if (start < surrogateStart && ``end`` > surrogateStart) || (start >= surrogateStart && start <= surrogateEnd) then
        raise
            (ArgumentException
                (String.Format
                    ("0x{0:X5}-0x{1:X5} includes the surrogate pair range 0x{2:X5}-0x{3:X5}", start, ``end``,
                     surrogateStart, surrogateEnd)))
    let last = roundUpToMultipleOf 0x10u ``end``
    let first = roundDownToMultipleOf 0x10u start

    let rows = (last - first) / 0x10u

    for r in 0u .. (rows - 1u) do
        // Display the row header.
        printf "%05x " (first + 0x10u * r)

        for c in 0u .. (0x10u - 1u) do
            let cur = (first + 0x10u * r + c)
            if cur < start || ``end`` < cur then
                printf " %c " (Convert.ToChar 0x20)
            else
                // the cast to int is safe, since we know that val <= upperRange.
                let chars = Char.ConvertFromUtf32(int cur)
                // Display a space for code points that are not valid characters.
                if CharUnicodeInfo.GetUnicodeCategory(chars[0]) = UnicodeCategory.OtherNotAssigned then
                    printf " %c " (Convert.ToChar 0x20)
                else
                    // Display a space for code points in the private use area.
                    if CharUnicodeInfo.GetUnicodeCategory(chars[0]) = UnicodeCategory.PrivateUse then
                        printf " %c " (Convert.ToChar 0x20)
                    else if chars.Length > 1
                            && CharUnicodeInfo.GetUnicodeCategory(chars, 0) = UnicodeCategory.OtherNotAssigned then
                        printf " %c " (Convert.ToChar 0x20)
                    else printf " %s " chars

            match c with
            | 3u
            | 11u -> printf "-"
            | 7u -> printf "--"
            | _ -> ()

        Console.WriteLine()
        if (0u < r && r % 0x10u = 0u) then Console.WriteLine()



[<EntryPoint>]
let main args =
    // Get the current encoding so we can restore it.
    let originalOutputEncoding = Console.OutputEncoding

    try
        try
            let parsedArgs =
                match args.Length with
                | 2 ->
                    Some
                        {| setOutputEncodingToUnicode = true
                           rangeStart = uint.Parse(args[0], NumberStyles.HexNumber)
                           rangeEnd = uint.Parse(args[1], NumberStyles.HexNumber) |}
                | 3 ->
                    let parseHexNumberOrThrow (value: string) parameterName =
                        (uint.TryParse(value, NumberStyles.HexNumber, null))
                        |> function
                        | (false, _) ->
                            invalidArg parameterName (String.Format("{0} is not a valid hexadecimal number.", value))
                        | (true, value) -> value

                    let setOutputEncodingToUnicode =
                        match bool.TryParse args[2] with
                        | true, value -> value
                        | false, _ -> true

                    Some
                        {| setOutputEncodingToUnicode = setOutputEncodingToUnicode
                           rangeStart = parseHexNumberOrThrow args[0] "rangeStart"
                           rangeEnd = parseHexNumberOrThrow args[1] "rangeEnd" |}
                | _ ->
                    printfn "Usage: %s <%s> <%s> [%s]" (Environment.GetCommandLineArgs()[0]) "startingCodePointInHex"
                        "endingCodePointInHex" "<setOutputEncodingToUnicode?{true|false, default:false}>"
                    None

            match parsedArgs with
            | None -> ()
            | Some parsedArgs ->
                if parsedArgs.setOutputEncodingToUnicode then
                    // This won't work before .NET Framework 4.5.
                    try
                        // Set encoding using endianness of this system.
                        // We're interested in displaying individual Char objects, so
                        // we don't want a Unicode BOM or exceptions to be thrown on
                        // invalid Char values.
                        Console.OutputEncoding <- UnicodeEncoding(not BitConverter.IsLittleEndian, false)
                        printfn "\nOutput encoding set to UTF-16"

                    with :? IOException ->
                        printfn "Output encoding set to UTF-8"
                        Console.OutputEncoding <- UTF8Encoding()
                else
                    printfn "The console encoding is %s (code page %i)" (Console.OutputEncoding.EncodingName)
                        (Console.OutputEncoding.CodePage)

                displayRange parsedArgs.rangeStart parsedArgs.rangeEnd
        with :? ArgumentException as ex -> Console.WriteLine(ex.Message)
    finally
        // Restore console environment.
        Console.OutputEncoding <- originalOutputEncoding
    0

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

Operaciones comunes

La Console clase contiene los métodos siguientes para leer la entrada de la consola y escribir la salida de la consola:

  • Las sobrecargas del ReadKey método leen un carácter individual.

  • El ReadLine método lee una línea completa de entrada.

  • 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.

  • Un conjunto paralelo de sobrecargas de WriteLine método genera la misma cadena que las Write sobrecargas, pero también agrega una cadena de terminación de línea.

La Console clase también contiene métodos y propiedades para realizar las siguientes operaciones:

  • Obtiene o establece el tamaño del búfer de pantalla. Las BufferHeight propiedades y BufferWidth permiten obtener o establecer el alto y el ancho del búfer, respectivamente, y el SetBufferSize método permite establecer el tamaño del búfer en una sola llamada al método.

  • Obtiene o establece el tamaño de la ventana de la consola. Las WindowHeight propiedades y WindowWidth permiten obtener o establecer el alto y el ancho de la ventana, respectivamente, y el SetWindowSize método permite establecer el tamaño de la ventana en una sola llamada de método.

  • Obtiene o establece el tamaño del cursor. La CursorSize propiedad especifica el alto del cursor en una celda de caracteres.

  • Obtiene o establece la posición de la ventana de consola en relación con el búfer de pantalla. Las WindowTop propiedades y WindowLeft 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 de la consola, y el SetWindowPosition método le permite establecer estos valores en una sola llamada de método.

  • Obtenga o establezca la posición del cursor obteniendo o estableciendo las CursorTop propiedades y CursorLeft , o establezca la posición del cursor llamando al SetCursorPosition método .

  • Mueva o borre los datos en el búfer de pantalla llamando al MoveBufferArea método o Clear .

  • Obtenga o establezca los colores de primer plano y de fondo mediante las ForegroundColor propiedades y BackgroundColor , o restablezca el fondo y el primer plano a sus colores predeterminados llamando al ResetColor método .

  • Reproduce el sonido de un pitido a través del altavoz de la consola llamando al Beep método .

Notas de .NET Core

En .NET Framework en el escritorio, la Console clase usa la codificación devuelta por GetConsoleCP y GetConsoleOutputCP, que normalmente es una codificación de página de códigos. Por ejemplo, en sistemas cuya referencia cultural es inglés (Estados Unidos), la página de códigos 437 es la codificación que se usa de forma predeterminada. Sin embargo, .NET Core puede hacer que solo haya disponible un subconjunto limitado de estas codificaciones. En este caso, Encoding.UTF8 se usa como codificación predeterminada para la consola.

Si la aplicación depende de codificaciones de páginas de códigos específicas, puedes hacer que estén disponibles haciendo lo siguiente antes de llamar a cualquier Console método:

  1. Agregue una referencia al ensamblado System.Text.Encoding.CodePages.dll al proyecto.

  2. Recupere el EncodingProvider objeto de la CodePagesEncodingProvider.Instance propiedad .

  3. Pase el EncodingProvider objeto al Encoding.RegisterProvider método para que las codificaciones adicionales sean compatibles con el proveedor de codificación disponible.

A continuación, 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.

Propiedades

BackgroundColor

Obtiene o establece el color de fondo de la consola.

BufferHeight

Obtiene o establece el alto del área del búfer.

BufferWidth

Obtiene o establece el ancho del área del búfer.

CapsLock

Obtiene un valor que indica si se activa o desactiva la alternancia de teclado de BLOQ MAYÚS.

CursorLeft

Obtiene o establece la posición en columnas del cursor en el área del búfer.

CursorSize

Obtiene o establece el alto del cursor en una celda de carácter.

CursorTop

Obtiene o establece la posición en filas del cursor en el área del búfer.

CursorVisible

Obtiene o establece un valor que indica si el cursor es visible.

Error

Obtiene el flujo de salida de error estándar.

ForegroundColor

Obtiene o establece el color de primer plano de la consola.

In

Obtiene el flujo de entrada estándar.

InputEncoding

Obtiene o establece la codificación que usa la consola para leer la entrada.

IsErrorRedirected

Obtiene un valor que indica si el flujo de salida de errores se ha redirigido desde el flujo de errores estándar.

IsInputRedirected

Obtiene un valor que indica si la entrada se ha redirigido desde el flujo de entrada estándar.

IsOutputRedirected

Obtiene un valor que indica si la salida se ha redirigido desde el flujo de salida estándar.

KeyAvailable

Obtiene un valor que indica si hay disponible una acción de presionar una tecla en el flujo de entrada.

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.

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.

NumberLock

Obtiene un valor que indica si está activada o desactivada la alternancia de teclado de BLOQ NUM.

Out

Obtiene el flujo de salida estándar.

OutputEncoding

Obtiene o establece la codificación que usa la consola para escribir la salida.

Title

Obtiene o establece el título que se va a mostrar en la barra de título de la consola.

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.

WindowHeight

Obtiene o establece el alto del área de la ventana de la consola.

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.

WindowTop

Obtiene o establece la posición superior del área de la ventana de la consola con respecto al búfer de pantalla.

WindowWidth

Obtiene o establece el ancho de la ventana de la consola.

Métodos

Beep()

Reproduce el sonido de un bip a través del altavoz de la consola.

Beep(Int32, Int32)

Reproduce el sonido de un bip con una frecuencia y duración especificadas a través del altavoz de la consola.

Clear()

Borra la información que se muestra en el búfer de pantalla y en la correspondiente ventana de la consola.

GetCursorPosition()

Obtiene la posición del cursor.

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

Copia un área de origen especificada del búfer de pantalla en un área de destino determinada.

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.

OpenStandardError()

Adquiere el flujo de error estándar.

OpenStandardError(Int32)

Adquiere el flujo de error estándar, que se establece en un tamaño de búfer especificado.

OpenStandardInput()

Adquiere el flujo de entrada estándar.

OpenStandardInput(Int32)

Adquiere el flujo de entrada estándar, que se establece en un tamaño de búfer especificado.

OpenStandardOutput()

Adquiere el flujo de salida estándar.

OpenStandardOutput(Int32)

Adquiere el flujo de salida estándar, que se establece en un tamaño de búfer especificado.

Read()

Lee el siguiente carácter del flujo de entrada estándar.

ReadKey()

Obtiene la siguiente tecla de carácter o de función presionada por el usuario. La tecla presionada se muestra en la ventana de la consola.

ReadKey(Boolean)

Obtiene la siguiente tecla de carácter o de función presionada por el usuario. Opcionalmente, la tecla presionada se muestra en la ventana de la consola.

ReadLine()

Lee la siguiente línea de caracteres del flujo de entrada estándar.

ResetColor()

Establece los colores de primer plano y de fondo de la consola en sus valores predeterminados.

SetBufferSize(Int32, Int32)

Establece el alto y el ancho del área del búfer de pantalla en los valores especificados.

SetCursorPosition(Int32, Int32)

Establece la posición del cursor.

SetError(TextWriter)

Establece la propiedad Error en el objeto TextWriter especificado.

SetIn(TextReader)

Establece la propiedad In en el objeto TextReader especificado.

SetOut(TextWriter)

Establece la propiedad Out para establecer el destino del objeto TextWriter.

SetWindowPosition(Int32, Int32)

Establece la posición de la ventana de la consola con respecto al búfer de pantalla.

SetWindowSize(Int32, Int32)

Establece el alto y el ancho de la ventana de la consola en los valores especificados.

Write(Boolean)

Escribe la representación de texto del valor booleano especificado en el flujo de salida estándar.

Write(Char)

Escribe el valor del carácter Unicode especificado en el flujo de salida estándar.

Write(Char[])

Escribe la matriz especificada de caracteres Unicode en el flujo de salida estándar.

Write(Char[], Int32, Int32)

Escribe la submatriz de caracteres Unicode especificada en el flujo de salida estándar.

Write(Decimal)

Escribe la representación de texto del valor Decimal especificado en el flujo de salida estándar.

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.

Write(Int32)

Escribe la representación de texto del valor entero de 32 bits con signo especificado en el flujo de salida estándar.

Write(Int64)

Escribe la representación de texto del valor entero de 64 bits con signo especificado en el flujo de salida estándar.

Write(Object)

Escribe la representación de texto del objeto especificado en el flujo de salida estándar.

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.

Write(String)

Escribe el valor de cadena especificado en el flujo de salida estándar.

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.

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.

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.

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.

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.

Write(UInt32)

Escribe la representación de texto del valor entero de 32 bits sin signo especificado en el flujo de salida estándar.

Write(UInt64)

Escribe la representación de texto del valor entero de 64 bits sin signo especificado en el flujo de salida estándar.

WriteLine()

Escribe el terminador de línea actual en el flujo de salida estándar.

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.

WriteLine(Char)

Escribe el carácter Unicode especificado, seguido del terminador de línea actual, en el flujo de salida estándar.

WriteLine(Char[])

Escribe la matriz de caracteres Unicode especificada, seguida del terminador de línea actual, en el flujo de salida estándar.

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.

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.

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.

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.

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.

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.

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.

WriteLine(String)

Escribe el valor de cadena especificado, seguido del terminador de línea actual, en el flujo de salida estándar.

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.

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.

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.

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.

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.

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.

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.

Eventos

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).

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.