Console Console Console Console Class

Définition

Représente les flux standard d'entrée, de sortie et d'erreur pour les applications console. Represents the standard input, output, and error streams for console applications. Cette classe ne peut pas être héritée. This class cannot be inherited.

public ref class Console abstract sealed
public static class Console
type Console = class
Public Class Console
Héritage
ConsoleConsoleConsoleConsole

Exemples

L’exemple suivant montre comment lire les données et écrire des données dans l’entrée standard et le flux de sortie.The following example demonstrates how to read data from, and write data to, the standard input and output streams. Notez que ces flux peuvent être redirigés à l’aide de la SetIn et SetOut méthodes.Note that these streams can be redirected by using the SetIn and SetOut methods.

using namespace System;

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

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

Remarques

La console est une fenêtre de système d’exploitation où les utilisateurs interagissent avec le système d’exploitation ou avec une application console basée sur le texte en entrant la saisie de texte via le clavier de l’ordinateur et en lisant la sortie de texte à partir du terminal de l’ordinateur.The console is an operating system window where users interact with the operating system or with a text-based console application by entering text input through the computer keyboard, and by reading text output from the computer terminal. Par exemple, dans le système d’exploitation Windows, la console est appelée à la fenêtre d’invite de commandes et accepte les commandes MS-DOS.For example, in the Windows operating system, the console is called the Command Prompt window and accepts MS-DOS commands. Le Console classe fournit la prise en charge de base pour les applications qui lisent et écrivent des caractères dans la console.The Console class provides basic support for applications that read characters from, and write characters to, the console.

Pour plus d’informations sur le développement avec le Console de classe, consultez les sections suivantes :For information about developing with the Console class, see the following sections:

Flux d’e/s de consoleConsole I/O Streams

Lorsqu’une application de console démarre, le système d’exploitation associe automatiquement trois flux d’e/s à la console : standard d’entrée de flux, les flux de sortie standard et les flux de sortie d’erreur standard.When a console application starts, the operating system automatically associates three I/O streams with the console: standard input stream, standard output stream, and standard error output stream. Votre application peut lire l’entrée d’utilisateur à partir du flux d’entrée standard ; écrire des données normales dans le flux de sortie standard ; et écrire des données de l’erreur dans le flux de sortie d’erreur standard.Your application can read user input from the standard input stream; write normal data to the standard output stream; and write error data to the standard error output stream. Ces flux sont présentés à votre application en tant que les valeurs de la Console.In, Console.Out, et Console.Error propriétés.These streams are presented to your application as the values of the Console.In, Console.Out, and Console.Error properties.

Par défaut, la valeur de la In propriété est un System.IO.TextReader objet qui représente le clavier et les valeurs de la Out et Error propriétés sont System.IO.TextWriter objets qui représentent une fenêtre de console.By default, the value of the In property is a System.IO.TextReader object that represents the keyboard, and the values of the Out and Error properties are System.IO.TextWriter objects that represent a console window. Toutefois, vous pouvez définir ces propriétés dans des flux qui ne représentent pas la fenêtre de console ou le clavier ; par exemple, vous pouvez définir ces propriétés dans des flux qui représentent des fichiers.However, you can set these properties to streams that do not represent the console window or keyboard; for example, you can set these properties to streams that represent files. Pour rediriger l’entrée standard, la sortie standard ou le flux d’erreur standard, appelez le Console.SetIn, Console.SetOut, ou Console.SetError (méthode), respectivement.To redirect the standard input, standard output, or standard error stream, call the Console.SetIn, Console.SetOut, or Console.SetError method, respectively. Opérations d’e/s qui utilisent ces flux sont synchronisées, ce qui signifie que plusieurs threads capable de lire, ou écrire dans les flux de données.I/O operations that use these streams are synchronized, which means that multiple threads can read from, or write to, the streams. Cela signifie que les méthodes qui sont habituellement asynchrones, tels que TextReader.ReadLineAsync, exécuter de façon synchrone si l’objet représente un flux de console.This means that methods that are ordinarily asynchronous, such as TextReader.ReadLineAsync, execute synchronously if the object represents a console stream.

Note

N’utilisez pas le Console classe pour afficher la sortie dans des applications sans assistance, telles que les applications de serveur.Do not use the Console class to display output in unattended applications, such as server applications. Appels aux méthodes telles que Console.Write et Console.WriteLine n’ont aucun effet dans les applications GUI.Calls to methods such as Console.Write and Console.WriteLine have no effect in GUI applications.

Console les membres de classe qui fonctionnent normalement lorsque le flux sous-jacent est dirigé vers une console peuvent lever une exception si le flux est redirigé, par exemple, dans un fichier.Console class members that work normally when the underlying stream is directed to a console might throw an exception if the stream is redirected, for example, to a file. Programmez votre application pour intercepter System.IO.IOException exceptions si vous redirigez un flux standard.Program your application to catch System.IO.IOException exceptions if you redirect a standard stream. Vous pouvez également utiliser le IsOutputRedirected, IsInputRedirected, et IsErrorRedirected propriétés pour déterminer si un flux standard est redirigé avant d’effectuer une opération qui lève une System.IO.IOException exception.You can also use the IsOutputRedirected, IsInputRedirected, and IsErrorRedirected properties to determine whether a standard stream is redirected before performing an operation that throws an System.IO.IOException exception.

Il est parfois utile d’appeler explicitement les membres des objets de flux de données représentés par le In, Out, et Error propriétés.It is sometimes useful to explicitly call the members of the stream objects represented by the In, Out, and Error properties. Par exemple, par défaut, le Console.ReadLine méthode lit l’entrée à partir du flux d’entrée standard.For example, by default, the Console.ReadLine method reads input from the standard input stream. De même, la Console.WriteLine méthode écrit des données dans le flux de sortie standard et les données sont suivies de la chaîne de terminaison de ligne par défaut, c'est-à-dire un retour chariot et saut de ligne (« \r\n »).Similarly, the Console.WriteLine method writes data to the standard output stream, and the data is followed by the default line termination string, which is a carriage return and line feed ("\r\n"). Toutefois, la Console classe ne fournit pas de méthode correspondante pour écrire des données dans le flux de sortie d’erreur standard, ou une propriété à modifier la chaîne de terminaison de ligne pour les données écrites dans ce flux.However, the Console class does not provide a corresponding method to write data to the standard error output stream, or a property to change the line termination string for data written to that stream.

