Clase System.Console
En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.
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 aplicaciones que leen caracteres de y escriben caracteres en la consola.
Secuencias de E/S de consola
Cuando se inicia una aplicación de consola, el sistema operativo asocia automáticamente tres flujos 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 sincrónicamente 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 pueden 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();
Búfer de pantalla y ventana de consola
Dos características estrechamente relacionadas de la consola son el búfer de pantalla y la ventana de la consola. En realidad, el texto se lee o escribe en secuencias que pertenecen a la consola, pero parece que se leen o escriben 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 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 la consola se pueda cambiar de posición en 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 esté siempre en la 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. Use í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 (?), ya que los caracteres cirílicos no se asignan a los caracteres de la página de códigos 437.
using System;
public class Example3
{
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. 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 que no sea 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 Example2
{
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr GetStdHandle(int nStdHandle);
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
static extern bool GetCurrentConsoleFontEx(
IntPtr consoleOutput,
bool maximumWindow,
ref CONSOLE_FONT_INFO_EX lpConsoleCurrentFontEx);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool SetCurrentConsoleFontEx(
IntPtr consoleOutput,
bool maximumWindow,
CONSOLE_FONT_INFO_EX consoleCurrentFontEx);
private const int STD_OUTPUT_HANDLE = -11;
private const int TMPF_TRUETYPE = 4;
private const int LF_FACESIZE = 32;
private static IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
public static unsafe void Main()
{
string fontName = "Lucida Console";
IntPtr hnd = GetStdHandle(STD_OUTPUT_HANDLE);
if (hnd != INVALID_HANDLE_VALUE)
{
CONSOLE_FONT_INFO_EX info = new CONSOLE_FONT_INFO_EX();
info.cbSize = (uint)Marshal.SizeOf(info);
bool tt = false;
// First determine whether there's already a TrueType font.
if (GetCurrentConsoleFontEx(hnd, false, ref info))
{
tt = (info.FontFamily & TMPF_TRUETYPE) == TMPF_TRUETYPE;
if (tt)
{
Console.WriteLine("The console already is using a TrueType font.");
return;
}
// Set console font to Lucida Console.
CONSOLE_FONT_INFO_EX newInfo = new CONSOLE_FONT_INFO_EX();
newInfo.cbSize = (uint)Marshal.SizeOf(newInfo);
newInfo.FontFamily = TMPF_TRUETYPE;
IntPtr ptr = new IntPtr(newInfo.FaceName);
Marshal.Copy(fontName.ToCharArray(), 0, ptr, fontName.Length);
// Get some settings from current font.
newInfo.dwFontSize = new COORD(info.dwFontSize.X, info.dwFontSize.Y);
newInfo.FontWeight = info.FontWeight;
SetCurrentConsoleFontEx(hnd, false, newInfo);
}
}
}
[StructLayout(LayoutKind.Sequential)]
internal struct COORD
{
internal short X;
internal short Y;
internal COORD(short x, short y)
{
X = x;
Y = y;
}
}
[StructLayout(LayoutKind.Sequential)]
internal unsafe struct CONSOLE_FONT_INFO_EX
{
internal uint cbSize;
internal uint nFont;
internal COORD dwFontSize;
internal int FontFamily;
internal int FontWeight;
internal fixed char FaceName[LF_FACESIZE];
}
}
Imports System.Runtime.InteropServices
Public Module Example5
' <DllImport("kernel32.dll", SetLastError = true)>
Private Declare Function GetStdHandle Lib "Kernel32" (
nStdHandle As Integer) As IntPtr
' [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
Private Declare Function GetCurrentConsoleFontEx Lib "Kernel32" (
consoleOutput As IntPtr,
maximumWindow As Boolean,
ByRef lpConsoleCurrentFontEx As CONSOLE_FONT_INFO_EX) As Boolean
' [DllImport("kernel32.dll", SetLastError = true)]
Private Declare Function SetCurrentConsoleFontEx Lib "Kernel32" (
consoleOutput As IntPtr,
maximumWindow As Boolean,
consoleCurrentFontEx As CONSOLE_FONT_INFO_EX) As Boolean
Private Const STD_OUTPUT_HANDLE As Integer = -11
Private Const TMPF_TRUETYPE As Integer = 4
Private Const LF_FACESIZE As Integer = 32
Private INVALID_HANDLE_VALUE As IntPtr = New IntPtr(-1)
Public Sub Main()
Dim fontName As String = "Lucida Console"
Dim hnd As IntPtr = GetStdHandle(STD_OUTPUT_HANDLE)
If hnd <> INVALID_HANDLE_VALUE Then
Dim info As CONSOLE_FONT_INFO_EX = New CONSOLE_FONT_INFO_EX()
info.cbSize = CUInt(Marshal.SizeOf(info))
Dim tt As Boolean = False
' First determine whether there's already a TrueType font.
If GetCurrentConsoleFontEx(hnd, False, info) Then
tt = (info.FontFamily And TMPF_TRUETYPE) = TMPF_TRUETYPE
If tt Then
Console.WriteLine("The console already is using a TrueType font.")
Return
End If
' Set console font to Lucida Console.
Dim newInfo As CONSOLE_FONT_INFO_EX = New CONSOLE_FONT_INFO_EX()
newInfo.cbSize = CUInt(Marshal.SizeOf(newInfo))
newInfo.FontFamily = TMPF_TRUETYPE
newInfo.FaceName = fontName
' Get some settings from current font.
newInfo.dwFontSize = New COORD(info.dwFontSize.X, info.dwFontSize.Y)
newInfo.FontWeight = info.FontWeight
SetCurrentConsoleFontEx(hnd, False, newInfo)
End If
End If
End Sub
<StructLayout(LayoutKind.Sequential)> Friend Structure COORD
Friend X As Short
Friend Y As Short
Friend Sub New(x As Short, y As Short)
Me.X = x
Me.Y = y
End Sub
End Structure
<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)> Friend Structure CONSOLE_FONT_INFO_EX
Friend cbSize As UInteger
Friend nFont As UInteger
Friend dwFontSize As COORD
Friend FontFamily As Integer
Friend FontWeight As Integer
<MarshalAs(UnmanagedType.ByValTStr, SizeConst:=32)> Friend FaceName As String
End Structure
End Module
module Example
open System
open System.Runtime.InteropServices
[<Literal>]
let STD_OUTPUT_HANDLE = -11
[<Literal>]
let TMPF_TRUETYPE = 4
[<Literal>]
let LF_FACESIZE = 32
let INVALID_HANDLE_VALUE = IntPtr(-1)
[<Struct>]
[<StructLayout(LayoutKind.Sequential)>]
type COORD =
val mutable X: int16
val mutable Y: int16
internal new(x: int16, y: int16) =
{ X = x
Y = y }
[<Struct>]
[<StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)>]
type CONSOLE_FONT_INFO_EX =
val mutable cbSize: uint32
val mutable nFont: uint32
val mutable dwFontSize: COORD
val mutable FontFamily: int
val mutable FontWeight: int
[<MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)>]
val mutable FaceName: string
[<DllImport("kernel32.dll", SetLastError = true)>]
extern IntPtr GetStdHandle(int nStdHandle)
[<DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)>]
extern bool GetCurrentConsoleFontEx(IntPtr consoleOutput, bool maximumWindow, CONSOLE_FONT_INFO_EX lpConsoleCurrentFontEx)
[<DllImport("kernel32.dll", SetLastError = true)>]
extern bool SetCurrentConsoleFontEx(IntPtr consoleOutput, bool maximumWindow, CONSOLE_FONT_INFO_EX consoleCurrentFontEx)
[<EntryPoint>]
let main argv =
let fontName = "Lucida Console"
let hnd = GetStdHandle(STD_OUTPUT_HANDLE)
if hnd <> INVALID_HANDLE_VALUE then
let mutable info = CONSOLE_FONT_INFO_EX()
info.cbSize <- uint32 (Marshal.SizeOf(info))
// First determine whether there's already a TrueType font.
if (GetCurrentConsoleFontEx(hnd, false, info)) then
if (((info.FontFamily) &&& TMPF_TRUETYPE) = TMPF_TRUETYPE) then
Console.WriteLine("The console already is using a TrueType font.")
else
// Set console font to Lucida Console.
let mutable newInfo = CONSOLE_FONT_INFO_EX()
newInfo.cbSize <- uint32 (Marshal.SizeOf(newInfo))
newInfo.FontFamily <- TMPF_TRUETYPE
newInfo.FaceName <- fontName
// Get some settings from current font.
newInfo.dwFontSize <- COORD(info.dwFontSize.X, info.dwFontSize.Y)
newInfo.FontWeight <- info.FontWeight
SetCurrentConsoleFontEx(hnd, false, newInfo) |> ignore
Console.WriteLine("The console is now using a TrueType font.")
// Return zero for success
0
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 lalista 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 puede definir mediante programación una fuente vinculada denominada SimSun que se encuentra en un archivo de fuente denominado simsun.ttc que muestra caracteres simplificados de Han.
using Microsoft.Win32;
using System;
public class Example
{
public static void Main()
{
string valueName = "Lucida Console";
string newFont = "simsun.ttc,SimSun";
string[] fonts = null;
RegistryValueKind kind = 0;
bool toAdd;
RegistryKey key = Registry.LocalMachine.OpenSubKey(
@"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink",
true);
if (key == null) {
Console.WriteLine("Font linking is not enabled.");
}
else {
// Determine if the font is a base font.
string[] names = key.GetValueNames();
if (Array.Exists(names, s => s.Equals(valueName,
StringComparison.OrdinalIgnoreCase))) {
// Get the value's type.
kind = key.GetValueKind(valueName);
// Type should be RegistryValueKind.MultiString, but we can't be sure.
switch (kind) {
case RegistryValueKind.String:
fonts = new string[] { (string) key.GetValue(valueName) };
break;
case RegistryValueKind.MultiString:
fonts = (string[]) key.GetValue(valueName);
break;
case RegistryValueKind.None:
// Do nothing.
fonts = new string[] { };
break;
}
// Determine whether SimSun is a linked font.
if (Array.FindIndex(fonts, s =>s.IndexOf("SimSun",
StringComparison.OrdinalIgnoreCase) >=0) >= 0) {
Console.WriteLine("Font is already linked.");
toAdd = false;
}
else {
// Font is not a linked font.
toAdd = true;
}
}
else {
// Font is not a base font.
toAdd = true;
fonts = new string[] { };
}
if (toAdd) {
Array.Resize(ref fonts, fonts.Length + 1);
fonts[fonts.GetUpperBound(0)] = newFont;
// Change REG_SZ to REG_MULTI_SZ.
if (kind == RegistryValueKind.String)
key.DeleteValue(valueName, false);
key.SetValue(valueName, fonts, RegistryValueKind.MultiString);
Console.WriteLine("SimSun added to the list of linked fonts.");
}
}
if (key != null) key.Close();
}
}
Imports Microsoft.Win32
Module Example2
Public Sub Main()
Dim valueName As String = "Lucida Console"
Dim newFont As String = "simsun.ttc,SimSun"
Dim fonts() As String = Nothing
Dim kind As RegistryValueKind
Dim toAdd As Boolean
Dim key As RegistryKey = Registry.LocalMachine.OpenSubKey(
"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink",
True)
If key Is Nothing Then
Console.WriteLine("Font linking is not enabled.")
Else
' Determine if the font is a base font.
Dim names() As String = key.GetValueNames()
If Array.Exists(names, Function(s) s.Equals(valueName,
StringComparison.OrdinalIgnoreCase)) Then
' Get the value's type.
kind = key.GetValueKind(valueName)
' Type should be RegistryValueKind.MultiString, but we can't be sure.
Select Case kind
Case RegistryValueKind.String
fonts = {CStr(key.GetValue(valueName))}
Case RegistryValueKind.MultiString
fonts = CType(key.GetValue(valueName), String())
Case RegistryValueKind.None
' Do nothing.
fonts = {}
End Select
' Determine whether SimSun is a linked font.
If Array.FindIndex(fonts, Function(s) s.IndexOf("SimSun",
StringComparison.OrdinalIgnoreCase) >= 0) >= 0 Then
Console.WriteLine("Font is already linked.")
toAdd = False
Else
' Font is not a linked font.
toAdd = True
End If
Else
' Font is not a base font.
toAdd = True
fonts = {}
End If
If toAdd Then
Array.Resize(fonts, fonts.Length + 1)
fonts(fonts.GetUpperBound(0)) = newFont
' Change REG_SZ to REG_MULTI_SZ.
If kind = RegistryValueKind.String Then
key.DeleteValue(valueName, False)
End If
key.SetValue(valueName, fonts, RegistryValueKind.MultiString)
Console.WriteLine("SimSun added to the list of linked fonts.")
End If
End If
If key IsNot Nothing Then key.Close()
End Sub
End Module
open System
open Microsoft.Win32
let valueName = "Lucida Console"
let newFont = "simsun.ttc,SimSun"
let key =
Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink", true)
if isNull key then
printfn "Font linking is not enabled."
else
// Determine if the font is a base font.
let names = key.GetValueNames()
let (fonts, kind, toAdd) =
if names |> Array.exists (fun s -> s.Equals(valueName, StringComparison.OrdinalIgnoreCase)) then
// Get the value's type.
let kind = key.GetValueKind(valueName)
// Type should be RegistryValueKind.MultiString, but we can't be sure.
let fonts =
match kind with
| RegistryValueKind.String -> [| key.GetValue(valueName) :?> string |]
| RegistryValueKind.MultiString -> (key.GetValue(valueName) :?> string array)
| _ -> [||]
// Determine whether SimSun is a linked font.
let toAdd =
not (fonts |> Array.exists (fun s -> s.IndexOf("SimSun", StringComparison.OrdinalIgnoreCase) >= 0))
(fonts, kind, toAdd)
else
// Font is not a base font.
([||], RegistryValueKind.Unknown, true)
if toAdd then
// Font is not a linked font.
let newFonts = Array.append fonts [| newFont |]
// Change REG_SZ to REG_MULTI_SZ.
if kind = RegistryValueKind.String then key.DeleteValue(valueName, false)
key.SetValue(valueName, newFonts, RegistryValueKind.MultiString)
printfn "SimSun added to the list of linked fonts."
else
printfn "Font is already linked."
if not (isNull key) then key.Close()
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 visualizació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 de combinación) se muestran como caracteres independientes. Para solucionar 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, una cadena que contiene la secuencia de caracteres combinada U+0061 U+0308 se muestra en la consola como dos caracteres antes de que se normalice 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 Example1 { public static void Main() { char[] chars = { '\u0061', '\u0308' }; string combining = new String(chars); Console.WriteLine(combining); combining = combining.Normalize(); Console.WriteLine(combining); } } // The example displays the following output: // a" // äModule Example3 Public Sub Main() Dim chars() As Char = {ChrW(&H61), ChrW(&H308)} Dim combining As String = New String(chars) Console.WriteLine(combining) combining = combining.Normalize() Console.WriteLine(combining) End Sub End Module ' The example displays the following output: ' a" ' äopen System let chars = [| '\u0061'; '\u0308' |] let combining = String chars Console.WriteLine combining let combining2 = combining.Normalize() Console.WriteLine combining2 // The example displays the following output: // a" // ä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 va a 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 toda una línea 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 le permite establecer el tamaño del búfer en una sola llamada de 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 le 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 .
Obtiene o establece los colores de primer plano y de fondo mediante las ForegroundColor propiedades y BackgroundColor , o restablece 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:
Recupere el EncodingProvider objeto de la CodePagesEncodingProvider.Instance propiedad .
Pase el EncodingProvider objeto al Encoding.RegisterProvider método para que el proveedor de codificación admita las codificaciones adicionales.
A continuación, la Console clase usará automáticamente la codificación del sistema predeterminada en lugar de UTF8, siempre que haya registrado el proveedor de codificación antes de llamar a los Console métodos de salida.
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 System;
public class Example4
{
public static void Main()
{
Console.Write("Hello ");
Console.WriteLine("World!");
Console.Write("Enter your name: ");
string name = Console.ReadLine();
Console.Write("Good day, ");
Console.Write(name);
Console.WriteLine("!");
}
}
// The example displays output similar to the following:
// Hello World!
// Enter your name: James
// Good day, James!
Public Class Example4
Public Shared Sub Main()
Console.Write("Hello ")
Console.WriteLine("World!")
Console.Write("Enter your name: ")
Dim name As String = Console.ReadLine()
Console.Write("Good day, ")
Console.Write(name)
Console.WriteLine("!")
End Sub
End Class
' The example displays output similar to the following:
' Hello World!
' Enter your name: James
' Good day, James!
module Example
open System
[<EntryPoint>]
let main argv =
Console.Write("Hello ")
Console.WriteLine("World!")
Console.Write("Enter your name: ")
let name = Console.ReadLine()
Console.Write("Good day, ")
Console.Write(name)
Console.WriteLine("!")
0
// The example displays output similar to the following:
// Hello World!
// Enter your name: James
// Good day, James!
