Console Console Console Console Class

Definizione

Rappresenta i flussi di input, output e di errore standard per le applicazioni console.Represents the standard input, output, and error streams for console applications. Questa classe non può essere ereditata.This class cannot be inherited.

public ref class Console abstract sealed
public static class Console
type Console = class
Public Class Console
Ereditarietà
ConsoleConsoleConsoleConsole

Esempi

Nell'esempio seguente viene illustrato come leggere i dati da e scrivere dati, i flussi di output e input standard.The following example demonstrates how to read data from, and write data to, the standard input and output streams. Si noti che questi flussi possono essere reindirizzati utilizzando il SetIn e SetOut metodi.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!

Commenti

La console è una finestra del sistema operativo in cui gli utenti interagiscono con il sistema operativo o con un'applicazione console basata su testo tramite l'immissione di input di testo tramite la tastiera del computer e leggendo l'output di testo dal terminale del computer.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. Ad esempio, nel sistema operativo Windows, la console viene chiamata il prompt dei comandi e accetta i comandi di MS-DOS.For example, in the Windows operating system, the console is called the Command Prompt window and accepts MS-DOS commands. Il Console classe fornisce il supporto di base per le applicazioni che leggono i caratteri da e scrivono caratteri, nella console.The Console class provides basic support for applications that read characters from, and write characters to, the console.

Per informazioni sullo sviluppo con il Console di classi, vedere le sezioni seguenti:For information about developing with the Console class, see the following sections:

Flussi dei / o consoleConsole I/O Streams

Quando viene avviata un'applicazione console, il sistema operativo associa automaticamente tre flussi i/o con la console: standard input stream, flusso di output standard e il flusso di output di errore 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. L'applicazione può leggere l'input dell'utente dal flusso di input standard; scrivere dati normali nel flusso di output standard. e scrivere i dati di errore al flusso di output degli errori 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. I flussi vengono passati all'applicazione come valori del Console.In, Console.Out, e Console.Error proprietà.These streams are presented to your application as the values of the Console.In, Console.Out, and Console.Error properties.

Per impostazione predefinita, il valore del In proprietà è una System.IO.TextReader che rappresenta la tastiera e i valori del Out e Error sono proprietà System.IO.TextWriter gli oggetti che rappresentano una finestra della 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. Tuttavia, è possibile impostare queste proprietà ai flussi che non rappresentano la finestra della console o della tastiera; ad esempio, è possibile impostare queste proprietà ai flussi che rappresentano i file.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. Per reindirizzare l'input standard, l'output standard o flusso errore standard, chiamare il Console.SetIn, Console.SetOut, o Console.SetError metodo, rispettivamente.To redirect the standard input, standard output, or standard error stream, call the Console.SetIn, Console.SetOut, or Console.SetError method, respectively. Operazioni dei / o che usano questi flussi sono sincronizzate, il che significa che più thread possono leggere o scrivere, i flussi.I/O operations that use these streams are synchronized, which means that multiple threads can read from, or write to, the streams. Ciò significa che i metodi che sono in genere asincroni, ad esempio TextReader.ReadLineAsync, eseguire in modo sincrono se l'oggetto rappresenta un flusso di console.This means that methods that are ordinarily asynchronous, such as TextReader.ReadLineAsync, execute synchronously if the object represents a console stream.

Nota

Non usare il Console classe per visualizzare l'output in applicazioni automatiche, ad esempio le applicazioni server.Do not use the Console class to display output in unattended applications, such as server applications. Le chiamate a metodi quali Console.Write e Console.WriteLine non hanno alcun effetto in applicazioni GUI.Calls to methods such as Console.Write and Console.WriteLine have no effect in GUI applications.

Console membri di classi che funzionano normalmente durante il flusso sottostante viene indirizzato a una console potrebbero generare un'eccezione se il flusso viene reindirizzato, ad esempio, in un file.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. Programma l'applicazione per rilevare System.IO.IOException eccezioni se si reindirizza un flusso standard.Program your application to catch System.IO.IOException exceptions if you redirect a standard stream. È anche possibile usare la IsOutputRedirected, IsInputRedirected, e IsErrorRedirected delle proprietà per determinare se un flusso standard viene reindirizzato prima di eseguire un'operazione che genera un System.IO.IOException eccezione.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.

È talvolta utile chiamare in modo esplicito i membri degli oggetti flusso rappresentati dal In, Out, e Error proprietà.It is sometimes useful to explicitly call the members of the stream objects represented by the In, Out, and Error properties. Ad esempio, per impostazione predefinita, il Console.ReadLine metodo legge l'input del flusso di input standard.For example, by default, the Console.ReadLine method reads input from the standard input stream. Analogamente, il Console.WriteLine metodo scrive i dati nel flusso di output standard e i dati sono seguiti dalla stringa di terminazione riga predefinita, ovvero un ritorno a capo e avanzamento riga ("\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"). Tuttavia, il Console classe non fornisce un metodo corrispondente per la scrittura dei dati per il flusso di output di errore standard o una proprietà per modificare la stringa di terminazione di riga per i dati scritti in tale flusso.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.

È possibile risolvere questo problema impostando il TextWriter.NewLine proprietà del Out o Error proprietà in un'altra stringa di terminazione di riga.You can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. L'istruzione c# riportata di seguito, ad esempio, imposta la stringa di terminazione di riga per il flusso di output degli errori standard a due ritorno a capo e avanzamento delle sequenze di riga: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";

È quindi possibile chiamare in modo esplicito il WriteLine metodo per l'oggetto flusso di output di errore, come l'istruzione c# riportata di seguito:You can then explicitly call the WriteLine method of the error output stream object, as in the following C# statement:

Console.Error.WriteLine();

Buffer dello schermo e finestra della ConsoleScreen Buffer and Console Window

Due funzionalità strettamente correlate della console sono buffer dello schermo e la finestra della console.Two closely related features of the console are the screen buffer and the console window. Il testo viene effettivamente letto o scritto nei flussi di proprietà da parte della console, ma sembra essere lette o scritte in un'area di proprietà console denominato buffer dello schermo.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. Il buffer dello schermo è un attributo della console ed è organizzato come una griglia rettangolare di righe e colonne in cui ogni intersezione della griglia o una cella di carattere, può contenere un carattere.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. Ogni carattere ha il proprio colore di primo piano e ogni cella di carattere ha il proprio colore di sfondo.Each character has its own foreground color, and each character cell has its own background color.

Il buffer dello schermo viene visualizzato in un'area rettangolare chiamata nella finestra della console.The screen buffer is viewed through a rectangular region called the console window. Nella finestra della console è un altro attributo della console; non è la console stessa, ovvero una finestra del sistema operativo.The console window is another attribute of the console; it is not the console itself, which is an operating system window. Nella finestra della console verrà disposti in righe e colonne, è minore o uguale alla dimensione del buffer dello schermo e può essere spostata per visualizzare aree diverse del buffer dello schermo sottostante.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. Se il buffer dello schermo è supera a nella finestra della console, la console visualizza automaticamente le barre di scorrimento in modo che la finestra della console può essere riposizionata sull'area del buffer dello schermo.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 cursore indica la posizione del buffer dello schermo in cui il testo viene letta o scritto.A cursor indicates the screen buffer position where text is currently read or written. Il cursore è possibile nascosto o rendere visibile e altezza può essere modificato.The cursor can be hidden or made visible, and its height can be changed. Se il cursore è visibile, la posizione della finestra console viene spostata automaticamente in modo che il cursore si trova sempre nella visualizzazione.If the cursor is visible, the console window position is moved automatically so the cursor is always in view.

L'origine per le coordinate di celle di carattere nel buffer dello schermo è l'angolo superiore sinistro e le posizioni del cursore e nella finestra della console vengano misurate in relazione tale 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. Usare gli indici in base zero per specificare le posizioni; vale a dire, specificare la riga più in alto come riga 0 e la colonna all'estrema sinistra come colonna 0.Use zero-based indexes to specify positions; that is, specify the topmost row as row 0, and the leftmost column as column 0. È il valore massimo per gli indici di riga e colonna Int16.MaxValue.The maximum value for the row and column indexes is Int16.MaxValue.

Supporto di Unicode per la Console diUnicode Support for the Console

In generale, la console legge l'input e output viene scritto usando la tabella codici corrente della console, che definisce le impostazioni locali del sistema per impostazione predefinita.In general, the console reads input and writes output by using the current console code page, which the system locale defines by default. Una tabella codici può gestire solo un subset di caratteri Unicode disponibili, pertanto se si prova a visualizzare caratteri che non sono mappati da una particolare tabella codici, la console non sarà possibile visualizzare tutti i caratteri o rappresentarli in modo accurato.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'esempio seguente illustra questo problema.The following example illustrates this problem. Prova a visualizzare i caratteri dell'alfabeto cirillico da U+10000 0410 a U + 044F nella console.It tries to display the characters of the Cyrillic alphabet from U+0410 to U+044F to the console. Se si esegue l'esempio in un sistema che utilizza la tabella codici 437 console, ogni carattere viene sostituito da un punto interrogativo (?), poiché non eseguano il mapping di caratteri in cirillico ai caratteri nella tabella codici 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
'       
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?

Oltre a supportare le tabelle codici, il Console con codifica UTF-8 supporta la classe di UTF8Encoding classe.In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. A partire da .NET Framework 4.5, il Console classe supporta anche con la codifica UTF-16 il UnicodeEncoding classe.Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. Per visualizzare i caratteri Unicode nella console.To display Unicode characters to the console. impostare il OutputEncoding proprietà a una delle due UTF8Encoding o UnicodeEncoding.you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

Supporto per i caratteri Unicode richiede il codificatore riconoscere un particolare carattere Unicode e richiede inoltre un tipo di carattere con glifi necessari per eseguire il rendering di tale carattere.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. Per visualizzare correttamente i caratteri Unicode nella console, è necessario impostare il tipo di carattere console a un tipo di carattere TrueType, ad esempio Lucida Console o Consolas o a non raster.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. Nell'esempio seguente viene illustrato come è possibile a livello di codice modificare il tipo di carattere da un tipo di carattere 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

Tipi di carattere TrueType, tuttavia, può visualizzare solo un subset dei glifi.However, TrueType fonts can display only a subset of glyphs. Ad esempio, il tipo di carattere Lucida Console visualizza solo 643 i 64.000 caratteri disponibili da u+0021 a U + FB02.For example, the Lucida Console font displays only 643 of the approximately 64,000 available characters from U+0021 to U+FB02. Per visualizzare un particolare tipo di carattere i cui caratteri supporti, aprire il tipi di carattere nel Pannello di controllo, scegliere il trova un carattere opzione e scegliere il tipo di carattere cui carattere set che si vuole esaminare la Tipo di carattere elenco del mappa caratteri finestra.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 Usa il collegamento per visualizzare glifi che non sono disponibili in un particolare tipo di carattere.Windows uses font linking to display glyphs that are not available in a particular font. Per informazioni sul tipo di carattere collegamento per visualizzare i set di caratteri aggiuntivi, vedere verso la globalizzazione: I tipi di carattere.For information about font linking to display additional character sets, see Globalization Step-by-Step: Fonts. Tipi di carattere collegati vengono definiti nella sottochiave del Registro di sistema HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink.Linked fonts are defined in the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink subkey of the registry. Ogni voce associata a questa sottochiave corrisponde al nome di un carattere di base e il relativo valore è una matrice di stringhe che definisce i file del tipo di carattere e i tipi di carattere collegati al carattere di 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. Ogni membro della matrice definisce un tipo di carattere collegato e assume la forma font-file-name,nome-tipo di carattere.Each member of the array defines a linked font and takes the form font-file-name,font-name. L'esempio seguente illustra la procedura a livello di codice per definire un tipo di carattere collegato denominato SimSun trovato in un file del tipo di carattere denominato simsun.ttc che visualizza i caratteri Han semplificato.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

Supporto di Unicode per la console presenta le limitazioni seguenti:Unicode support for the console has the following limitations:

  • Non è supportata la codifica UTF-32.UTF-32 encoding is not supported. Le codifiche sono UTF-8 e UTF-16, che sono rappresentate da Unicode è supportato esclusivamente il UTF8Encoding e UnicodeEncoding rispettivamente le classi.The only supported Unicode encodings are UTF-8 and UTF-16, which are represented by the UTF8Encoding and UnicodeEncoding classes, respectively.

  • Output bidirezionale non è supportato.Bidirectional output is not supported.

  • Visualizzazione di caratteri all'esterno nel Basic Multilingual Plane (vale a dire, delle coppie di surrogati) non è supportato, anche se sono definiti in un file del tipo di carattere collegati.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.

  • Non è supportata la visualizzazione dei caratteri in alfabeti non latini.Display of characters in complex scripts is not supported.

  • Le sequenze di caratteri di combinazione (vale a dire, i caratteri costituiti da un carattere di base e uno o più caratteri di unione) vengono visualizzate come caratteri distinti.Combining character sequences (that is, characters that consist of a base character and one or more combining characters) are displayed as separate characters. Per aggirare questa limitazione, è possibile normalizzare la stringa da visualizzare tramite la chiamata di String.Normalize metodo prima di inviare l'output alla 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. Nell'esempio seguente, una stringa che contiene il carattere di combinazione di U + 0061 sequenza U + 0308 viene visualizzato nella console come due caratteri prima che la stringa di output viene normalizzata sia come un singolo carattere dopo il String.Normalize viene chiamato il metodo.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"
    '       ä
    

    Si noti che la normalizzazione è una soluzione praticabile solo se lo standard per un form precomposti che corrisponde a un determinato combining è incluso il carattere Unicode sequenza di caratteri.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.

  • Se un tipo di carattere fornisce un glifo per un punto di codice nell'area uso privato, verrà visualizzato il glifo.If a font provides a glyph for a code point in the private use area, that glyph will be displayed. Tuttavia, poiché i caratteri nell'area uso privato sono specifici dell'applicazione, ciò potrebbe non essere glifo del previsto.However, because characters in the private use area are application-specific, this may not be the expected glyph.

Nell'esempio seguente visualizza un intervallo di caratteri Unicode nella console.The following example displays a range of Unicode characters to the console. Nell'esempio accetta tre parametri della riga di comando: l'inizio dell'intervallo da visualizzare, la fine dell'intervallo da visualizzare e se utilizzare la codifica di console corrente (false) o codifica 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). Si presuppone che la console utilizza un tipo di carattere 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  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ

Operazioni comuniCommon Operations

Il Console classe contiene i metodi seguenti per la lettura di input della console e la scrittura dell'output di console:The Console class contains the following methods for reading console input and writing console output:

  • Gli overload del ReadKey metodo leggere un singolo carattere.The overloads of the ReadKey method read an individual character.

  • Il ReadLine metodo legge l'intera riga di input.The ReadLine method reads an entire line of input.

  • Il Write convertire un'istanza di un tipo di valore, una matrice di caratteri o un set di oggetti in una stringa formattata o overload del metodo e quindi scrive tale stringa nella 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.

  • Set di un'operazione parallela di WriteLine overload del metodo lo stesso di stringhe come output il Write esegue l'overload, ma anche aggiungere una stringa di terminazione di riga.A parallel set of WriteLine method overloads output the same string as the Write overloads but also add a line termination string.

Il Console classe contiene inoltre i metodi e proprietà per eseguire le operazioni seguenti:The Console class also contains methods and properties to perform the following operations:

  • Ottiene o imposta la dimensione del buffer dello schermo.Get or set the size of the screen buffer. Il BufferHeight e BufferWidth delle proprietà consentono di ottenere o impostare rispettivamente, l'altezza del buffer e la larghezza e il SetBufferSize metodo consente di impostare le dimensioni del buffer in una singola chiamata al metodo.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.

  • Ottiene o imposta le dimensioni della finestra della console.Get or set the size of the console window. Il WindowHeight e WindowWidth delle proprietà consentono di ottenere o impostare rispettivamente, l'altezza della finestra e la larghezza e il SetWindowSize metodo consente di impostare le dimensioni della finestra in una singola chiamata al metodo.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.

  • Ottiene o imposta le dimensioni del cursore.Get or set the size of the cursor. Il CursorSize proprietà specifica l'altezza del cursore in una cella di carattere.The CursorSize property specifies the height of the cursor in a character cell.

  • Ottiene o imposta la posizione della finestra della console rispetto al buffer dello schermo.Get or set the position of the console window relative to the screen buffer. Il WindowTop e WindowLeft delle proprietà consentono di ottenere o impostare la prima riga e colonna più a sinistra del buffer dello schermo che viene visualizzato nella finestra della console, e il SetWindowPosition metodo consente di impostare questi valori in una singola chiamata al metodo.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.

  • Ottiene o imposta la posizione del cursore da ottenere o impostare il CursorTop e CursorLeft le proprietà o impostare la posizione del cursore tramite una chiamata di SetCursorPosition (metodo).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.

  • Spostare o cancellare i dati nel buffer dello schermo chiamando il MoveBufferArea o Clear (metodo).Move or clear data in the screen buffer by calling the MoveBufferArea or Clear method.

  • Ottenere o impostare i colori di primo piano e sfondo usando il ForegroundColor e BackgroundColor delle proprietà, o reimpostate il primo piano e i colori predefiniti chiamando il ResetColor (metodo).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.

  • Riproduce l'audio di un segnale acustico tramite l'altoparlante della console mediante la chiamata di Beep (metodo).Play the sound of a beep through the console speaker by calling the Beep method.

.NET Core.NET Core NoteNotes

In .NET Framework sul desktop, il Console classe utilizza la codifica restituita dalla GetConsoleCP e GetConsoleOutputCP, che in genere è una tabella codici di codifica.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. Ad esempio codice, nei sistemi con le impostazioni cultura è l'inglese (Stati Uniti), la tabella codici 437 è la codifica utilizzata per impostazione predefinita.For example code, on systems whose culture is English (United States), code page 437 is the encoding that is used by default. Tuttavia, .NET Core.NET Core può rendere disponibili solo un subset limitato di queste codifiche.However, .NET Core.NET Core may make only a limited subset of these encodings available. In questo caso, Encoding.UTF8 viene utilizzato come la codifica predefinita per la console.Where this is the case, Encoding.UTF8 is used as the default encoding for the console.

Se l'app dipende da codifiche specifiche, è possibile comunque renderli disponibili eseguendo le operazioni seguenti prima viene chiamato uno Console metodi: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. Aggiungere un riferimento all'assembly System.Text.Encoding.CodePages.dll al progetto.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Recuperare il EncodingProvider dall'oggetto di CodePagesEncodingProvider.Instance proprietà.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Passare il EncodingProvider dell'oggetto per il Encoding.RegisterProvider metodo per apportare le codifiche aggiuntive supportate dal provider di codifica disponibili.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

Il Console classe quindi userà automaticamente la codifica di sistema predefinita anziché UTF8, condizione che è stato registrato il provider di codifica prima di chiamare qualsiasi Console metodi di output.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.

Proprietà

BackgroundColor BackgroundColor BackgroundColor BackgroundColor

Ottiene o imposta il colore di sfondo della console.Gets or sets the background color of the console.

BufferHeight BufferHeight BufferHeight BufferHeight

Ottiene o imposta l'altezza dell'area del buffer.Gets or sets the height of the buffer area.

BufferWidth BufferWidth BufferWidth BufferWidth

Ottiene o imposta la larghezza dell'area del buffer.Gets or sets the width of the buffer area.

CapsLock CapsLock CapsLock CapsLock

Ottiene un valore che indica se il tasto di alternanza BLOC MAIUSC è attivato o disattivato.Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft CursorLeft CursorLeft CursorLeft

Ottiene o imposta la posizione della colonna del cursore all'interno dell'area del buffer.Gets or sets the column position of the cursor within the buffer area.

CursorSize CursorSize CursorSize CursorSize

Ottiene o imposta l'altezza del cursore all'interno di una cella di carattere.Gets or sets the height of the cursor within a character cell.

CursorTop CursorTop CursorTop CursorTop

Ottiene o imposta la posizione della riga del cursore all'interno dell'area del buffer.Gets or sets the row position of the cursor within the buffer area.

CursorVisible CursorVisible CursorVisible CursorVisible

Ottiene o imposta un valore che indica se il cursore è visibile.Gets or sets a value indicating whether the cursor is visible.

Error Error Error Error

Ottiene il flusso di output di errore standard.Gets the standard error output stream.

ForegroundColor ForegroundColor ForegroundColor ForegroundColor

Ottiene o imposta il colore di primo piano della console.Gets or sets the foreground color of the console.

In In In In

Ottiene il flusso di input standard.Gets the standard input stream.

InputEncoding InputEncoding InputEncoding InputEncoding

Ottiene o imposta la codifica usata dalla console per leggere l'input.Gets or sets the encoding the console uses to read input.

IsErrorRedirected IsErrorRedirected IsErrorRedirected IsErrorRedirected

Ottiene un valore che indica se il flusso di output errore è stato reindirizzato dal flusso di errore standard.Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected IsInputRedirected IsInputRedirected IsInputRedirected

Ottiene un valore che indica se l'input è stato reindirizzato dal flusso di input standard.Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected IsOutputRedirected IsOutputRedirected IsOutputRedirected

Ottiene un valore che indica se l'output è stato reindirizzato dal flusso di output standard.Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable KeyAvailable KeyAvailable KeyAvailable

Ottiene o imposta un valore che indica se nel flusso di input è stata rilevata la pressione di un tasto.Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight LargestWindowHeight LargestWindowHeight LargestWindowHeight

Ottiene il numero massimo consentito di righe per la finestra della console, in base al tipo di carattere corrente e alla risoluzione dello schermo.Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth LargestWindowWidth LargestWindowWidth LargestWindowWidth

Ottiene il numero massimo consentito di colonne della finestra della console, in base al tipo di carattere corrente e alla risoluzione dello schermo.Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock NumberLock NumberLock NumberLock

Ottiene un valore che indica se il tasto di alternanza BLOC NUM è attivato o disattivato.Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out Out Out Out

Ottiene il flusso di output standard.Gets the standard output stream.

OutputEncoding OutputEncoding OutputEncoding OutputEncoding

Ottiene o imposta la codifica usata dalla console per scrivere l'output.Gets or sets the encoding the console uses to write output.

Title Title Title Title

Ottiene o imposta il titolo da visualizzare nella barra del titolo della console.Gets or sets the title to display in the console title bar.

TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput

Ottiene o imposta un valore che indica se la combinazione del tasto di modifica Control e del tasto della console C (CTRL+C) deve essere trattata come un input standard o come un'interruzione gestita dal sistema operativo.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

Ottiene o imposta l'altezza dell'area della finestra della console.Gets or sets the height of the console window area.

WindowLeft WindowLeft WindowLeft WindowLeft

Ottiene o imposta la posizione più a sinistra dell'area della finestra della console relativamente al buffer dello schermo.Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop WindowTop WindowTop WindowTop

Ottiene o imposta la posizione più in alto della finestra della console relativamente al buffer dello schermo.Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth WindowWidth WindowWidth WindowWidth

Ottiene o imposta la larghezza della finestra della console.Gets or sets the width of the console window.

Metodi

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

Riproduce il suono di un segnale acustico usando l'altoparlante della console.Plays the sound of a beep through the console speaker.

Beep(Int32, Int32) Beep(Int32, Int32) Beep(Int32, Int32) Beep(Int32, Int32)

Riproduce il suono di un segnale acustico a una frequenza e durata specificate usando l'altoparlante della console.Plays the sound of a beep of a specified frequency and duration through the console speaker.

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

Cancella dal buffer della console e dalla rispettiva finestra della console le informazioni visualizzate.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)

Copia un'area di origine specificata del buffer dello schermo in un'area di destinazione specificata.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)

Copia un'area di origine specificata del buffer dello schermo in un'area di destinazione specificata.Copies a specified source area of the screen buffer to a specified destination area.

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

Acquisisce il flusso di errore standard.Acquires the standard error stream.

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

Acquisisce il flusso di errore standard, impostato su una determinata dimensione del buffer.Acquires the standard error stream, which is set to a specified buffer size.

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

Acquisisce il flusso di input standard.Acquires the standard input stream.

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

Acquisisce il flusso di input standard, impostato su una determinata dimensione del buffer.Acquires the standard input stream, which is set to a specified buffer size.

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

Acquisisce il flusso di output standard.Acquires the standard output stream.

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

Acquisisce il flusso di output standard, impostato su una determinata dimensione del buffer.Acquires the standard output stream, which is set to a specified buffer size.

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

Legge il carattere successivo dal flusso di input standard.Reads the next character from the standard input stream.

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

Ottiene il carattere successivo o il tasto funzione premuto dall'utente.Obtains the next character or function key pressed by the user. Il tasto premuto viene visualizzato nella finestra della console.The pressed key is displayed in the console window.

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

Ottiene il carattere successivo o il tasto funzione premuto dall'utente.Obtains the next character or function key pressed by the user. Il tasto premuto viene visualizzato facoltativamente nella finestra della console.The pressed key is optionally displayed in the console window.

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

Legge la riga successiva di caratteri dal flusso di input standard.Reads the next line of characters from the standard input stream.

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

Imposta i colori di primo piano e di sfondo della console sulle impostazioni predefinite.Sets the foreground and background console colors to their defaults.

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

Imposta l'altezza e la larghezza dell'area del buffer dello schermo sui valori specificati.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)

Imposta la posizione del cursore.Sets the position of the cursor.

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

Imposta la proprietà Error sull'oggetto TextWriter specificato.Sets the Error property to the specified TextWriter object.

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

Imposta la proprietà In sull'oggetto TextReader specificato.Sets the In property to the specified TextReader object.

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

Imposta la proprietà Out sull'oggetto TextWriter specificato.Sets the Out property to the specified TextWriter object.

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

Imposta la posizione della finestra della console rispetto al buffer dello schermo.Sets the position of the console window relative to the screen buffer.

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

Imposta l'altezza e la larghezza della finestra della console sui valori specificati.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)

Scrive nel flusso di output standard la rappresentazione testo dell'elenco degli oggetti e dei parametri di lunghezza variabile specificati usando le informazioni di formato specificate.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)

Scrive nel flusso di output standard la rappresentazione testo degli oggetti specificati usando le informazioni di formato specificate.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)

Scrive nel flusso di output standard la rappresentazione testo degli oggetti specificati usando le informazioni di formato specificate.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[])

Scrive nel flusso di output standard la rappresentazione testo della matrice di oggetti specificata usando le informazioni di formato specificate.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)

Scrive nel flusso di output standard la rappresentazione testo dell'oggetto specificato usando le informazioni di formato specificate.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)

Scrive nel flusso di output standard la rappresentazione testo dell'intero senza segno a 64 bit specificato.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)

Scrive nel flusso di output standard la rappresentazione testo dell'intero senza segno a 32 bit specificato.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)

Scrive nel flusso di output standard il valore della stringa specificato.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)

Scrive nel flusso di output standard una specifica sottomatrice di caratteri Unicode.Writes the specified subarray of Unicode characters to the standard output stream.

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

Scrive nel flusso di output standard la rappresentazione testo dell'oggetto specificato.Writes the text representation of the specified object to the standard output stream.

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

Scrive nel flusso di output standard la rappresentazione testo del valore a virgola mobile a precisione singola specificato.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)

Scrive nel flusso di output standard il valore del carattere Unicode specificato.Writes the specified Unicode character value to the standard output stream.

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

Scrive nel flusso di output standard una specifica matrice di caratteri Unicode.Writes the specified array of Unicode characters to the standard output stream.

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

Scrive nel flusso di output standard la rappresentazione testo del valore booleano specificato.Writes the text representation of the specified Boolean value to the standard output stream.

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

Scrive nel flusso di output standard la rappresentazione testo del valore a virgola mobile a precisione doppia specificato.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)

Scrive nel flusso di output standard la rappresentazione di testo dell'intero con segno a 32 bit specificato.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)

Scrive nel flusso di output standard la rappresentazione di testo dell'intero con segno a 64 bit specificato.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)

Inserisce nel flusso di output standard la rappresentazione testo del valore Decimal specificato.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)

Scrive nel flusso di output standard la rappresentazione testo degli oggetti specificati, seguita dal terminatore di riga corrente, usando le informazioni di formato specificate.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)

Scrive nel flusso di output standard il valore della stringa specificato, seguito dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la sottomatrice di caratteri Unicode specificata, seguita dal terminatore di riga corrente.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[])

Scrive nel flusso di output standard la rappresentazione testo della matrice di oggetti specificata, seguita dal terminatore di riga corrente, usando le informazioni di formato specificate.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)

Scrive nel flusso di output standard la rappresentazione testo dell'oggetto specificato, seguita dal terminatore di riga corrente, usando le informazioni di formato specificate.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)

Scrive nel flusso di output standard la rappresentazione testo dell'intero senza segno a 64 bit specificato, seguita dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione testo dell'intero senza segno a 32 bit specificato, seguita dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione testo del valore a virgola mobile a precisione singola specificato, seguita dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione testo del valore Decimal specificato, seguita dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione di testo dell'intero con segno a 64 bit specificato, seguita dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione di testo dell'intero con segno a 32 bit specificato, seguita dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione testo del valore a virgola mobile a precisione doppia specificato, seguita dal terminatore di riga corrente.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[])

Scrive nel flusso di output standard la matrice di caratteri Unicode specificata, seguita dal terminatore di riga corrente.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)

Scrive nel flusso di output standard il valore del carattere Unicode specificato, seguito dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione testo del valore booleano specificato, seguita dal terminatore di riga corrente.Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

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

Scrive nel flusso di output standard il terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione testo degli oggetti specificati, seguita dal terminatore di riga corrente, usando le informazioni di formato specificate.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)

Scrive nel flusso di output standard la rappresentazione testo dell'oggetto specificato, seguita dal terminatore di riga corrente.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)

Scrive nel flusso di output standard la rappresentazione testo dell'elenco degli oggetti e dei parametri di lunghezza variabile specificati, seguiti dal terminatore di riga corrente, usando le informazioni di formato specificate.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.

Eventi

CancelKeyPress CancelKeyPress CancelKeyPress CancelKeyPress

Si verifica quando il tasto di modifica Control (CTRL) e il tasto della console C (C) o il tasto INTERR vengono premuti contemporaneamente (CTRL+C o CTRL+INTERR).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).

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.