Vous pouvez résoudre ce problème en définissant le TextWriter.NewLine propriété de la Out ou Error propriété à une autre chaîne de terminaison de ligne.You can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. Par exemple, l’instruction c# suivante définit la chaîne de terminaison de ligne pour le flux de sortie d’erreur standard à deux retour chariot et les séquences de saut de ligne :For example, the following C# statement sets the line termination string for the standard error output stream to two carriage return and line feed sequences:

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

Vous pouvez ensuite appeler explicitement la WriteLine méthode de l’objet de flux de sortie d’erreur, comme dans l’instruction c# suivante :You can then explicitly call the WriteLine method of the error output stream object, as in the following C# statement:

Console.Error.WriteLine();

Mémoire tampon d’écran et la fenêtre de ConsoleScreen Buffer and Console Window

Deux fonctionnalités étroitement liées de la console sont la mémoire tampon d’écran et la fenêtre de console.Two closely related features of the console are the screen buffer and the console window. Texte est réellement lues ou écrit dans des flux appartenant à la console, mais semble être lu ou écrit une zone détenue par la console de la mémoire tampon d’écran.Text is actually read from or written to streams owned by the console, but appear to be read from or written to an area owned by the console called the screen buffer. La mémoire tampon d’écran est un attribut de la console et est organisé comme une grille rectangulaire de lignes et colonnes où chaque intersection de la grille ou une cellule de caractère, peut contenir un caractère.The screen buffer is an attribute of the console, and is organized as a rectangular grid of rows and columns where each grid intersection, or character cell, can contain a character. Chaque caractère possède sa propre couleur de premier plan, et chaque cellule de caractère a sa propre couleur d’arrière-plan.Each character has its own foreground color, and each character cell has its own background color.

La mémoire tampon d’écran est affichée via une zone rectangulaire appelée la fenêtre de console.The screen buffer is viewed through a rectangular region called the console window. La fenêtre de console est un autre attribut de la console ; Il n’est pas la console elle-même, qui est une fenêtre de système d’exploitation.The console window is another attribute of the console; it is not the console itself, which is an operating system window. La fenêtre de console est organisée en lignes et colonnes est inférieur ou égal à 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 écran sous-jacente.The console window is arranged in rows and columns, is less than or equal to the size of the screen buffer, and can be moved to view different areas of the underlying screen buffer. Si la mémoire tampon d’écran est supérieure à la fenêtre de console, la console affiche automatiquement les barres de défilement afin de la fenêtre de console peut être repositionnée sur la zone de mémoire tampon d’écran.If the screen buffer is larger than the console window, the console automatically displays scroll bars so the console window can be repositioned over the screen buffer area.

Un curseur indique la position de mémoire tampon écran où texte est actuellement lue ou écrit.A cursor indicates the screen buffer position where text is currently read or written. Le curseur peut être masqué ou visibles, et sa hauteur peut être modifié.The cursor can be hidden or made visible, and its height can be changed. Si le curseur est visible, la position de fenêtre de console est automatiquement déplacée donc le curseur se trouve toujours dans la vue.If the cursor is visible, the console window position is moved automatically so the cursor is always in view.

L’origine des coordonnées de cellule de caractère dans la mémoire tampon d’écran est l’angle supérieur gauche, et les positions du curseur et de la fenêtre de console sont mesurées par rapport à cette origine.The origin for character cell coordinates in the screen buffer is the upper left corner, and the positions of the cursor and the console window are measured relative to that origin. Utilisez les index de base zéro pour spécifier les positions ; Autrement dit, spécifiez la ligne supérieure comme ligne 0 et la colonne à l’extrême gauche en tant que colonne 0.Use zero-based indexes to specify positions; that is, specify the topmost row as row 0, and the leftmost column as column 0. La valeur maximale pour les index de ligne et de colonne est Int16.MaxValue.The maximum value for the row and column indexes is Int16.MaxValue.

Prise en charge Unicode pour la ConsoleUnicode Support for the Console

En général, la console lit l’entrée et écrit la sortie à l’aide de la page de codes de console en cours, qui définit des paramètres régionaux du système par défaut.In general, the console reads input and writes output by using the current console code page, which the system locale defines by default. Une page de codes peut gérer uniquement un sous-ensemble de caractères Unicode disponibles, donc si vous essayez d’affichage des caractères qui ne sont pas mappés à une page de codes particulier, la console ne sont pas en mesure d’afficher tous les caractères ou de les représenter avec précision.A code page can handle only a subset of available Unicode characters, so if you try to display characters that are not mapped by a particular code page, the console won't be able to display all characters or represent them accurately. L'exemple de code suivant illustre ce problème.The following example illustrates this problem. Il essaie d’afficher les caractères de l’alphabet cyrillique de U + 0410 à U + 044F dans la console.It tries to display the characters of the Cyrillic alphabet from U+0410 to U+044F to the console. Si vous exécutez l’exemple sur un système qui utilise la page de codes 437, chaque caractère est remplacé par un point d’interrogation ( ?), étant donné que les caractères cyrilliques ne correspondent pas aux caractères dans la page de codes 437.If you run the example on a system that uses console code page 437, each character is replaced by a question mark (?), because Cyrillic characters do not map to the characters in code page 437.

using System;

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

La prise en charge des pages de codes, la Console classe prend en charge UTF-8 est un encodage avec la UTF8Encoding classe.In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. Commençant par le .NET Framework 4.5, le Console classe prend également en charge le codage UTF-16 le UnicodeEncoding classe.Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. Pour afficher les caractères Unicode dans la console.To display Unicode characters to the console. vous définissez le OutputEncoding propriété UTF8Encoding ou UnicodeEncoding.you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

Prise en charge des caractères Unicode requiert l’encodeur afin de reconnaître un caractère Unicode particulier et nécessite également une police qui a les glyphes nécessaires au rendu de ce caractère.Support for Unicode characters requires the encoder to recognize a particular Unicode character, and also requires a font that has the glyphs needed to render that character. Pour afficher correctement les caractères Unicode dans la console, vous devez définir la police de la console à un non raster ou d’une police TrueType comme Consolas ou Lucida Console.To successfully display Unicode characters to the console, the console font must be set to a non-raster or TrueType font such as Consolas or Lucida Console. L’exemple suivant montre comment vous pouvez modifier par programmation la police à partir d’une police raster Lucida Console.The following example shows how you can programmatically change the font from a raster font to Lucida Console.

using System;
using System.Runtime.InteropServices;

public class Example
{
   [DllImport("kernel32.dll", SetLastError = true)]
   static extern IntPtr GetStdHandle(int nStdHandle);

   [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
   static extern bool GetCurrentConsoleFontEx(
          IntPtr consoleOutput, 
          bool maximumWindow,
          ref CONSOLE_FONT_INFO_EX lpConsoleCurrentFontEx);
          
   [DllImport("kernel32.dll", SetLastError = true)]
   static extern bool SetCurrentConsoleFontEx(
          IntPtr consoleOutput, 
          bool maximumWindow,
          CONSOLE_FONT_INFO_EX consoleCurrentFontEx);
   
   private const int STD_OUTPUT_HANDLE = -11;
   private const int TMPF_TRUETYPE = 4;
   private const int LF_FACESIZE = 32;
   private static IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
   
   public static unsafe void Main()
   {
      string fontName = "Lucida Console";
      IntPtr hnd = GetStdHandle(STD_OUTPUT_HANDLE);
      if (hnd != INVALID_HANDLE_VALUE) {
         CONSOLE_FONT_INFO_EX info = new CONSOLE_FONT_INFO_EX();
         info.cbSize = (uint) Marshal.SizeOf(info);
         bool tt = false;
         // First determine whether there's already a TrueType font.
         if (GetCurrentConsoleFontEx(hnd, false, ref info)) {
            tt = (info.FontFamily & TMPF_TRUETYPE) == TMPF_TRUETYPE;
            if (tt) {
               Console.WriteLine("The console already is using a TrueType font.");
               return;
            }
            // Set console font to Lucida Console.
            CONSOLE_FONT_INFO_EX newInfo = new CONSOLE_FONT_INFO_EX();
            newInfo.cbSize = (uint) Marshal.SizeOf(newInfo);          
            newInfo.FontFamily = TMPF_TRUETYPE;
            IntPtr ptr = new IntPtr(newInfo.FaceName);
            Marshal.Copy(fontName.ToCharArray(), 0, ptr, fontName.Length);
            // Get some settings from current font.
            newInfo.dwFontSize = new COORD(info.dwFontSize.X, info.dwFontSize.Y);
            newInfo.FontWeight = info.FontWeight;
            SetCurrentConsoleFontEx(hnd, false, newInfo);
         }
      }    
    }
 
   [StructLayout(LayoutKind.Sequential)]
   internal struct COORD
   {
      internal short X;
      internal short Y;
      
      internal COORD(short x, short y)
      {
         X = x;
         Y = y;
      }
   }
 
   [StructLayout(LayoutKind.Sequential)]
   internal unsafe struct CONSOLE_FONT_INFO_EX 
   {
      internal uint cbSize;
      internal uint nFont;
      internal COORD dwFontSize;
      internal int FontFamily;
      internal int FontWeight;
      internal fixed char FaceName[LF_FACESIZE];
   } 
}
Imports System.Runtime.InteropServices

Public Module Example
   ' <DllImport("kernel32.dll", SetLastError = true)>
   Private Declare Function GetStdHandle Lib "Kernel32" (
                   nStdHandle As Integer) As IntPtr

   ' [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
   Private Declare Function GetCurrentConsoleFontEx Lib "Kernel32" ( 
                   consoleOutput As IntPtr, 
                   maximumWindow As Boolean,
                   ByRef lpConsoleCurrentFontEx As CONSOLE_FONT_INFO_EX) As Boolean
          
   ' [DllImport("kernel32.dll", SetLastError = true)]
   Private Declare Function SetCurrentConsoleFontEx Lib "Kernel32"(
                   consoleOutput As IntPtr, 
                   maximumWindow As Boolean,
                   consoleCurrentFontEx As CONSOLE_FONT_INFO_EX) As Boolean
   
   Private Const STD_OUTPUT_HANDLE As Integer = -11
   Private Const TMPF_TRUETYPE As Integer = 4
   Private Const LF_FACESIZE As Integer= 32
   Private INVALID_HANDLE_VALUE As IntPtr = New IntPtr(-1)
   
   Public Sub Main()
      Dim fontName As String = "Lucida Console"
      Dim hnd As IntPtr = GetStdHandle(STD_OUTPUT_HANDLE)
      If hnd <> INVALID_HANDLE_VALUE Then
         Dim info AS CONSOLE_FONT_INFO_EX = New CONSOLE_FONT_INFO_EX()
         info.cbSize = CUInt(Marshal.SizeOf(info))
         Dim tt As Boolean = False
         ' First determine whether there's already a TrueType font.
         If GetCurrentConsoleFontEx(hnd, False, info) Then
            tt = (info.FontFamily And TMPF_TRUETYPE) = TMPF_TRUETYPE
            If tt Then
               Console.WriteLine("The console already is using a TrueType font.")
               Return
            End If
            ' Set console font to Lucida Console.
            Dim newInfo As CONSOLE_FONT_INFO_EX = New CONSOLE_FONT_INFO_EX()
            newInfo.cbSize = CUInt(Marshal.SizeOf(newInfo))          
            newInfo.FontFamily = TMPF_TRUETYPE
            newInfo.FaceName = fontName
            ' Get some settings from current font.
            newInfo.dwFontSize = New COORD(info.dwFontSize.X, info.dwFontSize.Y)
            newInfo.FontWeight = info.FontWeight
            SetCurrentConsoleFontEx(hnd, False, newInfo)
         End If
      End If    
   End Sub
 
   <StructLayout(LayoutKind.Sequential)> Friend Structure COORD
      Friend X As Short
      Friend Y As Short
      
      Friend Sub New(x As Short, y As Short)
         Me.X = x
         Me.Y = y
      End Sub
   End Structure
 
   <StructLayout(LayoutKind.Sequential, CharSet := CharSet.Unicode)> Friend Structure CONSOLE_FONT_INFO_EX 
      Friend cbSize As UInteger
      Friend nFont As UInteger
      Friend dwFontSize As COORD
      Friend FontFamily As Integer
      Friend FontWeight As Integer
      <MarshalAs(UnmanagedType.ByValTStr, SizeConst := 32)> Friend FaceName As String
   End Structure 
End Module

Toutefois, les polices TrueType peuvent afficher uniquement un sous-ensemble de glyphes.However, TrueType fonts can display only a subset of glyphs. Par exemple, la police Lucida Console affiche uniquement les 643 de 64 000 caractères disponibles allant de U + 0021 à U + FB02.For example, the Lucida Console font displays only 643 of the approximately 64,000 available characters from U+0021 to U+FB02. Pour voir une police particulière des caractères qui prend en charge, ouvrez le polices applet du Panneau de configuration, choisissez la rechercher un caractère option et choisir la police des jeux de caractère dont vous souhaitez examiner dans le ** Police** liste de la table des caractères fenêtre.To see which characters a particular font supports, open the Fonts applet in Control Panel, choose the Find a character option, and choose the font whose character set you'd like to examine in the Font list of the Character Map window.

Windows utilise la liaison de polices pour afficher des glyphes qui ne sont pas disponibles dans une police particulière.Windows uses font linking to display glyphs that are not available in a particular font. Pour plus d’informations sur la police de liaison pour afficher les jeux de caractères supplémentaires, consultez globalisation pas à pas : polices.For information about font linking to display additional character sets, see Globalization Step-by-Step: Fonts. Polices liés sont définis dans la sous-clé HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink du Registre.Linked fonts are defined in the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink subkey of the registry. 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 polices et les polices qui sont liés à la police de base.Each entry associated with this subkey corresponds to the name of a base font, and its value is a string array that defines the font files and the fonts that are linked to the base font. Chaque membre du tableau définit une police liée et prend la forme nom de fichier de police,nom de la police.Each member of the array defines a linked font and takes the form font-file-name,font-name. L’exemple suivant illustre comment vous pouvez définir par programme une police liée nommée SimSun trouvé dans un fichier de police nommé simsun.ttc qui affiche les caractères Han simplifié.The following example illustrates how you can programmatically define a linked font named SimSun found in a font file named simsun.ttc that displays Simplified Han characters.

using Microsoft.Win32;
using System;

public class Example
{
   public static void Main()
   {
      string valueName = "Lucida Console";
      string newFont = "simsun.ttc,SimSun";
      string[] fonts = null;
      RegistryValueKind kind = 0; 
      bool toAdd;
      
      RegistryKey key = Registry.LocalMachine.OpenSubKey( 
                 @"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink", 
                 true);
      if (key == null) {
         Console.WriteLine("Font linking is not enabled.");
      }
      else {
         // Determine if the font is a base font.
         string[] names = key.GetValueNames();
         if (Array.Exists(names, s => s.Equals(valueName, 
                                      StringComparison.OrdinalIgnoreCase))) {
            // Get the value's type.
            kind = key.GetValueKind(valueName);

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

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

            key.SetValue(valueName, fonts, RegistryValueKind.MultiString);
            Console.WriteLine("SimSun added to the list of linked fonts.");
         }                     
      }
      
      if (key != null) key.Close();
   }
}
Imports Microsoft.Win32

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

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

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

Prise en charge Unicode pour la console présente les limitations suivantes :Unicode support for the console has the following limitations:

  • Encodage UTF-32 n’est pas pris en charge.UTF-32 encoding is not supported. La seule prise en charge d’Unicode encodages sont UTF-8 et UTF-16, qui sont représentées par le UTF8Encoding et UnicodeEncoding des classes, respectivement.The only supported Unicode encodings are UTF-8 and UTF-16, which are represented by the UTF8Encoding and UnicodeEncoding classes, respectively.

  • Sortie de bidirectionnel n’est pas pris en charge.Bidirectional output is not supported.

  • Affichage des caractères en dehors du plan multilingue de base (autrement dit, des paires de substitution) n’est pas compatible, même si elles sont définies dans un fichier de polices lié.Display of characters outside the Basic Multilingual Plane (that is, of surrogate pairs) is not supported, even if they are defined in a linked font file.

  • Affichage des caractères dans les scripts complexes n’est pas pris en charge.Display of characters in complex scripts is not supported.

  • Combinant les séquences de caractères (autrement dit, les caractères qui se composent d’un caractère de base et un ou plusieurs caractères d’association) sont affichés sous forme de caractères distincts.Combining character sequences (that is, characters that consist of a base character and one or more combining characters) are displayed as separate characters. Pour contourner cette limitation, vous pouvez normaliser la chaîne à afficher en appelant le String.Normalize méthode avant d’envoyer la sortie à la console.To work around this limitation, you can normalize the string to be displayed by calling the String.Normalize method before sending output to the console. Dans l’exemple suivant, une chaîne qui contient le caractère de la combinaison de séquence U + 0061 U + 0308 s’affiche sur la console comme deux caractères avant la chaîne de sortie est normalisée et comme un caractère unique après le String.Normalize méthode est appelée.In the following example, a string that contains the combining character sequence U+0061 U+0308 is displayed to the console as two characters before the output string is normalized, and as a single character after the String.Normalize method is called.

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

    Notez que la normalisation est une solution viable que si la séquence de caractères Unicode standard pour le caractère inclut un formulaire préalable composé qui correspond à un particulier combining.Note that normalization is a viable solution only if the Unicode standard for the character includes a pre-composed form that corresponds to a particular combining character sequence.

  • Si une police fournit un glyphe pour un point de code dans la zone d’utilisation privée, ce glyphe s’affiche.If a font provides a glyph for a code point in the private use area, that glyph will be displayed. Toutefois, étant donné que les caractères dans la zone d’utilisation privée sont spécifiques à l’application, cela peut être pas le glyphe attendu.However, because characters in the private use area are application-specific, this may not be the expected glyph.

L’exemple suivant affiche une plage de caractères Unicode dans la console.The following example displays a range of Unicode characters to the console. L’exemple accepte trois paramètres de ligne de commande : le début de la plage à afficher, à la fin de la plage à afficher et s’il faut utiliser l’encodage de console actuel (false) ou de l’encodage UTF-16 (true).The example accepts three command-line parameters: the start of the range to display, the end of the range to display, and whether to use the current console encoding (false) or UTF-16 encoding (true). Il suppose que la console utilise une police TrueType.It assumes that the console is using a TrueType font.

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

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

   	try
   	{
         switch(args.Length)
         {
            case 2:
               rangeStart = uint.Parse(args[0], NumberStyles.HexNumber);
               rangeEnd = uint.Parse(args[1], NumberStyles.HexNumber);
               setOutputEncodingToUnicode = true;
               break;
            case 3:
               if (! uint.TryParse(args[0], NumberStyles.HexNumber, null, out rangeStart))
                  throw new ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args[0]));
               
               if (!uint.TryParse(args[1], NumberStyles.HexNumber, null, out rangeEnd))
                  throw new ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args[1]));
               
               bool.TryParse(args[2], out setOutputEncodingToUnicode);
               break;
            default:
               Console.WriteLine("Usage: {0} <{1}> <{2}> [{3}]", 
                                 Environment.GetCommandLineArgs()[0], 
                                 "startingCodePointInHex", 
                                 "endingCodePointInHex", 
                                 "<setOutputEncodingToUnicode?{true|false, default:false}>");
               return;
         }
   
         if (setOutputEncodingToUnicode) {
            // This won't work before .NET Framework 4.5.
            try {
               // Set encoding using endianness of this system.
               // We're interested in displaying individual Char objects, so 
               // we don't want a Unicode BOM or exceptions to be thrown on
               // invalid Char values.
               Console.OutputEncoding = new UnicodeEncoding(! BitConverter.IsLittleEndian, false); 
               Console.WriteLine("\nOutput encoding set to UTF-16");
            }
            catch (IOException) {
               Console.OutputEncoding = new UTF8Encoding();
               Console.WriteLine("Output encoding set to UTF-8");
            }
         }
         else {
            Console.WriteLine("The console encoding is {0} (code page {1})", 
                              Console.OutputEncoding.EncodingName,
                              Console.OutputEncoding.CodePage);
         }
         DisplayRange(rangeStart, rangeEnd);
      }
      catch (ArgumentException ex) {
         Console.WriteLine(ex.Message);
      }
      finally {
         // Restore console environment.
         Console.OutputEncoding = originalOutputEncoding;
      }
   }

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

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

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

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

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

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

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

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

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

Opérations courantesCommon Operations

Le Console classe contient les méthodes suivantes pour l’entrée de la console de lecture et écriture de la sortie de console :The Console class contains the following methods for reading console input and writing console output:

  • Les surcharges de la ReadKey méthode lire un caractère individuel.The overloads of the ReadKey method read an individual character.

  • Le ReadLine méthode lit une ligne d’entrée entière.The ReadLine method reads an entire line of input.

  • Le Write surcharges de méthode convertir 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 mis en forme, puis écrire cette chaîne dans la console.The Write method overloads convert an instance of a value type, an array of characters, or a set of objects to a formatted or unformatted string, and then write that string to the console.

  • Un parallèle ensemble de WriteLine sortie de la même chaîne comme des surcharges de méthode le Write surcharges mais également ajouter une chaîne de terminaison de ligne.A parallel set of WriteLine method overloads output the same string as the Write overloads but also add a line termination string.

Le Console classe contient également des méthodes et propriétés pour effectuer les opérations suivantes :The Console class also contains methods and properties to perform the following operations:

  • Obtient ou définit la taille de la mémoire tampon d’écran.Get or set the size of the screen buffer. Le BufferHeight et BufferWidth propriétés vous permettent d’obtenir ou définir la hauteur de la mémoire tampon et la largeur, respectivement et le SetBufferSize méthode vous permet de définir la taille de mémoire tampon dans un seul appel de méthode.The BufferHeight and BufferWidth properties let you get or set the buffer height and width, respectively, and the SetBufferSize method lets you set the buffer size in a single method call.

  • Obtient ou définit la taille de la fenêtre de console.Get or set the size of the console window. Le WindowHeight et WindowWidth propriétés vous permettent d’obtenir ou définir la hauteur de la fenêtre et la largeur, respectivement et le SetWindowSize méthode vous permet de définir la taille de fenêtre dans un seul appel de méthode.The WindowHeight and WindowWidth properties let you get or set the window height and width, respectively, and the SetWindowSize method lets you set the window size in a single method call.

  • Obtient ou définit la taille du curseur.Get or set the size of the cursor. Le CursorSize propriété spécifie la hauteur du curseur dans une cellule de caractère.The CursorSize property specifies the height of the cursor in a character cell.

  • Obtient ou définit la position de la fenêtre de console par rapport à la mémoire tampon d’écran.Get or set the position of the console window relative to the screen buffer. Le WindowTop et WindowLeft propriétés vous permettent d’obtenir ou définir la ligne du haut et la colonne de gauche de la mémoire tampon d’écran qui s’affiche dans la fenêtre de console, et le SetWindowPosition méthode vous permet de définir ces valeurs dans un seul appel de méthode.The WindowTop and WindowLeft properties let you get or set the top row and leftmost column of the screen buffer that appears in the console window, and the SetWindowPosition method lets you set these values in a single method call.

  • Obtenir ou définir la position du curseur en bien ou en définissant le CursorTop et CursorLeft propriétés, ou définir la position du curseur en appelant le SetCursorPosition (méthode).Get or set the position of the cursor by getting or setting the CursorTop and CursorLeft properties, or set the position of the cursor by calling the SetCursorPosition method.

  • Déplacer ou supprimer des données dans la mémoire tampon d’écran en appelant le MoveBufferArea ou Clear (méthode).Move or clear data in the screen buffer by calling the MoveBufferArea or Clear method.

  • Obtenir ou définir les couleurs de premier plan et d’arrière-plan à l’aide de la ForegroundColor et BackgroundColor propriétés, ou de réinitialiser l’arrière-plan et premier plan pour leurs couleurs par défaut en appelant le ResetColor (méthode).Get or set the foreground and background colors by using the ForegroundColor and BackgroundColor properties, or reset the background and foreground to their default colors by calling the ResetColor method.

  • Lire le son d’un signal sonore via le haut-parleur de la console en appelant le Beep (méthode).Play the sound of a beep through the console speaker by calling the Beep method.

.NET Core.NET Core Notes de publication Notes

Dans le .NET Framework sur le bureau, le Console classe utilise l’encodage retourné par GetConsoleCP et GetConsoleOutputCP, ce qui en général, est une page de codes d’encodage.In the .NET Framework on the desktop, the Console class uses the encoding returned by GetConsoleCP and GetConsoleOutputCP, which typically is a code page encoding. Par exemple le code, sur les systèmes dont la culture est anglais (États-Unis), page de codes 437 est l’encodage qui est utilisé par défaut.For example code, on systems whose culture is English (United States), code page 437 is the encoding that is used by default. Toutefois, .NET Core.NET Core peut effectuer uniquement un sous-ensemble limité de ces encodages disponibles.However, .NET Core.NET Core may make only a limited subset of these encodings available. Dans ce cas, Encoding.UTF8 est utilisé en tant que l’encodage par défaut pour la console.Where this is the case, Encoding.UTF8 is used as the default encoding for the console.

Si votre application dépend des codages de page de codes spécifique, vous pouvez toujours les rendre disponibles en procédant comme suit avant vous appeler les Console méthodes :If your app depends on specific code page encodings, you can still make them available by doing the following before you call any Console methods:

  1. Ajoutez une référence à l’assembly System.Text.Encoding.CodePages.dll à votre projet.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Récupérer le EncodingProvider de l’objet à partir de la CodePagesEncodingProvider.Instance propriété.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Passer le EncodingProvider de l’objet à la Encoding.RegisterProvider méthode permettant d’apporter les autres encodages pris en charge par le fournisseur d’encodage disponible.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

Le Console classe puis utilisent automatiquement l’encodage du système par défaut au lieu d’UTF-8, sous réserve que vous avez enregistré le fournisseur d’encodage avant d’appeler une Console méthodes de sortie.The Console class will then automatically use the default system encoding rather than UTF8, provided that you have registered the encoding provider before calling any Console output methods.

Propriétés

BackgroundColor BackgroundColor BackgroundColor BackgroundColor

Obtient ou définit la couleur d'arrière-plan de la console. Gets or sets the background color of the console.

BufferHeight BufferHeight BufferHeight BufferHeight

Obtient ou définit la hauteur de la zone de mémoire tampon. Gets or sets the height of the buffer area.

BufferWidth BufferWidth BufferWidth BufferWidth

Obtient ou définit la largeur de la zone de mémoire tampon. Gets or sets the width of the buffer area.

CapsLock CapsLock CapsLock CapsLock

Obtient une valeur indiquant si la bascule de la touche VERR. MAJ est activée ou désactivée. Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft CursorLeft CursorLeft CursorLeft

Obtient ou définit la position de colonne du curseur dans la zone de mémoire tampon. Gets or sets the column position of the cursor within the buffer area.

CursorSize CursorSize CursorSize CursorSize

Obtient ou définit la hauteur du curseur dans une cellule de caractère. Gets or sets the height of the cursor within a character cell.

CursorTop CursorTop CursorTop CursorTop

Obtient ou définit la position de ligne du curseur dans la zone de mémoire tampon. Gets or sets the row position of the cursor within the buffer area.

CursorVisible CursorVisible CursorVisible CursorVisible

Obtient ou définit une valeur indiquant si le curseur est visible. Gets or sets a value indicating whether the cursor is visible.

Error Error Error Error

Obtient le flux de sortie d'erreur standard. Gets the standard error output stream.

ForegroundColor ForegroundColor ForegroundColor ForegroundColor

Obtient ou définit la couleur de premier plan de la console. Gets or sets the foreground color of the console.

In In In In

Obtient le flux d'entrée standard. Gets the standard input stream.

InputEncoding InputEncoding InputEncoding InputEncoding

Obtient ou définit l'encodage que la console utilise pour lire l'entrée. Gets or sets the encoding the console uses to read input.

IsErrorRedirected IsErrorRedirected IsErrorRedirected IsErrorRedirected

Obtient une valeur qui indique si le flux de sortie d'erreur a été redirigé à partir du flux d'erreur standard. Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected IsInputRedirected IsInputRedirected IsInputRedirected

Obtient une valeur qui indique si l'entrée a été redirigée à partir du flux d'entrée standard. Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected IsOutputRedirected IsOutputRedirected IsOutputRedirected

Obtient une valeur qui indique si la sortie a été redirigée à partir du flux de sortie standard. Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable KeyAvailable KeyAvailable KeyAvailable

Obtient une valeur indiquant si l'appui sur une touche est disponible dans le flux d'entrée. Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight LargestWindowHeight LargestWindowHeight LargestWindowHeight

Obtient le plus grand nombre possible de lignes de fenêtre de console, selon la police et la résolution d’écran actuelles. Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth LargestWindowWidth LargestWindowWidth LargestWindowWidth

Obtient le plus grand nombre possible de colonnes de fenêtre de console, selon la police et la résolution d’écran actuelles. Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock NumberLock NumberLock NumberLock

Obtient une valeur indiquant si la bascule de la touche VERR. NUM est activée ou désactivée. Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out Out Out Out

Obtient le flux de sortie standard. Gets the standard output stream.

OutputEncoding OutputEncoding OutputEncoding OutputEncoding

Obtient ou définit l'encodage que la console utilise pour écrire la sortie. Gets or sets the encoding the console uses to write output.

Title Title Title Title

Obtient ou définit le titre à afficher dans la barre de titre de la console. Gets or sets the title to display in the console title bar.

TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput

Obtient 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. Gets or sets a value indicating whether the combination of the Control modifier key and C console key (Ctrl+C) is treated as ordinary input or as an interruption that is handled by the operating system.

WindowHeight WindowHeight WindowHeight WindowHeight

Obtient ou définit la hauteur de la zone de la fenêtre de console. Gets or sets the height of the console window area.

WindowLeft WindowLeft WindowLeft WindowLeft

Obtient ou définit la position la plus à gauche de la zone de la fenêtre de console par rapport à la mémoire tampon d'écran. Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop WindowTop WindowTop WindowTop

Obtient ou définit la position supérieure de la zone de la fenêtre de console par rapport à la mémoire tampon d'écran. Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth WindowWidth WindowWidth WindowWidth

Obtient ou définit la largeur de la fenêtre de console. Gets or sets the width of the console window.

Méthodes

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

Lit le son d'un signal sonore via le haut-parleur de la console. Plays the sound of a beep through the console speaker.

Beep(Int32, Int32) Beep(Int32, Int32) Beep(Int32, Int32) Beep(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. Plays the sound of a beep of a specified frequency and duration through the console speaker.

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

Efface la mémoire tampon et la fenêtre correspondante de la console contenant les informations d'affichage. Clears the console buffer and corresponding console window of display information.

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

Copie une zone source spécifiée de la mémoire tampon d'écran dans une zone de destination spécifiée. Copies a specified source area of the screen buffer to a specified destination area.

MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor) MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor) MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor) MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor)

Copie une zone source spécifiée de la mémoire tampon d'écran dans une zone de destination spécifiée. Copies a specified source area of the screen buffer to a specified destination area.

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

Acquiert le flux d'erreur standard. Acquires the standard error stream.

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

Acquiert le flux d'erreur standard, défini sur une taille de mémoire tampon spécifiée. Acquires the standard error stream, which is set to a specified buffer size.

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

Acquiert le flux d'entrée standard. Acquires the standard input stream.

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

Acquiert le flux d'entrée standard, défini sur une taille de mémoire tampon spécifiée. Acquires the standard input stream, which is set to a specified buffer size.

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

Acquiert le flux de sortie standard. Acquires the standard output stream.

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

Acquiert le flux de sortie standard, défini sur une taille de mémoire tampon spécifiée. Acquires the standard output stream, which is set to a specified buffer size.

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

Lit le caractère suivant du flux d'entrée standard. Reads the next character from the standard input stream.

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

Obtient le caractère suivant ou la touche de fonction sur laquelle l'utilisateur a appuyé. Obtains the next character or function key pressed by the user. La touche enfoncée s'affiche dans la fenêtre de console. The pressed key is displayed in the console window.

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

Obtient le caractère suivant ou la touche de fonction sur laquelle l'utilisateur a appuyé. Obtains the next character or function key pressed by the user. La touche enfoncée s'affiche éventuellement dans la fenêtre de console. The pressed key is optionally displayed in the console window.

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

Lit la ligne de caractères suivante du flux d'entrée standard. Reads the next line of characters from the standard input stream.

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

Définit les couleurs de premier plan et d'arrière-plan de la console sur leurs valeurs par défaut. Sets the foreground and background console colors to their defaults.

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

Définit la hauteur et la largeur de la zone de mémoire tampon d'écran sur les valeurs spécifiées. Sets the height and width of the screen buffer area to the specified values.

SetCursorPosition(Int32, Int32) SetCursorPosition(Int32, Int32) SetCursorPosition(Int32, Int32) SetCursorPosition(Int32, Int32)

Définit la position du curseur. Sets the position of the cursor.

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

Définit la propriété Error avec l'objet TextWriter spécifié. Sets the Error property to the specified TextWriter object.

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

Définit la propriété In avec l'objet TextReader spécifié. Sets the In property to the specified TextReader object.

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

Définit la propriété Out avec l'objet TextWriter spécifié. Sets the Out property to the specified TextWriter object.

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

Définit la position de la fenêtre de console par rapport à la mémoire tampon d'écran. Sets the position of the console window relative to the screen buffer.

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

Définit la hauteur et la largeur de la fenêtre de console sur les valeurs spécifiées. Sets the height and width of the console window to the specified values.

Write(String, Object, Object, Object, Object) Write(String, Object, Object, Object, Object) Write(String, Object, Object, Object, Object) Write(String, Object, Object, Object, Object)

Écrit la représentation textuelle des objets spécifiés et la liste des paramètres de longueur variable dans le flux de sortie standard à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified objects and variable-length parameter list to the standard output stream using the specified format information.

Write(String, Object, Object, Object) Write(String, Object, Object, Object) Write(String, Object, Object, Object) Write(String, Object, Object, Object)

Écrit la représentation textuelle des objets spécifiés dans le flux de sortie standard à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified objects to the standard output stream using the specified format information.

Write(String, Object, Object) Write(String, Object, Object) Write(String, Object, Object) Write(String, Object, Object)

Écrit la représentation textuelle des objets spécifiés dans le flux de sortie standard à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified objects to the standard output stream using the specified format information.

Write(String, Object[]) Write(String, Object[]) Write(String, Object[]) Write(String, Object[])

Écrit la représentation textuelle du tableau d'objets spécifiés dans le flux de sortie standard à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified array of objects to the standard output stream using the specified format information.

Write(String, Object) Write(String, Object) Write(String, Object) Write(String, Object)

Écrit la représentation textuelle de l'objet spécifié dans le flux de sortie standard à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified object to the standard output stream using the specified format information.

Write(UInt64) Write(UInt64) Write(UInt64) Write(UInt64)

Écrit la représentation textuelle de la valeur entière non signée 64 bits spécifiée dans le flux de sortie standard. Writes the text representation of the specified 64-bit unsigned integer value to the standard output stream.

Write(UInt32) Write(UInt32) Write(UInt32) Write(UInt32)

Écrit la représentation textuelle de la valeur entière non signée 32 bits spécifiée dans le flux de sortie standard. Writes the text representation of the specified 32-bit unsigned integer value to the standard output stream.

Write(String) Write(String) Write(String) Write(String)

Écrit la valeur de chaîne spécifiée dans le flux de sortie standard. Writes the specified string value to the standard output stream.

Write(Char[], Int32, Int32) Write(Char[], Int32, Int32) Write(Char[], Int32, Int32) Write(Char[], Int32, Int32)

Écrit le sous-tableau de caractères Unicode spécifié dans le flux de sortie standard. Writes the specified subarray of Unicode characters to the standard output stream.

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

Écrit la représentation textuelle de l'objet spécifié dans le flux de sortie standard. Writes the text representation of the specified object to the standard output stream.

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

Écrit la représentation textuelle de la valeur à virgule flottante simple précision spécifiée dans le flux de sortie standard. Writes the text representation of the specified single-precision floating-point value to the standard output stream.

Write(Char) Write(Char) Write(Char) Write(Char)

Écrit la valeur du caractère Unicode spécifiée dans le flux de sortie standard. Writes the specified Unicode character value to the standard output stream.

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

Écrit le tableau de caractères Unicode spécifié dans le flux de sortie standard. Writes the specified array of Unicode characters to the standard output stream.

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

Écrit la représentation textuelle de la valeur booléenne spécifiée dans le flux de sortie standard. Writes the text representation of the specified Boolean value to the standard output stream.

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

Écrit la représentation textuelle de la valeur à virgule flottante double précision spécifiée dans le flux de sortie standard. Writes the text representation of the specified double-precision floating-point value to the standard output stream.

Write(Int32) Write(Int32) Write(Int32) Write(Int32)

Écrit la représentation textuelle de la valeur entière signée 32 bits spécifiée dans le flux de sortie standard. Writes the text representation of the specified 32-bit signed integer value to the standard output stream.

Write(Int64) Write(Int64) Write(Int64) Write(Int64)

Écrit la représentation textuelle de la valeur entière signée 64 bits spécifiée dans le flux de sortie standard. Writes the text representation of the specified 64-bit signed integer value to the standard output stream.

Write(Decimal) Write(Decimal) Write(Decimal) Write(Decimal)

Écrit la représentation textuelle de la valeur Decimal spécifiée dans le flux de sortie standard. Writes the text representation of the specified Decimal value to the standard output stream.

WriteLine(String, Object, Object) WriteLine(String, Object, Object) WriteLine(String, Object, Object) WriteLine(String, Object, Object)

Écrit la représentation textuelle des objets spécifiés suivie du terminateur de la ligne active dans le flux de sortie standard, à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(String) WriteLine(String) WriteLine(String) WriteLine(String)

Écrit la valeur de chaîne spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the specified string value, followed by the current line terminator, to the standard output stream.

WriteLine(Char[], Int32, Int32) WriteLine(Char[], Int32, Int32) WriteLine(Char[], Int32, Int32) WriteLine(Char[], Int32, Int32)

Écrit le sous-tableau de caractères Unicode spécifié suivi du terminateur de la ligne active dans le flux de sortie standard. Writes the specified subarray of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(String, Object[]) WriteLine(String, Object[]) WriteLine(String, Object[]) WriteLine(String, Object[])

Écrit la représentation textuelle du tableau d'objets spécifié suivie du terminateur de la ligne active dans le flux de sortie standard, à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified array of objects, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(String, Object) WriteLine(String, Object) WriteLine(String, Object) WriteLine(String, Object)

Écrit la représentation textuelle de l'objet spécifié suivie du terminateur de la ligne active dans le flux de sortie standard, à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(UInt64) WriteLine(UInt64) WriteLine(UInt64) WriteLine(UInt64)

Écrit la représentation textuelle de la valeur entière non signée 64 bits spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified 64-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

WriteLine(UInt32) WriteLine(UInt32) WriteLine(UInt32) WriteLine(UInt32)

Écrit la représentation textuelle de la valeur entière non signée 32 bits spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified 32-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Single) WriteLine(Single) WriteLine(Single) WriteLine(Single)

Écrit la représentation textuelle de la valeur à virgule flottante simple précision spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified single-precision floating-point value, followed by the current line terminator, to the standard output stream.

WriteLine(Decimal) WriteLine(Decimal) WriteLine(Decimal) WriteLine(Decimal)

Écrit la représentation textuelle de la valeur Decimal spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified Decimal value, followed by the current line terminator, to the standard output stream.

WriteLine(Int64) WriteLine(Int64) WriteLine(Int64) WriteLine(Int64)

Écrit la représentation textuelle de la valeur entière signée 64 bits spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified 64-bit signed integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Int32) WriteLine(Int32) WriteLine(Int32) WriteLine(Int32)

Écrit la représentation textuelle de la valeur entière signée 32 bits spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified 32-bit signed integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Double) WriteLine(Double) WriteLine(Double) WriteLine(Double)

Écrit la représentation textuelle de la valeur à virgule flottante double précision spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified double-precision floating-point value, followed by the current line terminator, to the standard output stream.

WriteLine(Char[]) WriteLine(Char[]) WriteLine(Char[]) WriteLine(Char[])

Écrit le tableau de caractères Unicode spécifié suivi du terminateur de la ligne active dans le flux de sortie standard. Writes the specified array of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(Char) WriteLine(Char) WriteLine(Char) WriteLine(Char)

Écrit la valeur du caractère Unicode spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the specified Unicode character, followed by the current line terminator, value to the standard output stream.

WriteLine(Boolean) WriteLine(Boolean) WriteLine(Boolean) WriteLine(Boolean)

Écrit la représentation textuelle de la valeur booléenne spécifiée suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

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

Écrit le terminateur de la ligne active dans le flux de sortie standard. Writes the current line terminator to the standard output stream.

WriteLine(String, Object, Object, Object) WriteLine(String, Object, Object, Object) WriteLine(String, Object, Object, Object) WriteLine(String, Object, Object, Object)

Écrit la représentation textuelle des objets spécifiés suivie du terminateur de la ligne active dans le flux de sortie standard, à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.

WriteLine(Object) WriteLine(Object) WriteLine(Object) WriteLine(Object)

Écrit la représentation textuelle de l'objet spécifié suivie du terminateur de la ligne active dans le flux de sortie standard. Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream.

WriteLine(String, Object, Object, Object, Object) WriteLine(String, Object, Object, Object, Object) WriteLine(String, Object, Object, Object, Object) WriteLine(String, Object, Object, Object, Object)

Écrit la représentation textuelle des objets spécifiés et la liste des paramètres de longueur variable suivies du terminateur de la ligne active dans le flux de sortie standard, à l'aide des informations de mise en forme spécifiées. Writes the text representation of the specified objects and variable-length parameter list, followed by the current line terminator, to the standard output stream using the specified format information.

Événements

CancelKeyPress CancelKeyPress CancelKeyPress CancelKeyPress

Se produit quand la touche de modification (Ctrl) Control et la touche de console (C) C ou la touche d'arrêt sont utilisées simultanément (Ctrl+C ou Ctrl+Pause). Occurs when the Control modifier key (Ctrl) and either the C console key (C) or the Break key are pressed simultaneously (Ctrl+C or Ctrl+Break).

S’applique à

Cohérence de thread

Ce type est thread-safe. This type is thread safe.