Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Console (Clase)

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

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

public static class Console

El tipo Console expone los siguientes miembros.

  NombreDescripción
Propiedad públicaMiembro estáticoBackgroundColorObtiene o establece el color de fondo de la consola.
Propiedad públicaMiembro estáticoBufferHeightObtiene o establece el alto del área del búfer.
Propiedad públicaMiembro estáticoBufferWidthObtiene o establece el ancho del área del búfer.
Propiedad públicaMiembro estáticoCapsLockObtiene un valor que indica si se activa o desactiva la alternancia de teclado de BLOQ MAYÚS.
Propiedad públicaMiembro estáticoCursorLeftObtiene o establece la posición en columnas del cursor en el área del búfer.
Propiedad públicaMiembro estáticoCursorSizeObtiene o establece el alto del cursor en una celda de carácter.
Propiedad públicaMiembro estáticoCursorTopObtiene o establece la posición en filas del cursor en el área del búfer.
Propiedad públicaMiembro estáticoCursorVisibleObtiene o establece un valor que indica si el cursor es visible.
Propiedad públicaMiembro estáticoCompatible con XNA FrameworkErrorObtiene el flujo de salida de error estándar.
Propiedad públicaMiembro estáticoForegroundColorObtiene o establece el color de primer plano de la consola.
Propiedad públicaMiembro estáticoCompatible con XNA FrameworkInObtiene el flujo de entrada estándar.
Propiedad públicaMiembro estáticoInputEncodingObtiene o establece la codificación que utiliza la consola para leer la entrada.
Propiedad públicaMiembro estáticoIsErrorRedirectedObtiene un valor que indica si el flujo de salida de errores se ha redirigido desde el flujo de errores estándar.
Propiedad públicaMiembro estáticoIsInputRedirectedObtiene un valor que indica si la entrada se ha redirigido desde el flujo de entrada estándar.
Propiedad públicaMiembro estáticoIsOutputRedirectedObtiene un valor que indica si la salida se ha redirigido desde el flujo de salida estándar.
Propiedad públicaMiembro estáticoKeyAvailableObtiene un valor que indica si hay disponible una acción de presionar una tecla en el flujo de entrada.
Propiedad públicaMiembro estáticoLargestWindowHeightObtiene 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.
Propiedad públicaMiembro estáticoLargestWindowWidthObtiene 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.
Propiedad públicaMiembro estáticoNumberLockObtiene un valor que indica si está activada o desactivada la alternancia de teclado de BLOQ NUM.
Propiedad públicaMiembro estáticoCompatible con XNA FrameworkOutObtiene el flujo de salida estándar.
Propiedad públicaMiembro estáticoOutputEncodingObtiene o establece la codificación que utiliza la consola para escribir la salida.
Propiedad públicaMiembro estáticoTitleObtiene o establece el título que se va a mostrar en la barra de título de la consola.
Propiedad públicaMiembro estáticoTreatControlCAsInputObtiene 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.
Propiedad públicaMiembro estáticoWindowHeightObtiene o establece el alto del área de la ventana de la consola.
Propiedad públicaMiembro estáticoWindowLeftObtiene 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.
Propiedad públicaMiembro estáticoWindowTopObtiene o establece la posición superior del área de la ventana de la consola con respecto al búfer de pantalla.
Propiedad públicaMiembro estáticoWindowWidthObtiene o establece el ancho de la ventana de la consola.
Arriba

  NombreDescripción
Método públicoMiembro estáticoBeep()Reproduce el sonido de un bip a través del altavoz de la consola.
Método públicoMiembro estáticoBeep(Int32, Int32)Reproduce el sonido de un bip con una frecuencia y duración especificadas a través del altavoz de la consola.
Método públicoMiembro estáticoClearBorra la información que se muestra en el búfer de pantalla y en la correspondiente ventana de la consola.
Método públicoMiembro estáticoMoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32)Copia un área de origen especificada del búfer de pantalla en un área de destino determinada.
Método públicoMiembro estáticoMoveBufferArea(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.
Método públicoMiembro estáticoOpenStandardError()Adquiere el flujo de error estándar.
Método públicoMiembro estáticoOpenStandardError(Int32)Adquiere el flujo de error estándar, que se establece en un tamaño de búfer especificado.
Método públicoMiembro estáticoOpenStandardInput()Adquiere el flujo de entrada estándar.
Método públicoMiembro estáticoOpenStandardInput(Int32)Adquiere el flujo de entrada estándar, que se establece en un tamaño de búfer especificado.
Método públicoMiembro estáticoOpenStandardOutput()Adquiere el flujo de salida estándar.
Método públicoMiembro estáticoOpenStandardOutput(Int32)Adquiere el flujo de salida estándar, que se establece en un tamaño de búfer especificado.
Método públicoMiembro estáticoReadLee el siguiente carácter del flujo de entrada estándar.
Método públicoMiembro estáticoReadKey()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.
Método públicoMiembro estáticoReadKey(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.
Método públicoMiembro estáticoCompatible con XNA FrameworkReadLineLee la siguiente línea de caracteres del flujo de entrada estándar.
Método públicoMiembro estáticoResetColorEstablece los colores de primer plano y de fondo de la consola en sus valores predeterminados.
Método públicoMiembro estáticoSetBufferSizeEstablece el alto y el ancho del área del búfer de pantalla en los valores especificados.
Método públicoMiembro estáticoSetCursorPositionEstablece la posición del cursor.
Método públicoMiembro estáticoCompatible con XNA FrameworkSetErrorEstablece la propiedad Error en el objeto TextWriter especificado.
Método públicoMiembro estáticoCompatible con XNA FrameworkSetInEstablece la propiedad In en el objeto TextReader especificado.
Método públicoMiembro estáticoCompatible con XNA FrameworkSetOutEstablece la propiedad Out en el objeto TextWriter especificado.
Método públicoMiembro estáticoSetWindowPositionEstablece la posición de la ventana de la consola con respecto al búfer de pantalla.
Método públicoMiembro estáticoSetWindowSizeEstablece el alto y el ancho de la ventana de la consola en los valores especificados.
Método públicoMiembro estáticoWrite(Boolean)Escribe la representación de texto del valor Boolean especificado en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(Char)Escribe el valor del carácter Unicode especificado en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(Char[])Escribe la matriz especificada de caracteres Unicode en el flujo de salida estándar.
Método públicoMiembro estáticoWrite(Decimal)Escribe la representación de texto del valor Decimal especificado en el flujo de salida estándar.
Método públicoMiembro estáticoWrite(Double)Escribe la representación de texto del valor de punto flotante de precisión doble especificado en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(Int32)Escribe la representación de texto del valor entero de 32 bits con signo especificado en el flujo de salida estándar.
Método públicoMiembro estáticoWrite(Int64)Escribe la representación de texto del valor entero de 64 bits con signo especificado en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(Object)Escribe la representación de texto del objeto especificado en el flujo de salida estándar.
Método públicoMiembro estáticoWrite(Single)Escribe la representación de texto del valor de punto flotante de precisión sencilla especificado en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(String)Escribe el valor de cadena especificado en el flujo de salida estándar.
Método públicoMiembro estáticoWrite(UInt32)Escribe la representación de texto del valor entero de 32 bits sin signo especificado en el flujo de salida estándar.
Método públicoMiembro estáticoWrite(UInt64)Escribe la representación de texto del valor entero de 64 bits sin signo especificado en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(String, Object)Escribe la representación de texto del objeto especificado en el flujo de salida estándar utilizando la información de formato indicada.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(String, Object[])Escribe la representación de texto de la matriz de objetos especificada en el flujo de salida estándar utilizando la información de formato especificada.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(Char[], Int32, Int32)Escribe la submatriz de caracteres Unicode especificada en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(String, Object, Object)Escribe la representación de texto de los objetos especificados en el flujo de salida estándar utilizando la información de formato indicada.
Método públicoMiembro estáticoCompatible con XNA FrameworkWrite(String, Object, Object, Object)Escribe la representación de texto de los objetos especificados en el flujo de salida estándar utilizando la información de formato indicada.
Método públicoMiembro estáticoWrite(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 utilizando la información de formato especificada.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine()Escribe el terminador de línea actual en el flujo de salida estándar.
Método públicoMiembro estáticoWriteLine(Boolean)Escribe la representación de texto del valor Boolean especificado, seguida del terminador de línea actual, en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(Char)Escribe el carácter Unicode especificado, seguido del terminador de línea actual, en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(Char[])Escribe la matriz de caracteres Unicode especificada, seguida del terminador de línea actual, en el flujo de salida estándar.
Método públicoMiembro estáticoWriteLine(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.
Método públicoMiembro estáticoWriteLine(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.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(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.
Método públicoMiembro estáticoWriteLine(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.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(Object)Escribe la representación de texto del objeto especificado, seguida del terminador de línea actual, en el flujo de salida estándar.
Método públicoMiembro estáticoWriteLine(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.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(String)Escribe el valor de cadena especificado, seguido del terminador de línea actual, en el flujo de salida estándar.
Método públicoMiembro estáticoWriteLine(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.
Método públicoMiembro estáticoWriteLine(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.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(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 utilizando la información de formato especificada.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(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 utilizando la información de formato especificada.
Método públicoMiembro estáticoWriteLine(Char[], Int32, Int32)Escribe la submatriz de caracteres Unicode especificada, seguida del terminador de línea actual, en el flujo de salida estándar.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(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 utilizando la información de formato especificada.
Método públicoMiembro estáticoCompatible con XNA FrameworkWriteLine(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 utilizando la información de formato especificada.
Método públicoMiembro estáticoWriteLine(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 utilizando la información de formato especificada.
Arriba

  NombreDescripción
Evento públicoMiembro estáticoCancelKeyPressSe produce cuando la tecla modificadora Control (Ctrl) y la tecla de consola ConsoleKey.C (C) o la tecla Interrumpir se presionan simultáneamente (Ctrl+C o Ctrl+Inter).
Arriba

La consola es una ventana del sistema operativo donde los usuarios interactúan con el sistema operativo o con una aplicación de consola basada en texto escribiendo en la entrada de texto a través del teclado de equipo, y leer el texto generado del terminal. Por ejemplo, en el sistema operativo Windows, la consola se denomina la ventana símbolo del sistema y acepta comandos de MS-DOS. La clase Console proporciona una compatibilidad básica para las aplicaciones que leen y escriben caracteres en la consola.

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

Flujos de E/S de la consola

Cuando una aplicación de consola empezará, el sistema operativo asocia automáticamente tres secuencias de E/S en 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 las entradas del usuario provenientes del flujo de entrada estándar, escribir datos normales en el flujo de salida estándar y escribir datos de error en el flujo de salida de error estándar. Estos flujos se presentan a la aplicación como los valores de las propiedades Console.In, Console.Out y Console.Error.

De manera predeterminada, el valor de la propiedad In es un objeto System.IO.TextReader y los valores de las propiedades Out y Error son objetos System.IO.TextWriter. No obstante, se pueden establecer estas propiedades en flujos que no representen la consola; por ejemplo, es posible establecer estas propiedades en flujos que representen archivos. Para redirigir la entrada estándar, el resultado estándar o el flujo de error estándar, llame al método Console.SetIn, Console.SetError o Console.SetOut, respectivamente. Se sincronizan las operaciones de E/S que utilizan estas secuencias, lo que significa que varios subprocesos pueden leer de, o escriben, secuencias.

NotaNota

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

Los miembros de la clase Console que funcionan normalmente cuando el flujo subyacente se dirige a una consola pueden producir una excepción si el flujo se redirige, por ejemplo, a un archivo. Programa la aplicación para detectar las excepciones de System.IO.IOException si redirige una secuencia estándar. También puede utilizar IsOutputRedirected, IsInputRedirected, y las propiedades de IsErrorRedirected para determinar si una secuencia estándar se redirigirá antes de realizar una operación que inicia una excepción de System.IO.IOException .

A veces es útil llamar explícitamente a los miembros de los objetos de secuencia representados por In, Out, y las propiedades de Error . Por ejemplo, de forma predeterminada, el método Console.ReadLine lee la entrada del flujo de entrada estándar. De igual forma, el método de Console.WriteLine escribe datos en el flujo de salida estándar, y los datos va seguido de la cadena predeterminada de fin de línea, que es un retorno de carro y un salto de línea (“\r\n”). Sin embargo, la clase Console no proporciona un método correspondiente para escribir datos en el flujo de salida de error estándar, ni una propiedad para cambiar la cadena de terminación de línea de los datos escritos en ese flujo.

Este problema se puede resolver estableciendo la propiedad TextWriter.NewLine de la propiedad Out o Error en otra cadena de terminación de línea. Por ejemplo, la siguiente instrucción de C# establece la cadena de fin de línea para el flujo de salida de error estándar a dos secuencias de retorno de carro y avance de línea:

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

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

Console.Error.WriteLine();

Búfer de pantalla y ventana de la 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 flujos propiedad de la consola, aunque aparentemente se lee o escribe en un área de la que es propietaria la consola y que se denomina búfer de pantalla. El búfer de pantalla es un atributo de la consola que está organizado como una cuadrícula rectangular de filas y columnas, en la que cada intersección de la cuadrícula, o celda de carácter, puede contener un carácter. Cada carácter tiene su propio color de primer plano, y cada celda de carácter tiene su propio color de fondo.

El búfer de pantalla se ve a través de una región rectangular denominada ventana de la consola. La ventana de la consola es otro atributo de la consola; no la propia consola, y es una ventana de sistema operativo. La ventana de la consola se organizan en filas y columnas, es menor o igual que el tamaño de búfer de pantalla, y se puede desplazarse para ver diferentes áreas del búfer de pantalla subyacente. Si el búfer de pantalla es mayor que la ventana de la consola, ésta muestra automáticamente barras de desplazamiento para poder cambiar la posición de la ventana en el área del búfer de pantalla.

Un cursor indica la posición en el búfer de pantalla donde se está leyendo o escribiendo el texto actualmente. El cursor se puede ocultar o mostrar y también es posible cambiar su alto. Cuando el cursor está visible, la posición de la ventana de la consola se mueve automáticamente de modo que el cursor siempre quede a la vista.

El origen de las coordenadas de celda de carácter en el búfer de presentación es la esquina superior izquierda, y la posición del cursor y la ventana de la consola se miden en relación con ese origen. Utilice índices de base cero para indicar las posiciones; es decir, especifique la fila superior como fila 0 y la columna situada más a la izquierda como columna 0. El valor máximo para los índices de columna y fila es Int16.MaxValue.

Compatibilidad con Unicode para la consola

La consola lee normalmente entrada y escribe generan con la página de códigos actual de la consola, que la configuración regional del sistema define de forma predeterminada. Una página de códigos puede controlar sólo un subconjunto de caracteres Unicode disponible, por lo que si se intenta mostrar caracteres que no son asignados por una página de códigos determinada, la consola no podrá mostrar todos los caracteres o representarlos exactamente. En el ejemplo siguiente se muestra este problema. Intenta mostrar caracteres del alfabeto cirílico de U+0410 a U+044F en la consola. Si ejecuta el ejemplo en un sistema que utiliza la página de códigos 437 de la consola, cada carácter se reemplaza por un signo de interrogación (?), porque los caracteres cirílicos no asignados 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] = Convert.ToChar(codePoint);
        codePoint++;
      }   

      Console.WriteLine("Current code page: {0}\n", 
                        Console.OutputEncoding.CodePage);
      // Display the characters.
      foreach (var ch in chars) {
         Console.Write("{0}  ", ch);
         if (Console.CursorLeft >= 70) 
            Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Current code page: 437
//    
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?


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

Compatibilidad con caracteres Unicode requiere el codificador reconocer un carácter Unicode determinado, y también requiere una fuente que haga glifos que necesite para generar ese carácter. Para mostrar correctamente los caracteres Unicode en la consola, la fuente de la consola debe establecerse en una interfaz no trama o una fuente TrueType como consola de Consolas o de Lucida. El ejemplo siguiente se muestra cómo se puede cambiar mediante programación a la fuente de una fuente de mapa de bits a la consola de Lucida.


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];
   } 
}


Sin embargo, las fuentes truetype pueden mostrar solo un subconjunto de glifos. Por ejemplo, la fuente de la consola de Lucida solo muestra 643 de los aproximadamente 64.000 caracteres disponibles de U+0021 a U+FB02. Para ver los caracteres una fuente determinada admitan, abra el applet de Fuentes en Panel de control, elija la opción de Buscar un carácter , y elija la fuente cuyo juego de caracteres desee examinar en la lista de font de la ventana de Mapa de caracteres .

Windows utiliza la fuente que vincula para mostrar glifos que no están disponibles en una fuente concreta. Para obtener información acerca de la fuente que vincula para mostrar juegos de caracteres adicionales, vea Globalización paso a paso: Fuentes. Las fuentes se definen vinculadas en la subclave de 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 el valor es una matriz de cadenas que define los archivos de fuente y fuentes vinculados a la fuente base. Cada miembro de la matriz define una fuente vinculada y su formato fuente-archivo-nombre,nombre de fuente. El ejemplo siguiente se muestra cómo mediante programación puede definir una fuente vinculada denominada SimSun encontrado en un archivo de fuente denominado simsun.ttc que muestra los caracteres de Simplificado 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();
   }
}


Compatibilidad de Unicode para la consola tiene las siguientes limitaciones:

  • La codificación UTF-32 no se admite. Las únicas codificaciones admitidas Unicode son UTF-8 y UTF-16, que se representan mediante las clases de UTF8Encoding y de UnicodeEncoding , respectivamente.

  • No se admiten en la salida bidireccional.

  • No se admiten en la pantalla de caracteres fuera de MUI básico Plane (es decir, de pares suplentes), aunque se definen en un archivo de fuente vinculado.

  • No se admiten en la pantalla de caracteres de escritura compleja.

  • Combinando el carácter secuencias (es decir, caracteres que constan de un carácter base y uno o más caracteres combinados) se muestran como caracteres independientes. Para solucionar esta limitación, puede normalizar la cadena que se mostrará llamando al método de String.Normalize antes de enviar generado en la consola. En el ejemplo siguiente, una cadena que contiene la secuencia U+0061 U+0308 de caracteres de combinación se muestra en la consola como dos caracteres antes de que la cadena de resultado es normalizada, y como un único carácter después del método de String.Normalize se denomina.

    
    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"
    //       ä
    
    
    

    Observe que la normalización es una solución viable sólo si el estándar Unicode por el carácter incluye un formulario pre- compuesto que corresponde a una secuencia determinada de caracteres de combinación.

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

El ejemplo siguiente muestra un intervalo de caracteres Unicode en la consola. El ejemplo acepta tres parámetros de línea de comandos: el inicio del intervalo de mostrar, el final del intervalo a mostrar, y si utilizar la codificación actual de consola (false) o UTF-16 (true). Se supone que la consola utiliza 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(" {0} ", Convert.ToChar(0x20));
            }
            else if (end < cur) {
               Console.Write(" {0} ", Convert.ToChar(0x20));
            }
            else {
               // the cast to int is safe, since we know that val <= upperRange.
               String chars = Char.ConvertFromUtf32( (int) cur);
               // Display a space for code points that are not valid characters.
               if (CharUnicodeInfo.GetUnicodeCategory(chars[0]) == 
                                               UnicodeCategory.OtherNotAssigned)
                  Console.Write(" {0} ", Convert.ToChar(0x20));
               // Display a space for code points in the private use area.
               else if (CharUnicodeInfo.GetUnicodeCategory(chars[0]) ==
                                              UnicodeCategory.PrivateUse)
                 Console.Write(" {0} ", Convert.ToChar(0x20));
               // Is surrogate pair a valid character?
               // Note that the console will interpret the high and low surrogate
               // as separate (and unrecognizable) characters.
               else if (chars.Length > 1 && CharUnicodeInfo.GetUnicodeCategory(chars, 0) == 
                                            UnicodeCategory.OtherNotAssigned)
                  Console.Write(" {0} ", Convert.ToChar(0x20));
               else
                  Console.Write(" {0} ", chars); 
            }

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

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

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

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


Operaciones comunes

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

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

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

  • Las sobrecargas del método de Write convierten una instancia de un tipo de valor, de una matriz de caracteres, o un conjunto de objetos en una cadena con formato o sin formato, y escriben esa cadena en la consola.

  • Un conjunto paralelo de sobrecargas del método de WriteLine generó la misma cadena que las sobrecargas de Write pero también agregan una cadena de fin de línea.

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

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

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

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

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

  • Obtiene o establece la posición del cursor obtener o establecer las propiedades de CursorTop y de CursorLeft , o establezca la posición del cursor llamando al método de SetCursorPosition .

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

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

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

El ejemplo siguiente muestra cómo leer datos, y tipo de datos, a la entrada y las secuencias de salida estándar. Observe que estas secuencias se pueden redirigir mediante los métodos de SetIn y de SetOut .


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!


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

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

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft