Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Console, classe

Représente les flux d'entrée, de sortie et d'erreur standard pour les applications console. Cette classe ne peut pas être héritée.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

public static class Console

Le type Console expose les membres suivants.

  NomDescription
Propriété publiqueMembre statiqueBackgroundColorObtient ou définit la couleur d'arrière-plan de la console.
Propriété publiqueMembre statiqueBufferHeightObtient ou définit la hauteur de la zone de mémoire tampon.
Propriété publiqueMembre statiqueBufferWidthObtient ou définit la largeur de la zone de mémoire tampon.
Propriété publiqueMembre statiqueCapsLockObtient une valeur indiquant si la bascule de la touche VERR. MAJ est activée ou désactivée.
Propriété publiqueMembre statiqueCursorLeftObtient ou définit la position de colonne du curseur dans la zone de mémoire tampon.
Propriété publiqueMembre statiqueCursorSizeObtient ou définit la hauteur du curseur dans une cellule de caractère.
Propriété publiqueMembre statiqueCursorTopObtient ou définit la position de ligne du curseur dans la zone de mémoire tampon.
Propriété publiqueMembre statiqueCursorVisibleObtient ou définit une valeur indiquant si le curseur est visible.
Propriété publiqueMembre statiquePris en charge par XNA FrameworkErrorObtient le flux de sortie d'erreur standard.
Propriété publiqueMembre statiqueForegroundColorObtient ou définit la couleur de premier plan de la console.
Propriété publiqueMembre statiquePris en charge par XNA FrameworkInObtient le flux d'entrée standard.
Propriété publiqueMembre statiqueInputEncodingObtient ou définit l'encodage que la console utilise pour lire l'entrée.
Propriété publiqueMembre statiqueIsErrorRedirectedObtient une valeur qui indique si le flux de sortie des erreurs a été redirigé à partir du flux d'erreurs standard.
Propriété publiqueMembre statiqueIsInputRedirectedObtient une valeur qui indique si l'entrée a été redirigée à partir du flux d'entrée standard.
Propriété publiqueMembre statiqueIsOutputRedirectedObtient une valeur qui indique si la sortie a été redirigée à partir du flux de sortie standard.
Propriété publiqueMembre statiqueKeyAvailableObtient une valeur indiquant si une touche enfoncée est disponible dans le flux d'entrée.
Propriété publiqueMembre statiqueLargestWindowHeightObtient le plus grand nombre possible de lignes de fenêtre de console, selon la police et la résolution d'écran en cours.
Propriété publiqueMembre statiqueLargestWindowWidthObtient le plus grand nombre possible de colonnes de fenêtre de console, selon la police et la résolution d'écran en cours.
Propriété publiqueMembre statiqueNumberLockObtient une valeur indiquant si la bascule de la touche VERR. NUM est activée ou désactivée.
Propriété publiqueMembre statiquePris en charge par XNA FrameworkOutObtient le flux de sortie standard.
Propriété publiqueMembre statiqueOutputEncodingObtient ou définit l'encodage que la console utilise pour écrire la sortie.
Propriété publiqueMembre statiqueTitleObtient ou définit le titre à afficher dans la barre de titre de la console.
Propriété publiqueMembre statiqueTreatControlCAsInputObtient ou définit une valeur qui indique si la combinaison de la touche de modification Control et de la touche de console (Ctrl+C) C est traitée comme une entrée ordinaire ou comme une interruption gérée par le système d'exploitation.
Propriété publiqueMembre statiqueWindowHeightObtient ou définit la hauteur de la zone de fenêtre de console.
Propriété publiqueMembre statiqueWindowLeftObtient ou définit la position la plus à gauche de la zone de fenêtre de console par rapport à la mémoire tampon d'écran.
Propriété publiqueMembre statiqueWindowTopObtient ou définit la position supérieure de la zone de fenêtre de console par rapport à la mémoire tampon d'écran.
Propriété publiqueMembre statiqueWindowWidthObtient ou définit la largeur de la fenêtre de console.
Début

  NomDescription
Méthode publiqueMembre statiqueBeep()Lit le son d'un signal sonore via le haut-parleur de la console.
Méthode publiqueMembre statiqueBeep(Int32, Int32)Lit le son d'un signal sonore à la fréquence et pendant la durée spécifiées, via le haut-parleur de la console.
Méthode publiqueMembre statiqueClearEfface de la mémoire tampon de la console et de la fenêtre de console correspondante les informations d'affichage.
Méthode publiqueMembre statiqueMoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32)Copie une zone source spécifiée de la mémoire tampon d'écran vers une zone de destination spécifiée.
Méthode publiqueMembre statiqueMoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor)Copie une zone source spécifiée de la mémoire tampon d'écran vers une zone de destination spécifiée.
Méthode publiqueMembre statiqueOpenStandardError()Acquiert le flux d'erreur standard.
Méthode publiqueMembre statiqueOpenStandardError(Int32)Acquiert le flux d'erreur standard, défini avec la taille de mémoire tampon spécifiée.
Méthode publiqueMembre statiqueOpenStandardInput()Acquiert le flux d'entrée standard.
Méthode publiqueMembre statiqueOpenStandardInput(Int32)Acquiert le flux d'entrée standard, défini avec la taille de mémoire tampon spécifiée.
Méthode publiqueMembre statiqueOpenStandardOutput()Acquiert le flux de sortie standard.
Méthode publiqueMembre statiqueOpenStandardOutput(Int32)Acquiert le flux de sortie standard, défini avec la taille de mémoire tampon spécifiée.
Méthode publiqueMembre statiqueReadLit le caractère suivant à partir du flux d'entrée standard.
Méthode publiqueMembre statiqueReadKey()Obtient le caractère suivant ou la touche de fonction sur laquelle l'utilisateur a appuyé. La touche enfoncée s'affiche dans la fenêtre de console.
Méthode publiqueMembre statiqueReadKey(Boolean)Obtient le caractère suivant ou la touche de fonction sur laquelle l'utilisateur a appuyé. La touche enfoncée s'affiche à titre facultatif dans la fenêtre de console.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkReadLineLit la ligne de caractères suivante à partir du flux d'entrée standard.
Méthode publiqueMembre statiqueResetColorDéfinit les couleurs de premier plan et d'arrière-plan de la console avec leurs valeurs par défaut.
Méthode publiqueMembre statiqueSetBufferSizeDéfinit la hauteur et la largeur de la zone de mémoire tampon d'écran avec les valeurs spécifiées.
Méthode publiqueMembre statiqueSetCursorPositionObtient la position du curseur.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkSetErrorDéfinit la propriété Error avec l'objet TextWriter spécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkSetInDéfinit la propriété In avec l'objet TextReader spécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkSetOutDéfinit la propriété Out avec l'objet TextWriter spécifié.
Méthode publiqueMembre statiqueSetWindowPositionDéfinit la position de la fenêtre de console par rapport à la mémoire tampon d'écran.
Méthode publiqueMembre statiqueSetWindowSizeDéfinit la hauteur et la largeur de la fenêtre de console avec les valeurs spécifiées.
Méthode publiqueMembre statiqueWrite(Boolean)Écrit dans le flux de sortie standard la représentation textuelle de la valeur Boolean spécifiée.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(Char)Écrit la valeur de caractère Unicode spécifiée dans le flux de sortie standard.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(Char[])Écrit le tableau de caractères Unicode spécifié dans le flux de sortie standard.
Méthode publiqueMembre statiqueWrite(Decimal)Écrit dans le flux de sortie standard la représentation textuelle de la valeur Decimal spécifiée.
Méthode publiqueMembre statiqueWrite(Double)Écrit dans le flux de sortie standard la représentation textuelle de la valeur à virgule flottante double précision spécifiée.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(Int32)Écrit dans le flux de sortie standard la représentation textuelle de la valeur entière signée 32 bits spécifiée.
Méthode publiqueMembre statiqueWrite(Int64)Écrit dans le flux de sortie standard la représentation textuelle de la valeur entière signée 64 bits spécifiée.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(Object)Écrit dans le flux de sortie standard la représentation textuelle de l'objet spécifié.
Méthode publiqueMembre statiqueWrite(Single)Écrit dans le flux de sortie standard la représentation textuelle de la valeur à virgule flottante simple précision spécifiée.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(String)Écrit la valeur de chaîne spécifiée dans le flux de sortie standard.
Méthode publiqueMembre statiqueWrite(UInt32)Écrit dans le flux de sortie standard la représentation textuelle de la valeur entière non signée 32 bits spécifiée.
Méthode publiqueMembre statiqueWrite(UInt64)Écrit dans le flux de sortie standard la représentation textuelle de la valeur entière non signée 64 bits spécifiée.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(String, Object)Écrit la représentation textuelle de l'objet spécifié dans le flux de sortie standard à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(String, Object[])Écrit la représentation textuelle du tableau d'objets spécifiés dans le flux de sortie standard à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(Char[], Int32, Int32)Écrit le sous-tableau de caractères Unicode spécifié dans le flux de sortie standard.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(String, Object, Object)Écrit la représentation textuelle des objets spécifiés dans le flux de sortie standard à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWrite(String, Object, Object, Object)Écrit la représentation textuelle des objets spécifiés dans le flux de sortie standard à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiqueWrite(String, Object, Object, Object, Object)Écrit, dans le flux de sortie standard, la représentation textuelle des objets spécifiés et la liste des paramètres de longueur variable à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine()Écrit le terminateur de la ligne active dans le flux de sortie standard.
Méthode publiqueMembre statiqueWriteLine(Boolean)Écrit dans le flux de sortie standard la représentation textuelle de la valeur Boolean spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(Char)Écrit dans le flux de sortie standard la valeur du caractère Unicode spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(Char[])Écrit dans le flux de sortie standard le tableau de caractères Unicode spécifié, suivi du terminateur de la ligne active.
Méthode publiqueMembre statiqueWriteLine(Decimal)Écrit dans le flux de sortie standard la représentation textuelle de la valeur Decimal spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiqueWriteLine(Double)Écrit dans le flux de sortie standard la représentation textuelle de la valeur à virgule flottante double précision spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(Int32)Écrit dans le flux de sortie standard la représentation textuelle de la valeur entière signée 32 bits spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiqueWriteLine(Int64)Écrit dans le flux de sortie standard la représentation textuelle de la valeur entière signée 64 bits spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(Object)Écrit dans le flux de sortie standard la représentation textuelle de l'objet spécifié, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiqueWriteLine(Single)Écrit dans le flux de sortie standard la représentation textuelle de la valeur à virgule flottante simple précision spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(String)Écrit dans le flux de sortie standard la valeur de chaîne spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiqueWriteLine(UInt32)Écrit dans le flux de sortie standard la représentation textuelle de la valeur entière non signée 32 bits spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiqueWriteLine(UInt64)Écrit dans le flux de sortie standard la représentation textuelle de la valeur entière non signée 64 bits spécifiée, suivie du terminateur de la ligne active.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(String, Object)Écrit dans le flux de sortie standard la représentation textuelle de l'objet spécifié, suivie de la marque de fin de ligne active, à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(String, Object[])Écrit dans le flux de sortie standard la représentation textuelle du tableau d'objets spécifié, suivie de la marque de fin de ligne active, à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiqueWriteLine(Char[], Int32, Int32)Écrit dans le flux de sortie standard le sous-tableau de caractères Unicode spécifié, suivi du terminateur de la ligne active.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(String, Object, Object)Écrit dans le flux de sortie standard la représentation textuelle des objets spécifiés, suivie de la marque de fin de ligne active, à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkWriteLine(String, Object, Object, Object)Écrit dans le flux de sortie standard la représentation textuelle des objets spécifiés, suivie de la marque de fin de ligne active, à l'aide des informations de format spécifiées.
Méthode publiqueMembre statiqueWriteLine(String, Object, Object, Object, Object)Écrit, dans le flux de sortie standard, la représentation textuelle des objets spécifiés et la liste des paramètres de longueur variable, suivies de la marque de fin de ligne en cours, à l'aide des informations de format spécifiées.
Début

  NomDescription
Événement publicMembre statiqueCancelKeyPressSe produit lorsque la touche de modification (Ctrl) Control (CTRL) et la touche de console (C) ConsoleKey.C ou la touche d'interruption sont utilisées simultanément (Ctrl+C ou Ctrl+ATTN).
Début

La console est une fenêtre du système d'exploitation où les utilisateurs interagissent avec le système d'exploitation ou une application console de type texte en saisissant l'entrée de texte via le clavier de l'ordinateur et en lisant la sortie de texte sur l'ordinateur terminal. Par exemple, dans le système d'exploitation Windows, la console correspond à la fenêtre d'invite de commandes et accepte les commandes MS-DOS. La classe Console fournit la prise en charge de base pour les applications qui lisent ou écrivent des caractères dans la console.

Pour plus d'informations sur la façon de développer avec la classe Console, consultez les sections suivantes :

Flux des E/S de console

Au démarrage d'une application console, le système d'exploitation associe automatiquement trois flux d'E/S avec la console : flux d'entrée standard, flux de sortie standard, et flux de sortie d'erreur standard. Votre application peut lire l'entrée d'utilisateur depuis le flux d'entrée standard, écrire des données normales dans le flux de sortie standard et écrire les données d'erreur dans le flux de sortie d'erreur standard. Ces flux sont présentés à votre application comme les valeurs des propriétés Console.In, Console.Out et Console.Error.

Par défaut, la valeur de la propriété In est un objet System.IO.TextReader, et les valeurs des propriétés Out et Error sont des objets System.IO.TextWriter. Cependant, vous pouvez associer ces propriétés aux flux qui ne représentent pas la console : par exemple, vous pouvez les associer aux flux qui représentent des fichiers. Pour rediriger le flux d'entrée, de sortie ou d'erreur standard, appelez la méthode Console.SetIn, Console.SetOut ou Console.SetError, respectivement. Les opérations d'E/S qui utilisent ces flux sont synchronisées, ce qui signifie que plusieurs threads peuvent lire à partir des flux ou y écrire.

RemarqueRemarque

N'utilisez pas la classe Console pour afficher la sortie dans des applications sans assistance, telles que les applications serveur. Les appels des méthodes telles que Console.Write et Console.WriteLine n'ont aucun effet dans les applications GUI.

Les membres de classe Console qui fonctionnent normalement lorsque le flux sous-jacent est dirigé vers une console peuvent lever une exception si le flux est, par exemple, redirigé vers un fichier. Programmez votre application de façon à intercepter les exceptions System.IO.IOException si vous redirigez un flux standard. Vous pouvez également utiliser les propriétés IsOutputRedirected, IsInputRedirected et IsErrorRedirected pour déterminer si un flux standard est redirigé avant d'exécuter une opération qui lève une exception System.IO.IOException.

Il est quelquefois utile d'appeler explicitement les membres des objets de flux représentés par les propriétés In, Out et Error. Par exemple, par défaut, la méthode Console.ReadLine lit les entrées à partir du flux d'entrée standard. De même, la méthode Console.WriteLine écrit les données dans le flux de sortie standard, suivies de la chaîne de terminaison de ligne par défaut. Les données sont donc suivies d'un retour chariot ou d'un saut de ligne ("\r\n"). Toutefois, la classe Console ne fournit pas de méthode correspondante pour écrire les données dans le flux de sortie d'erreur standard, ni de propriété pour modifier la chaîne de terminaison de ligne des données écrites dans ce flux.

Vous pouvez résoudre ce problème en attribuant à la propriété TextWriter.NewLine de Out ou à la propriété Error une autre chaîne de terminaison de ligne. Par exemple, l'instruction C# suivante attribue à la chaîne de terminaison de ligne du flux de sortie d'erreurs standard deux séquences de retour chariot et de saut de ligne :

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

Vous pouvez donc appeler explicitement la méthode WriteLine de l'objet du flux de sortie d'erreur standard, comme dans l'instruction C# suivante.

Console.Error.WriteLine();

Mémoire tampon d'écran et fenêtre de console

La mémoire tampon d'écran et la fenêtre de console constituent deux fonctionnalités étroitement liées de la console. Le texte est lu depuis les flux détenus par la console (ou y est écrit), mais semble lu (ou écrit) depuis une zone détenue par la console et intitulée mémoire tampon d'écran. La mémoire tampon d'écran est un attribut de la console et se présente sous forme d'une grille composée de lignes et de colonnes où chaque intersection de grille, ou cellule de caractère, peut contenir un caractère. Chaque caractère possède sa propre couleur de premier plan et chaque cellule de caractère, sa propre couleur d'arrière-plan.

La mémoire tampon d'écran est affichée via une région rectangulaire, appelée fenêtre de console. La fenêtre de console constitue un autre attribut de la console ; il ne s'agit pas de la console elle-même, qui est une fenêtre du système d'exploitation. La fenêtre de console est également organisée en lignes et en colonnes ; elle est inférieure ou égale à la taille de la mémoire tampon d'écran et peut être déplacée pour afficher différentes zones de la mémoire tampon d'écran sous-jacente. Si la mémoire tampon d'écran est plus grande que la fenêtre de console, la console affiche automatiquement les barres de défilement afin que la fenêtre de console puisse être repositionnée sur la zone de la mémoire tampon d'écran.

Un curseur indique la position dans la mémoire tampon d'écran de l'emplacement où le texte est lu ou écrit. Le curseur peut être masqué ou affiché, et sa hauteur peut être modifiée. Si le curseur est visible, la position de la fenêtre de console est déplacée automatiquement afin que le curseur demeure toujours en vue.

L'origine des coordonnées de la cellule de caractère de la mémoire tampon d'écran se trouve dans le coin supérieur gauche, tandis que les positions du curseur et de la fenêtre de console sont mesurées par rapport à cette origine. Utilisez les index de base zéro pour spécifier des positions ; autrement dit, spécifiez la ligne la plus haute comme la ligne 0 et la colonne située le plus à gauche comme la colonne 0. La valeur maximale des index de ligne et de colonne est Int16.MaxValue.

Prise en charge de Unicode pour la console.

En général la console affiche l'entrée et écrit la sortie via la page de code de la console, que les paramètres régionaux du système définissent par défaut. Une page de codes peut gérer uniquement un sous-ensemble de caractères Unicode disponibles, si vous essayez d'afficher des caractères non mappés par une page de codes spécifique, la console ne pourra pas afficher tous les caractères et les représenter exactement. L'exemple suivant illustre ce problème. Il essaie d'afficher des caractères de l'alphabet cyrillique d'U+0410 à U+044F dans la console. Si vous exécutez l'exemple dans un système qui utilise la page de codes 437 de console, chaque caractère est remplacé par un point d'interrogation (?), car les caractères cyrilliques ne correspondent pas aux caractères de la page de codes 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
//    
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?


En plus des pages de codes de prise en charge, la classe Console prend en charge l'encodage UTF-8 avec la classe UTF8Encoding. À partir de la version 4.5 de .NET Framework, la classe Console prend également en charge l'encodage UTF-16 avec la classe UnicodeEncoding. Pour afficher des caractères Unicode dans la console. vous définissez la propriété OutputEncoding à la valeur UTF8Encoding ou UnicodeEncoding.

La prise en charge des caractères Unicode requiert que l'encodeur identifie un caractère Unicode particulier, et requiert également une police qui a besoin des glyphes pour afficher ce caractère. Pour afficher correctement les caractères Unicode dans la console, la police de console doit avoir une police non-raster ou TrueType telle que la console de Consolas ou de Lucida. L'exemple suivant montre comment modifier par programmation une police Raster 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];
   } 
}


Toutefois, les polices TrueType peuvent afficher uniquement un sous-ensemble de glyphes. Par exemple, la police Lucida Console affiche uniquement 643 % des environ 64.000 caractères disponibles de U+0021 à U+FB02. Pour consulter les caractères qu'une police particulière prend en charge, ouvrez l'applet Polices du Panneau de configuration, choisissez l'option Rechercher un caractère, puis sélectionnez la police dont le jeu de caractères que vous souhaitez examiner dans la liste Police de la fenêtre Table de caractères.

Windows utilise la liaison de police pour afficher les glyphes qui ne sont pas disponibles dans une police particulière. Pour plus d'informations sur la liaison de police pour afficher les jeux de caractères supplémentaires, voir Globalisation pas-à-pas : Les polices. Les polices liées sont définies dans la sous-clé d'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink du Registre. Chaque entrée associée à cette sous-clé correspond au nom d'une police de base, et sa valeur est un tableau de chaînes qui définit les fichiers de police et les polices liées à la police de base. Chaque membre du tableau définit une police liée et prend la forme police-fichier-nom,de police nom. L'exemple suivant montre comment vous pouvez définir une police liée nommée SimSun trouvée dans un fichier de police nommé simsun.ttc qui affiche les caractères simplifiés 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();
   }
}


Les limitations de la prise en charge Unicode de la console sont les suivantes :

  • L'encodage UTF-32 n'est pas pris en charge. Les seuls encodages Unicode pris en charge sont UTF-8 et UTF-16, représentés par les classes UTF8Encoding et UnicodeEncoding, respectivement.

  • La sortie bidirectionnelle n'est pas prise en charge.

  • L'affichage des caractères en dehors du plan multilingue de base (autrement dit, les paires de substitution) n'est pas pris en charge, même s'ils sont définis dans un fichier de police lié.

  • L'affichage des caractères dans les scripts complexes n'est pas pris en charge.

  • Les séquences de caractères d'association (autrement dit, les caractères qui se composent d'un caractère de base et d'un ou de plusieurs caractères d'association) sont affichées sous forme de caractères séparés. Pour contourner cette limitation, vous pouvez normaliser la chaîne à afficher en appelant la méthode String.Normalize avant d'envoyer la sortie dans la console. Dans l'exemple suivant, une chaîne contenant la séquence U+0061 U+0308 de caractères d'association est affichée dans la console comme deux caractères avant que la chaîne de sortie ne soit normalisée, ainsi qu'un caractère unique après que la méthode String.Normalize ne soit appelée.

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

    Notez que la normalisation est une solution valide uniquement si la norme Unicode pour le caractère inclut un formulaire pré-composé qui correspond à une séquence particulière de caractères d'association.

  • Si une police fournit un glyphe de point de code dans la zone privée d'utilisation, ce glyphe sera affiché. Toutefois, comme les caractères dans la zone privée d'application sont spécifiques à l'application, cela peut ne pas être le glyphe prévu.

L'exemple suivant affiche une plage de caractères Unicode dans la console. L'exemple accepte trois paramètres de ligne de commande : le début de la plage de s'afficher, en fin de la plage à afficher, et la possibilité d'utiliser l'encodage de la console (false) ou l'encodage UTF-16 (true). Cela suppose que la console utilise une police 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  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ


Opérations courantes

La classe Console contient les méthodes suivantes pour lire l'entrée de console et écrire la sortie.

  • Les surcharges de la méthode ReadKey lisent un caractère individuel.

  • La méthode ReadLine lit une ligne entière d'entrée.

  • Les surcharges de méthode Write convertissent une instance d'un type valeur, un tableau de caractères, ou un ensemble d'objets en une chaîne mise en forme ou non mise en forme, puis écrivent cette chaîne dans la console.

  • Un ensemble de surcharge de méthode de sortie WriteLine donne pour résultat la même chaîne que les surcharges Write mais ajoutent également une chaîne d'arrêt de ligne.

La classe Console contient également des méthodes et des propriétés pour effectuer les opérations suivantes :

  • Obtient ou définit la taille de la mémoire tampon d'écran. Les propriétés BufferHeight et BufferWidth vous permettent d'obtenir ou définir la hauteur et la largeur de mémoire tampon, respectivement, et la méthode SetBufferSize vous permet de définir la taille de mémoire tampon dans un appel de méthode.

  • Obtient ou définit la taille de la fenêtre de console. Les propriétés WindowHeight et WindowWidth vous permettent d'obtenir ou définir la hauteur et la largeur de la fenêtre, respectivement, et la méthode SetWindowSize vous permet de définir la taille de la fenêtre dans un appel de méthode.

  • Obtient ou définit la taille du curseur. La propriété CursorSize spécifie la hauteur du curseur dans une cellule de caractère.

  • Obtient ou définit la position de la fenêtre de console par rapport à la mémoire tampon d'écran. Les propriétés WindowTop et WindowLeft vous permettent d'obtenir ou de définir la ligne du haut et la colonne la plus à gauche de la mémoire tampon d'écran qui apparaît dans la fenêtre de console, et la méthode SetWindowPosition vous permet de définir ces valeurs dans un simple appel de la méthode.

  • Obtient ou définit la position du curseur en obtenant ou en définissant les propriétés CursorTop et CursorLeft, ou définit la position du curseur en appelant la méthode SetCursorPosition.

  • Déplacez ou désactivez les données dans la mémoire tampon d'écran en appelant la méthode MoveBufferArea ou la méthode Clear.

  • Obtient ou définit les couleurs de premier plan et d'arrière-plan à l'aide des propriétés ForegroundColor et BackgroundColor, ou réinitialisez l'arrière-plan et le premier plan à leur valeur par défaut couleurs en appelant la méthode ResetColor.

  • Lire le son d'un signal sonore par le haut-parleur de la console en appelant la méthode Beep.

L'exemple suivant montre comment lire des données, à partir des flux d'entrées standard et comment écrire des données dans des flux de sortie standards. Remarquez que ces flux peuvent être redirigés à l'aide des méthodes SetIn et 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

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

.NET pour les applications Windows Phone

Pris en charge dans : 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 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ce type est thread-safe.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft