Console Klasa

Definicja

Reprezentuje standardowe strumienie danych wejściowych, wyjściowych i błędów dla aplikacji konsolowych.Represents the standard input, output, and error streams for console applications. Klasa ta nie może być dziedziczona.This class cannot be inherited.

public ref class Console abstract sealed
public static class Console
type Console = class
Public Class Console
Dziedziczenie
Console

Przykłady

Poniższy przykład ilustruje sposób odczytywania danych z i zapisywania danych w standardowym strumieniu danych wejściowych i wyjściowych.The following example demonstrates how to read data from, and write data to, the standard input and output streams. Należy zauważyć, że te strumienie mogą być przekierowywane przy użyciu metod SetIn i SetOut.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!
module Example

open System

[<EntryPoint>]
let main argv =
    Console.Write("Hello ")
    Console.WriteLine("World!")
    Console.Write("Enter your name: ")
    let name = Console.ReadLine()
    Console.Write("Good day, ")
    Console.Write(name)
    Console.WriteLine("!")
    0
    
// The example displays output similar to the following:
//       Hello World!
//       Enter your name: James
//       Good day, James!

Uwagi

Konsola programu jest oknem systemu operacyjnego, w którym użytkownicy wchodzą w interakcje z systemem operacyjnym lub z aplikacją konsolową opartą na tekście przez wprowadzanie tekstu wejściowego za pomocą klawiatury komputer i odczytywanie tekstu wyjściowego z terminalu komputerowego.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. Na przykład w systemie operacyjnym Windows konsola jest nazywana oknem wiersza polecenia i akceptuje polecenia systemu MS-DOS.For example, in the Windows operating system, the console is called the Command Prompt window and accepts MS-DOS commands. Klasa Console zapewnia podstawową pomoc techniczną dla aplikacji, które odczytują znaki z i zapisują znaki w konsoli programu.The Console class provides basic support for applications that read characters from, and write characters to, the console.

Aby uzyskać informacje na temat programowania z klasą Console, zobacz następujące sekcje:For information about developing with the Console class, see the following sections:

Strumienie wejścia/wyjścia konsoliConsole I/O Streams

Po uruchomieniu aplikacji konsolowej system operacyjny automatycznie kojarzy trzy strumienie we/wy z konsolą: standardowy strumień wejściowy, standardowy strumień wyjściowy i strumień wyjściowy błędu standardowego.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. Aplikacja może odczytywać dane wejściowe użytkownika ze standardowego strumienia wejściowego. Zapisuj normalne dane w standardowym strumieniu wyjściowym; i Zapisz dane błędów w standardowym strumieniu wyjściowym błędu.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. Te strumienie są prezentowane w aplikacji jako wartości właściwości Console.In, Console.Outi Console.Error.These streams are presented to your application as the values of the Console.In, Console.Out, and Console.Error properties.

Domyślnie wartość właściwości In jest obiektem System.IO.TextReader, który reprezentuje klawiaturę, a wartości właściwości Out i ErrorSystem.IO.TextWriter obiektów, które reprezentują okno konsoli.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. Można jednak ustawić te właściwości na strumienie, które nie reprezentują okna konsoli lub klawiatury; na przykład można ustawić te właściwości na strumienie reprezentujące pliki.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. Aby przekierować strumień standardowego wejścia, wyjścia standardowego lub standardowego błędu, wywołaj odpowiednio metodę Console.SetIn, Console.SetOutlub Console.SetError.To redirect the standard input, standard output, or standard error stream, call the Console.SetIn, Console.SetOut, or Console.SetError method, respectively. Operacje we/wy, które używają tych strumieni, są synchronizowane, co oznacza, że wiele wątków może odczytywać i zapisywać strumieniowo.I/O operations that use these streams are synchronized, which means that multiple threads can read from, or write to, the streams. Oznacza to, że metody, które są zwykle asynchroniczne, takie jak TextReader.ReadLineAsync, wykonują synchronicznie, jeśli obiekt reprezentuje strumień konsoli.This means that methods that are ordinarily asynchronous, such as TextReader.ReadLineAsync, execute synchronously if the object represents a console stream.

Uwaga

Nie należy używać klasy Console do wyświetlania danych wyjściowych w aplikacjach nienadzorowanych, takich jak aplikacje serwera.Do not use the Console class to display output in unattended applications, such as server applications. Wywołania metod, takich jak Console.Write i Console.WriteLine, nie działają w aplikacjach graficznego interfejsu użytkownika.Calls to methods such as Console.Write and Console.WriteLine have no effect in GUI applications.

Console składowe klasy, które działają normalnie, gdy źródłowy strumień jest kierowany do konsoli programu, może zgłosić wyjątek, jeśli strumień jest przekierowywany, na przykład do pliku.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. Zapoznaj się z aplikacją, aby przechwycić System.IO.IOException wyjątki w przypadku przekierowania standardowego strumienia.Program your application to catch System.IO.IOException exceptions if you redirect a standard stream. Można również użyć właściwości IsOutputRedirected, IsInputRedirectedi IsErrorRedirected, aby określić, czy strumień standardowy został przekierowany przed wykonaniem operacji, która zgłasza wyjątek System.IO.IOException.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.

Czasami warto jawnie wywołać elementy członkowskie obiektów strumienia reprezentowane przez właściwości In, Outi Error.It is sometimes useful to explicitly call the members of the stream objects represented by the In, Out, and Error properties. Na przykład domyślnie Metoda Console.ReadLine odczytuje dane wejściowe ze standardowego strumienia wejściowego.For example, by default, the Console.ReadLine method reads input from the standard input stream. Podobnie Metoda Console.WriteLine zapisuje dane w standardowym strumieniu wyjściowym, a po nim następuje domyślny ciąg zakończenia wiersza, który jest znakiem powrotu karetki i wysuwu wiersza ("\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"). Jednak Klasa Console nie zapewnia odpowiedniej metody zapisu danych w standardowym strumieniu wyjściowym błędu lub właściwości, aby zmienić ciąg zakończenia wiersza dla danych zapisanych w tym strumieniu.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.

Możesz rozwiązać ten problem, ustawiając właściwość TextWriter.NewLine właściwości Out lub Error na inny ciąg zakończenia wiersza.You can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. Na przykład Poniższa C# instrukcja ustawia ciąg zakończenia wiersza dla standardowego strumienia wyjściowego błędu do dwóch sekwencji powrotu karetki i wysuwu wiersza: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";

Następnie można jawnie wywołać metodę WriteLine obiektu strumienia wyjściowego błędu, jak w poniższej C# instrukcji:You can then explicitly call the WriteLine method of the error output stream object, as in the following C# statement:

Console.Error.WriteLine();

Bufor ekranu i okno konsoliScreen Buffer and Console Window

Dwie ściśle powiązane funkcje konsoli to bufor ekranu i okno konsoli.Two closely related features of the console are the screen buffer and the console window. Tekst jest faktycznie odczytywany lub zapisywana w strumieniach należących do konsoli, ale prawdopodobnie jest odczytywany lub zapisywana w obszarze należącym do konsoli o nazwie bufor ekranu.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. Bufor ekranu jest atrybutem konsoli i jest zorganizowany jako prostokątna siatka wierszy i kolumn, w których każda sekcja przecięcie siatki lub komórka znaku może zawierać znak.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. Każdy znak ma swój własny kolor pierwszego planu, a każda komórka znaku ma własny kolor tła.Each character has its own foreground color, and each character cell has its own background color.

Bufor ekranu jest wyświetlany za pomocą prostokątnego regionu o nazwie okno konsoli.The screen buffer is viewed through a rectangular region called the console window. Okno konsoli jest innym atrybutem konsoli programu; nie jest to sama sama konsola, która jest oknem systemu operacyjnego.The console window is another attribute of the console; it is not the console itself, which is an operating system window. Okno konsoli jest ułożone w wiersze i kolumny, jest mniejsze niż lub równe rozmiarowi buforu ekranu i można je przenieść, aby wyświetlić różne obszary odpowiedniego buforu ekranu.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. Jeśli bufor ekranu jest większy niż okno konsoli, w konsoli programu automatycznie są wyświetlane paski przewijania, dzięki czemu okno konsoli można zmienić w obszarze buforu ekranu.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.

Kursor wskazuje położenie buforu ekranu, w którym tekst jest aktualnie odczytywany lub zapisywana.A cursor indicates the screen buffer position where text is currently read or written. Kursor może być ukryty lub niewidoczny i można zmienić jego wysokość.The cursor can be hidden or made visible, and its height can be changed. Jeśli kursor jest widoczny, pozycja okna konsoli jest przenoszona automatycznie, aby kursor był zawsze w widoku.If the cursor is visible, the console window position is moved automatically so the cursor is always in view.

Punkt początkowy współrzędne komórki znaku w buforze ekranu jest górnym lewym rogu, a położenia kursora i okna konsoli są mierzone względem tego źródła.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. Użyj indeksów opartych na zerach, aby określić pozycje; oznacza to, że należy określić górny wiersz jako wiersz 0 i kolumnę z lewej strony jako kolumnę 0.Use zero-based indexes to specify positions; that is, specify the topmost row as row 0, and the leftmost column as column 0. Maksymalna wartość indeksów wierszy i kolumn jest Int16.MaxValue.The maximum value for the row and column indexes is Int16.MaxValue.

Obsługa standardu Unicode dla konsoliUnicode Support for the Console

Ogólnie rzecz biorąc, konsola odczytuje dane wejściowe i zapisuje dane wyjściowe przy użyciu bieżącej strony kodowej konsoli, która domyślnie definiuje ustawienia regionalne systemu.In general, the console reads input and writes output by using the current console code page, which the system locale defines by default. Strona kodowa może obsługiwać tylko podzestaw dostępnych znaków Unicode, więc jeśli spróbujesz wyświetlić znaki, które nie są zamapowane przez określoną stronę kodową, konsola nie będzie mogła wyświetlać wszystkich znaków ani ich dokładnie przedstawiać.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. Poniższy przykład ilustruje ten problem.The following example illustrates this problem. Próbuje wyświetlić znaki alfabetu cyrylicy od U + 0410 do U + 044F w konsoli programu.It tries to display the characters of the Cyrillic alphabet from U+0410 to U+044F to the console. W przypadku uruchomienia przykładu w systemie, który używa strony kodowej konsoli 437, każdy znak jest zastępowany znakiem zapytania (?), ponieważ znaki cyrylicy nie są mapowane na znaki na stronie kodowej 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
'       
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
module Example

open System

[<EntryPoint>]
let main argv =
    // Create a char List for the modern Cyrillic alphabet,
    // from U+0410 to U+044F.
    let chars =
        [ for codePoint in 0x0410 .. 0x044F do
            Convert.ToChar(codePoint) ]

    printfn "Current code page: %i\n" Console.OutputEncoding.CodePage
    // Display the characters.
    for ch in chars do
        printf "%c  " ch
        if (Console.CursorLeft) >= 70 then Console.WriteLine()

    0
// The example displays the following output:
//    Current code page: 437
//
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?

Oprócz obsługi stron kodowych, Klasa Console obsługuje kodowanie UTF-8 z klasą UTF8Encoding.In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. Począwszy od .NET Framework 4,5, Klasa Console obsługuje również kodowanie UTF-16 z klasą UnicodeEncoding.Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. Aby wyświetlić znaki Unicode w konsoli programu.To display Unicode characters to the console. Właściwość OutputEncoding ustawia się na UTF8Encoding lub UnicodeEncoding.you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

Obsługa znaków Unicode wymaga, aby koder rozpoznaje określony znak Unicode, a także wymaga czcionki, która ma glify potrzebne do renderowania tego znaku.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. Aby pomyślnie wyświetlić znaki Unicode w konsoli programu, czcionka konsoli musi być ustawiona na czcionkę nierastrową lub TrueType, taką jak Consolas lub 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. Poniższy przykład pokazuje, jak można programowo zmienić czcionkę z czcionki rastrowej na Lucidę 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
module Example

open System
open System.Runtime.InteropServices

[<Literal>]
let STD_OUTPUT_HANDLE = -11

[<Literal>]
let TMPF_TRUETYPE = 4

[<Literal>]
let LF_FACESIZE = 32

let INVALID_HANDLE_VALUE = IntPtr(-1)


[<Struct>]
[<StructLayout(LayoutKind.Sequential)>]
type COORD =
    val mutable X: int16
    val mutable Y: int16

    internal new(x: int16, y: int16) =
        { X = x
          Y = y }

[<Struct>]
[<StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)>]
type CONSOLE_FONT_INFO_EX =
    val mutable cbSize: uint32
    val mutable nFont: uint32
    val mutable dwFontSize: COORD
    val mutable FontFamily: int
    val mutable FontWeight: int
    [<MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)>]
    val mutable FaceName: string

[<DllImport("kernel32.dll", SetLastError = true)>]
extern IntPtr GetStdHandle(int nStdHandle)

[<DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)>]
extern bool GetCurrentConsoleFontEx(IntPtr consoleOutput, bool maximumWindow, CONSOLE_FONT_INFO_EX lpConsoleCurrentFontEx)

[<DllImport("kernel32.dll", SetLastError = true)>]
extern bool SetCurrentConsoleFontEx(IntPtr consoleOutput, bool maximumWindow, CONSOLE_FONT_INFO_EX consoleCurrentFontEx)

[<EntryPoint>]
let main argv =
    let fontName = "Lucida Console"
    let hnd = GetStdHandle(STD_OUTPUT_HANDLE)
    if hnd <> INVALID_HANDLE_VALUE then
        let mutable info = CONSOLE_FONT_INFO_EX()
        info.cbSize <- uint32 (Marshal.SizeOf(info))
        // First determine whether there's already a TrueType font.
        if (GetCurrentConsoleFontEx(hnd, false, info)) then
            if (((info.FontFamily) &&& TMPF_TRUETYPE) = TMPF_TRUETYPE) then
                Console.WriteLine("The console already is using a TrueType font.")
            else
                // Set console font to Lucida Console.
                let mutable newInfo = CONSOLE_FONT_INFO_EX()
                newInfo.cbSize <- uint32 (Marshal.SizeOf(newInfo))
                newInfo.FontFamily <- TMPF_TRUETYPE
                newInfo.FaceName <- fontName
                // Get some settings from current font.
                newInfo.dwFontSize <- COORD(info.dwFontSize.X, info.dwFontSize.Y)
                newInfo.FontWeight <- info.FontWeight
                SetCurrentConsoleFontEx(hnd, false, newInfo) |> ignore
                Console.WriteLine("The console is now using a TrueType font.")

    // Return zero for success
    0

Jednak czcionki TrueType mogą wyświetlać tylko podzbiór symboli.However, TrueType fonts can display only a subset of glyphs. Na przykład czcionka konsoli Lucida wyświetla tylko 643 z około 64 000 dostępnych znaków z U + 0021 do U + FB02.For example, the Lucida Console font displays only 643 of the approximately 64,000 available characters from U+0021 to U+FB02. Aby zobaczyć, które znaki są obsługiwane przez określoną czcionkę, Otwórz aplet czcionki w panelu sterowania, wybierz opcję Znajdź znak i wybierz czcionkę, której zestaw znaków chcesz sprawdzić na liście czcionka okna Mapa znaków .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.

System Windows używa łączenia czcionek do wyświetlania glifów, które nie są dostępne w określonej czcionce.Windows uses font linking to display glyphs that are not available in a particular font. Aby uzyskać informacje o łączeniu czcionki do wyświetlania dodatkowych zestawów znaków, zobacz globalizacja krok po kroku: czcionki.For information about font linking to display additional character sets, see Globalization Step-by-Step: Fonts. Czcionki połączone są zdefiniowane w HKEY_LOCAL_MACHINE podkluczu NT\CurrentVersion\FontLink\SystemLink \SOFTWARE\Microsoft\Windows rejestru.Linked fonts are defined in the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink subkey of the registry. Każda pozycja skojarzona z tym podkluczem odpowiada nazwie czcionki podstawowej, a jej wartość jest tablicą ciągów, która definiuje pliki czcionek i czcionki połączone z czcionką podstawową.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. Każdy element członkowski tablicy definiuje połączoną czcionkę i przyjmuje postać Font-File-NameiFont-Name.Each member of the array defines a linked font and takes the form font-file-name,font-name. W poniższym przykładzie pokazano, jak programowo zdefiniować połączoną czcionkę o nazwie SimSun znalezioną w pliku czcionki o nazwie SimSun. TTC, który wyświetla uproszczone znaki Han.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
module Example

open System
open Microsoft.Win32

[<EntryPoint>]
let main argv =
    let valueName = "Lucida Console"
    let newFont = "simsun.ttc,SimSun"

    let key =
        Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink", true)
    if isNull key then
        printfn "Font linking is not enabled."
    else
        // Determine if the font is a base font.
        let names = key.GetValueNames()

        let (fonts, kind, toAdd) =
            if names |> Array.exists (fun s -> s.Equals(valueName, StringComparison.OrdinalIgnoreCase)) then
                // Get the value's type.
                let kind = key.GetValueKind(valueName)

                // Type should be RegistryValueKind.MultiString, but we can't be sure.
                let fonts =
                    match kind with
                    | RegistryValueKind.String -> [| key.GetValue(valueName) :?> string |]
                    | RegistryValueKind.MultiString -> (key.GetValue(valueName) :?> string array)
                    | _ -> [||]

                // Determine whether SimSun is a linked font.
                let toAdd =
                    not (fonts |> Array.exists (fun s -> s.IndexOf("SimSun", StringComparison.OrdinalIgnoreCase) >= 0))

                (fonts, kind, toAdd)
            else
                // Font is not a base font.
                ([||], RegistryValueKind.Unknown, true)

        if toAdd then
            // Font is not a linked font.
            let newFonts = Array.append fonts [| newFont |]

            // Change REG_SZ to REG_MULTI_SZ.
            if kind = RegistryValueKind.String then key.DeleteValue(valueName, false)

            key.SetValue(valueName, newFonts, RegistryValueKind.MultiString)
            printfn "SimSun added to the list of linked fonts."
        else
            printfn "Font is already linked."


    if not (isNull key) then key.Close()
    0
    

Obsługa standardu Unicode dla konsoli programu ma następujące ograniczenia:Unicode support for the console has the following limitations:

  • Kodowanie UTF-32 nie jest obsługiwane.UTF-32 encoding is not supported. Jedyne obsługiwane kodowanie Unicode to UTF-8 i UTF-16, które są reprezentowane odpowiednio przez klasy UTF8Encoding i UnicodeEncoding.The only supported Unicode encodings are UTF-8 and UTF-16, which are represented by the UTF8Encoding and UnicodeEncoding classes, respectively.

  • Dane wyjściowe dwukierunkowe nie są obsługiwane.Bidirectional output is not supported.

  • Wyświetlanie znaków poza podstawową płaszczyzną wielojęzyczną (czyli pary zastępczej) nie jest obsługiwane, nawet jeśli są one zdefiniowane w połączonym pliku czcionki.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.

  • Wyświetlanie znaków w złożonych skryptach nie jest obsługiwane.Display of characters in complex scripts is not supported.

  • Łączenie sekwencji znaków (czyli znaków, które składają się z znaku podstawowego i jednego lub więcej łączących znaków) są wyświetlane jako osobne znaki.Combining character sequences (that is, characters that consist of a base character and one or more combining characters) are displayed as separate characters. Aby obejść to ograniczenie, można znormalizować ciąg, który ma być wyświetlany, wywołując metodę String.Normalize przed wysłaniem danych wyjściowych do konsoli.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. W poniższym przykładzie ciąg, który zawiera sekwencję znaków łączących U + 0061 U + 0308 jest wyświetlany w konsoli jako dwa znaki, zanim ciąg wyjściowy jest znormalizowany, i jako pojedynczy znak po wywołaniu metody String.Normalize.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"
    '       ä
    
    module Example
    
    open System;
    
    [<EntryPoint>]
    let main argv =
       let chars = [| '\u0061'; '\u0308' |]
    
       let combining = String(chars)
       Console.WriteLine(combining)
       
       let combining = combining.Normalize()
       Console.WriteLine(combining)
       0
    
    // The example displays the following output:
    //       a"
    //       ä
    

    Należy zauważyć, że normalizacja jest rozwiązaniem wykonalnym tylko wtedy, gdy standard Unicode dla znaku zawiera formularz przedłożony, który odnosi się do konkretnej sekwencji znaków łączącej.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.

  • Jeśli czcionka zawiera glif dla punktu kodu w obszarze prywatnego użytkowania, ten symbol zostanie wyświetlony.If a font provides a glyph for a code point in the private use area, that glyph will be displayed. Jednak ze względu na to, że znaki w prywatnym obszarze użytkowania są specyficzne dla aplikacji, może to nie być oczekiwany symbol.However, because characters in the private use area are application-specific, this may not be the expected glyph.

Poniższy przykład wyświetla zakres znaków Unicode do konsoli.The following example displays a range of Unicode characters to the console. W przykładzie są akceptowane trzy parametry wiersza polecenia: początek zakresu do wyświetlenia, koniec zakresu do wyświetlenia oraz czy ma być używane bieżące kodowanie konsoli (false) czy kodowanie 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). Przyjęto założenie, że konsola używa czcionki 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.IO
Imports System.Globalization
Imports System.Text

Public Module DisplayChars
   Public Sub Main(args() As String)
      Dim rangeStart As UInteger = 0
      Dim rangeEnd As UInteger = 0
      Dim setOutputEncodingToUnicode As Boolean = True
      ' Get the current encoding so we can restore it.
      Dim originalOutputEncoding As Encoding = Console.OutputEncoding

    Try
         Select Case args.Length
            Case 2
               rangeStart = UInt32.Parse(args(0), NumberStyles.HexNumber)
               rangeEnd = UInt32.Parse(args(1), NumberStyles.HexNumber)
               setOutputEncodingToUnicode = True
            Case 3
               If Not UInt32.TryParse(args(0), NumberStyles.HexNumber, Nothing, rangeStart) Then
                  Throw New ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args(0)))
               End If
               
               If Not UInt32.TryParse(args(1), NumberStyles.HexNumber, Nothing, rangeEnd) Then
                  Throw New ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args(1)))
               End If
               
               Boolean.TryParse(args(2), setOutputEncodingToUnicode)
            Case Else
               Console.WriteLine("Usage: {0} <{1}> <{2}> [{3}]", 
                                 Environment.GetCommandLineArgs()(0), 
                                 "startingCodePointInHex", 
                                 "endingCodePointInHex", 
                                 "<setOutputEncodingToUnicode?{true|false, default:false}>")
               Exit Sub
         End Select
   
         If setOutputEncodingToUnicode Then
            ' This won't work before .NET Framework 4.5.
            Try 
               ' Set encoding Imports endianness of this system.
               ' We're interested in displaying individual Char objects, so 
               ' we don't want a Unicode BOM or exceptions to be thrown on
               ' invalid Char values.
               Console.OutputEncoding = New UnicodeEncoding(Not BitConverter.IsLittleEndian, False) 
               Console.WriteLine("{0}Output encoding set to UTF-16", vbCrLf)
            Catch e As IOException
               Console.OutputEncoding = New UTF8Encoding()
               Console.WriteLine("Output encoding set to UTF-8")
            End Try
         Else
            Console.WriteLine("The console encoding is {0} (code page {1})", 
                              Console.OutputEncoding.EncodingName,
                              Console.OutputEncoding.CodePage)
         End If
         DisplayRange(rangeStart, rangeEnd)
      Catch ex As ArgumentException
         Console.WriteLine(ex.Message)
      Finally
         ' Restore console environment.
         Console.OutputEncoding = originalOutputEncoding
      End Try
   End Sub

   Public Sub DisplayRange(rangeStart As UInteger, rangeEnd As UInteger)
      Const upperRange As UInteger = &h10FFFF
      Const surrogateStart As UInteger = &hD800
      Const surrogateEnd As UInteger = &hDFFF
       
      If rangeEnd <= rangeStart Then
         Dim t As UInteger = rangeStart
         rangeStart = rangeEnd
         rangeEnd = t
      End If

      ' Check whether the start or end range is outside of last plane.
      If rangeStart > upperRange Then
         Throw New ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{1:X5})",
                                                   rangeStart, upperRange))                                   
      End If
      If rangeEnd > upperRange Then
         Throw New ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{0:X5})",
                                                   rangeEnd, upperRange))
      End If
      ' Since we're using 21-bit code points, we can't use U+D800 to U+DFFF.
      If (rangeStart < surrogateStart And rangeEnd > surrogateStart) OrElse (rangeStart >= surrogateStart And rangeStart <= surrogateEnd )
         Throw New ArgumentException(String.Format("0x{0:X5}-0x{1:X5} includes the surrogate pair range 0x{2:X5}-0x{3:X5}", 
                                                   rangeStart, rangeEnd, surrogateStart, surrogateEnd))         
      End If
      
      Dim last As UInteger = RoundUpToMultipleOf(&h10, rangeEnd)
      Dim first As UInteger = RoundDownToMultipleOf(&h10, rangeStart)

      Dim rows As UInteger = (last - first) \ &h10

      For r As UInteger = 0 To rows - 1
         ' Display the row header.
         Console.Write("{0:x5} ", first + &h10 * r)

         For c As UInteger = 1 To &h10
            Dim cur As UInteger = first + &h10 * r + c
            If cur  < rangeStart Then
               Console.Write(" {0} ", Convert.ToChar(&h20))
            Else If rangeEnd < cur Then
               Console.Write(" {0} ", Convert.ToChar(&h20))
            Else 
               ' the cast to int is safe, since we know that val <= upperRange.
               Dim chars As String = Char.ConvertFromUtf32(CInt(cur))
               ' Display a space for code points that are not valid characters.
               If CharUnicodeInfo.GetUnicodeCategory(chars(0)) = 
                                   UnicodeCategory.OtherNotAssigned Then
                  Console.Write(" {0} ", Convert.ToChar(&h20))
               ' Display a space for code points in the private use area.
               Else If CharUnicodeInfo.GetUnicodeCategory(chars(0)) =
                                        UnicodeCategory.PrivateUse Then
                 Console.Write(" {0} ", Convert.ToChar(&h20))
               ' Is surrogate pair a valid character?
               ' Note that the console will interpret the high and low surrogate
               ' as separate (and unrecognizable) characters.
               Else If chars.Length > 1 AndAlso CharUnicodeInfo.GetUnicodeCategory(chars, 0) = 
                                            UnicodeCategory.OtherNotAssigned Then
                  Console.Write(" {0} ", Convert.ToChar(&h20))
               Else
                  Console.Write(" {0} ", chars) 
               End If   
            End If
            
            Select Case c
               Case 3, 11
                  Console.Write("-")
               Case 7
                  Console.Write("--")
            End Select
         Next

         Console.WriteLine()
         If 0 < r AndAlso r Mod &h10 = 0
            Console.WriteLine()
         End If
      Next
   End Sub

   Private Function RoundUpToMultipleOf(b As UInteger, u As UInteger) As UInteger
      Return RoundDownToMultipleOf(b, u) + b
   End Function

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

open System
open System.IO
open System.Globalization
open System.Text

type uint = uint32

let inline roundDownToMultipleOf b u = u - (u % b)

let inline roundUpToMultipleOf b u = roundDownToMultipleOf b u |> (+) b

let displayRange (start: uint) (``end``: uint) =

    let upperRange = 0x10FFFFu
    let surrogateStart = 0xD800u
    let surrogateEnd = 0xDFFFu

    let start, ``end`` =
        if ``end`` <= start then ``end``, start
        else start, ``end``

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

    // Since we're using 21-bit code points, we can't use U+D800 to U+DFFF.
    if ((start < surrogateStart && ``end`` > surrogateStart) || (start >= surrogateStart && start <= surrogateEnd)) then
        raise
            (ArgumentException
                (String.Format
                    ("0x{0:X5}-0x{1:X5} includes the surrogate pair range 0x{2:X5}-0x{3:X5}", start, ``end``,
                     surrogateStart, surrogateEnd)))
    let last = roundUpToMultipleOf 0x10u ``end``
    let first = roundDownToMultipleOf 0x10u start

    let rows = (last - first) / 0x10u

    for r in 0u .. (rows - 1u) do
        // Display the row header.
        printf "%05x " (first + 0x10u * r)

        for c in 0u .. (0x10u - 1u) do
            let cur = (first + 0x10u * r + c)
            if cur < start || ``end`` < cur then
                printf " %c " (Convert.ToChar 0x20)
            else
                // the cast to int is safe, since we know that val <= upperRange.
                let chars = Char.ConvertFromUtf32((int) cur)
                // Display a space for code points that are not valid characters.
                if CharUnicodeInfo.GetUnicodeCategory(chars.[0]) = UnicodeCategory.OtherNotAssigned then
                    printf " %c " (Convert.ToChar 0x20)
                else
                    // Display a space for code points in the private use area.
                    if CharUnicodeInfo.GetUnicodeCategory(chars.[0]) = UnicodeCategory.PrivateUse then
                        printf " %c " (Convert.ToChar 0x20)
                    else if chars.Length > 1
                            && CharUnicodeInfo.GetUnicodeCategory(chars, 0) = UnicodeCategory.OtherNotAssigned then
                        printf " %c " (Convert.ToChar 0x20)
                    else printf " %s " chars

            match c with
            | 3u
            | 11u -> printf "-"
            | 7u -> printf "--"
            | _ -> ()

        Console.WriteLine()
        if (0u < r && r % 0x10u = 0u) then Console.WriteLine()



[<EntryPoint>]
let main args =
    // Get the current encoding so we can restore it.
    let originalOutputEncoding = Console.OutputEncoding

    try
        try
            let parsedArgs =
                match args.Length with
                | 2 ->
                    Some
                        {| setOutputEncodingToUnicode = true
                           rangeStart = uint.Parse(args.[0], NumberStyles.HexNumber)
                           rangeEnd = uint.Parse(args.[1], NumberStyles.HexNumber) |}
                | 3 ->
                    let parseHexNumberOrThrow (value: string) parameterName =
                        (uint.TryParse(value, NumberStyles.HexNumber, null))
                        |> function
                        | (false, _) ->
                            invalidArg parameterName (String.Format("{0} is not a valid hexadecimal number.", value))
                        | (true, value) -> value

                    let setOutputEncodingToUnicode =
                        match bool.TryParse args.[2] with
                        | true, value -> value
                        | false, _ -> true

                    Some
                        {| setOutputEncodingToUnicode = setOutputEncodingToUnicode
                           rangeStart = parseHexNumberOrThrow args.[0] "rangeStart"
                           rangeEnd = parseHexNumberOrThrow args.[1] "rangeEnd" |}
                | _ ->
                    printfn "Usage: %s <%s> <%s> [%s]" (Environment.GetCommandLineArgs().[0]) "startingCodePointInHex"
                        "endingCodePointInHex" "<setOutputEncodingToUnicode?{true|false, default:false}>"
                    None

            match parsedArgs with
            | None -> ()
            | Some parsedArgs ->
                if parsedArgs.setOutputEncodingToUnicode then
                    // This won't work before .NET Framework 4.5.
                    try
                        // Set encoding using endianness of this system.
                        // We're interested in displaying individual Char objects, so
                        // we don't want a Unicode BOM or exceptions to be thrown on
                        // invalid Char values.
                        Console.OutputEncoding <- UnicodeEncoding(not BitConverter.IsLittleEndian, false)
                        printfn "\nOutput encoding set to UTF-16"

                    with :? IOException ->
                        printfn "Output encoding set to UTF-8"
                        Console.OutputEncoding <- UTF8Encoding()
                else
                    printfn "The console encoding is %s (code page %i)" (Console.OutputEncoding.EncodingName)
                        (Console.OutputEncoding.CodePage)

                displayRange parsedArgs.rangeStart parsedArgs.rangeEnd
        with :? ArgumentException as ex -> Console.WriteLine(ex.Message)
    finally
        // Restore console environment.
        Console.OutputEncoding <- originalOutputEncoding
    0

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

Typowe operacjeCommon Operations

Klasa Console zawiera następujące metody odczytywania danych wejściowych konsoli i pisania danych wyjściowych konsoli:The Console class contains the following methods for reading console input and writing console output:

  • Przeciążenia metody ReadKey odczytywać pojedynczy znak.The overloads of the ReadKey method read an individual character.

  • Metoda ReadLine odczytuje cały wiersz danych wejściowych.The ReadLine method reads an entire line of input.

  • Przeciążenia metody Write konwertują wystąpienie typu wartości, tablicę znaków lub zestaw obiektów na sformatowany lub niesformatowany ciąg, a następnie napisz ten ciąg do konsoli.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.

  • Równoległy zestaw WriteLine przeciążania metody wyprowadza ten sam ciąg co Write overloads, ale również dodaje ciąg zakończenia wiersza.A parallel set of WriteLine method overloads output the same string as the Write overloads but also add a line termination string.

Klasa Console zawiera również metody i właściwości, które umożliwiają wykonywanie następujących operacji:The Console class also contains methods and properties to perform the following operations:

  • Pobierz lub ustaw rozmiar buforu ekranu.Get or set the size of the screen buffer. Właściwości BufferHeight i BufferWidth umożliwiają pobieranie lub ustawianie odpowiednio wysokości i szerokości bufora, a metoda SetBufferSize pozwala ustawić rozmiar buforu w wywołaniu pojedynczej metody.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.

  • Pobierz lub ustaw rozmiar okna konsoli.Get or set the size of the console window. Właściwości WindowHeight i WindowWidth pozwalają uzyskać lub ustawić odpowiednio wysokość i szerokość okna, a metoda SetWindowSize umożliwia ustawienie rozmiaru okna w jednym wywołaniu metody.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.

  • Pobierz lub ustaw rozmiar kursora.Get or set the size of the cursor. Właściwość CursorSize określa wysokość kursora w komórce znaku.The CursorSize property specifies the height of the cursor in a character cell.

  • Pobierz lub Ustaw położenie okna konsoli względem buforu ekranu.Get or set the position of the console window relative to the screen buffer. Właściwości WindowTop i WindowLeft umożliwiają pobieranie lub Ustawianie górnego wiersza i kolumny z lewej strony buforu ekranu, które pojawiają się w oknie konsoli, a metoda SetWindowPosition pozwala ustawić te wartości w jednym wywołaniu metody.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.

  • Pobierz lub Ustaw położenie kursora przez pobranie lub ustawienie właściwości CursorTop i CursorLeft albo ustawienie pozycji kursora przez wywołanie metody SetCursorPosition.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.

  • Przenieś lub Wyczyść dane w buforze ekranu, wywołując metodę MoveBufferArea lub Clear.Move or clear data in the screen buffer by calling the MoveBufferArea or Clear method.

  • Pobierz lub Ustaw kolory pierwszego planu i tła przy użyciu właściwości ForegroundColor i BackgroundColor lub zresetuj tło i pierwszy plan do domyślnych kolorów, wywołując metodę ResetColor.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.

  • Odtwórz dźwięk sygnału dźwiękowego przez prelegenta konsoli, wywołując metodę Beep.Play the sound of a beep through the console speaker by calling the Beep method.

Notatki .NET Core.NET Core.NET Core.NET Core Notes

W .NET Framework na pulpicie Klasa Console używa kodowania zwracanego przez GetConsoleCP i GetConsoleOutputCP, który zazwyczaj jest kodowaniem strony kodowej.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. Na przykład kod, w systemach, których kultura jest angielski (Stany Zjednoczone), strona kodowa 437 jest kodowaniem, które jest używane domyślnie.For example code, on systems whose culture is English (United States), code page 437 is the encoding that is used by default. Jednak w .NET Core.NET Core mogą być dostępne tylko ograniczone podzbiór tych kodowań.However, .NET Core.NET Core may make only a limited subset of these encodings available. W takim przypadku Encoding.UTF8 jest używany jako domyślne kodowanie dla konsoli programu.Where this is the case, Encoding.UTF8 is used as the default encoding for the console.

Jeśli aplikacja zależy od określonych kodowań stron kodowych, można nadal udostępnić je, wykonując następujące czynności przed wywołaniem Console metod: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. Dodaj odwołanie do zestawu System. Text. Encoding. CodePage. dll do projektu.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Pobierz obiekt EncodingProvider ze właściwości CodePagesEncodingProvider.Instance.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Przekaż obiekt EncodingProvider do metody Encoding.RegisterProvider, aby udostępnić dodatkowe kodowanie obsługiwane przez dostępnego dostawcę kodowania.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

Klasa Console będzie wtedy automatycznie używać domyślnego kodowania systemowego zamiast UTF8, pod warunkiem, że zarejestrowano dostawcę kodowania przed wywołaniem jakichkolwiek metod Console wyjściowych.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.

Właściwości

BackgroundColor

Pobiera lub ustawia kolor tła konsoli.Gets or sets the background color of the console.

BufferHeight

Pobiera lub ustawia wysokość obszaru bufora.Gets or sets the height of the buffer area.

BufferWidth

Pobiera lub ustawia szerokość obszaru bufora.Gets or sets the width of the buffer area.

CapsLock

Pobiera wartość wskazującą, czy przełącznik klawiatury Caps Lock jest włączony, czy wyłączony.Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft

Pobiera lub ustawia położenie kolumny kursora w obszarze buforu.Gets or sets the column position of the cursor within the buffer area.

CursorSize

Pobiera lub ustawia wysokość kursora w komórce znaku.Gets or sets the height of the cursor within a character cell.

CursorTop

Pobiera lub ustawia położenie wiersza kursora w obszarze buforu.Gets or sets the row position of the cursor within the buffer area.

CursorVisible

Pobiera lub ustawia wartość wskazującą, czy kursor jest widoczny.Gets or sets a value indicating whether the cursor is visible.

Error

Pobiera strumień wyjściowy błędu standardowego.Gets the standard error output stream.

ForegroundColor

Pobiera lub ustawia kolor pierwszego planu konsoli.Gets or sets the foreground color of the console.

In

Pobiera standardowy strumień wejściowy.Gets the standard input stream.

InputEncoding

Pobiera lub ustawia kodowanie używane przez konsolę do odczytu danych wejściowych.Gets or sets the encoding the console uses to read input.

IsErrorRedirected

Pobiera wartość wskazującą, czy strumień wyjściowy błędu został przekierowany ze standardowego strumienia błędów.Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected

Pobiera wartość wskazującą, czy dane wejściowe zostały przekierowane ze standardowego strumienia wejściowego.Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected

Pobiera wartość wskazującą, czy dane wyjściowe zostały przekierowane ze standardowego strumienia wyjściowego.Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable

Pobiera wartość wskazującą, czy naciśnięcie klawisza jest dostępne w strumieniu wejściowym.Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight

Pobiera największą możliwą liczbę wierszy okna konsoli na podstawie bieżącej rozdzielczości czcionki i ekranu.Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth

Pobiera największą możliwą liczbę kolumn okna konsoli na podstawie bieżącej rozdzielczości czcionki i ekranu.Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock

Pobiera wartość wskazującą, czy przełącznik klawiatury NUM LOCK jest włączony, czy wyłączony.Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out

Pobiera standardowy strumień wyjściowy.Gets the standard output stream.

OutputEncoding

Pobiera lub ustawia kodowanie używane przez konsolę do zapisywania danych wyjściowych.Gets or sets the encoding the console uses to write output.

Title

Pobiera lub ustawia tytuł, który ma być wyświetlany na pasku tytułu konsoli.Gets or sets the title to display in the console title bar.

TreatControlCAsInput

Pobiera lub ustawia wartość wskazującą, czy kombinacja klucza modyfikatora Control i klucza konsoli C (Ctrl + C) jest traktowana jako zwykła wartość wejściowa, czy jako przerwanie obsługiwane przez system operacyjny.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

Pobiera lub ustawia wysokość obszaru okna konsoli.Gets or sets the height of the console window area.

WindowLeft

Pobiera lub ustawia pozycję z lewej strony obszaru okna konsoli względem buforu ekranu.Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop

Pobiera lub ustawia górną pozycję obszaru okna konsoli względem buforu ekranu.Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth

Pobiera lub ustawia szerokość okna konsoli.Gets or sets the width of the console window.

Metody

Beep()

Odtwarza dźwięk sygnału dźwiękowego przez prelegenta konsoli.Plays the sound of a beep through the console speaker.

Beep(Int32, Int32)

Odtwarza dźwięk sygnału dźwiękowego z określoną częstotliwością i czasem trwania przez prelegenta konsoli.Plays the sound of a beep of a specified frequency and duration through the console speaker.

Clear()

Czyści bufor konsoli i odpowiednie okno konsoli zawierające informacje o wyświetlaniu.Clears the console buffer and corresponding console window of display information.

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

Kopiuje określony obszar źródłowy buforu ekranu do określonego obszaru docelowego.Copies a specified source area of the screen buffer to a specified destination area.

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

Kopiuje określony obszar źródłowy buforu ekranu do określonego obszaru docelowego.Copies a specified source area of the screen buffer to a specified destination area.

OpenStandardError()

Uzyskuje standardowy strumień błędów.Acquires the standard error stream.

OpenStandardError(Int32)

Uzyskuje standardowy strumień błędów, który jest ustawiony na określony rozmiar buforu.Acquires the standard error stream, which is set to a specified buffer size.

OpenStandardInput()

Uzyskuje standardowy strumień wejściowy.Acquires the standard input stream.

OpenStandardInput(Int32)

Uzyskuje standardowy strumień wejściowy, który jest ustawiony na określony rozmiar buforu.Acquires the standard input stream, which is set to a specified buffer size.

OpenStandardOutput()

Uzyskuje standardowy strumień wyjściowy.Acquires the standard output stream.

OpenStandardOutput(Int32)

Uzyskuje standardowy strumień wyjściowy, który jest ustawiony na określony rozmiar buforu.Acquires the standard output stream, which is set to a specified buffer size.

Read()

Odczytuje następny znak ze standardowego strumienia wejściowego.Reads the next character from the standard input stream.

ReadKey()

Pobiera następny znak lub funkcję wskutek naciśnięcia klawisza przez użytkownika.Obtains the next character or function key pressed by the user. Naciśnięty klawisz jest wyświetlany w oknie konsoli.The pressed key is displayed in the console window.

ReadKey(Boolean)

Pobiera następny znak lub funkcję wskutek naciśnięcia klawisza przez użytkownika.Obtains the next character or function key pressed by the user. Naciśnięty klawisz jest opcjonalnie wyświetlany w oknie konsoli.The pressed key is optionally displayed in the console window.

ReadLine()

Odczytuje następny wiersz znaków ze standardowego strumienia wejściowego.Reads the next line of characters from the standard input stream.

ResetColor()

Ustawia ustawienia domyślne kolorów pierwszego planu i konsoli w tle.Sets the foreground and background console colors to their defaults.

SetBufferSize(Int32, Int32)

Ustawia wysokość i szerokość obszaru buforu ekranu na określone wartości.Sets the height and width of the screen buffer area to the specified values.

SetCursorPosition(Int32, Int32)

Ustawia pozycję kursora.Sets the position of the cursor.

SetError(TextWriter)

Ustawia właściwość Error na określony obiekt TextWriter.Sets the Error property to the specified TextWriter object.

SetIn(TextReader)

Ustawia właściwość In na określony obiekt TextReader.Sets the In property to the specified TextReader object.

SetOut(TextWriter)

Ustawia właściwość Out na obiekt docelowy obiektu TextWriter.Sets the Out property to target the TextWriter object.

SetWindowPosition(Int32, Int32)

Ustawia pozycję okna konsoli względem buforu ekranu.Sets the position of the console window relative to the screen buffer.

SetWindowSize(Int32, Int32)

Ustawia wysokość i szerokość okna konsoli na określone wartości.Sets the height and width of the console window to the specified values.

Write(Boolean)

Zapisuje tekstową reprezentację określonej wartości logicznej w standardowym strumieniu wyjściowym.Writes the text representation of the specified Boolean value to the standard output stream.

Write(Char)

Zapisuje określoną wartość znaku Unicode w standardowym strumieniu wyjściowym.Writes the specified Unicode character value to the standard output stream.

Write(Char[])

Zapisuje określoną tablicę znaków Unicode w standardowym strumieniu wyjściowym.Writes the specified array of Unicode characters to the standard output stream.

Write(Char[], Int32, Int32)

Zapisuje określoną podtablicę znaków Unicode w standardowym strumieniu wyjściowym.Writes the specified subarray of Unicode characters to the standard output stream.

Write(Decimal)

Zapisuje tekstową reprezentację określonej Decimal wartości w standardowym strumieniu wyjściowym.Writes the text representation of the specified Decimal value to the standard output stream.

Write(Double)

Zapisuje tekstową reprezentację określonej wartości zmiennoprzecinkowej podwójnej precyzji w standardowym strumieniu wyjściowym.Writes the text representation of the specified double-precision floating-point value to the standard output stream.

Write(Int32)

Zapisuje tekstową reprezentację określonej 32-bitowej wartości całkowitej ze znakiem w standardowym strumieniu wyjściowym.Writes the text representation of the specified 32-bit signed integer value to the standard output stream.

Write(Int64)

Zapisuje tekstową reprezentację określonej 64-bitowej wartości całkowitej ze znakiem w standardowym strumieniu wyjściowym.Writes the text representation of the specified 64-bit signed integer value to the standard output stream.

Write(Object)

Zapisuje tekstową reprezentację określonego obiektu w standardowym strumieniu wyjściowym.Writes the text representation of the specified object to the standard output stream.

Write(Single)

Zapisuje tekstową reprezentację określonej wartości zmiennoprzecinkowej o pojedynczej precyzji w standardowym strumieniu wyjściowym.Writes the text representation of the specified single-precision floating-point value to the standard output stream.

Write(String)

Zapisuje określoną wartość ciągu w standardowym strumieniu wyjściowym.Writes the specified string value to the standard output stream.

Write(String, Object)

Zapisuje tekstową reprezentację określonego obiektu w standardowym strumieniu wyjściowym przy użyciu informacji o określonym formacie.Writes the text representation of the specified object to the standard output stream using the specified format information.

Write(String, Object, Object)

Zapisuje tekstową reprezentację określonych obiektów w standardowym strumieniu wyjściowym przy użyciu informacji o określonym formacie.Writes the text representation of the specified objects to the standard output stream using the specified format information.

Write(String, Object, Object, Object)

Zapisuje tekstową reprezentację określonych obiektów w standardowym strumieniu wyjściowym przy użyciu informacji o określonym formacie.Writes the text representation of the specified objects to the standard output stream using the specified format information.

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

Zapisuje tekstową reprezentację określonych obiektów i listę parametrów o zmiennej długości do standardowego strumienia wyjściowego przy użyciu informacji o określonym formacie.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[])

Zapisuje tekstową reprezentację określonej tablicy obiektów w standardowym strumieniu wyjściowym przy użyciu określonych informacji o formacie.Writes the text representation of the specified array of objects to the standard output stream using the specified format information.

Write(UInt32)

Zapisuje tekstową reprezentację określonej 32-bitowej nieoznaczonej liczby całkowitej do standardowego strumienia wyjściowego.Writes the text representation of the specified 32-bit unsigned integer value to the standard output stream.

Write(UInt64)

Zapisuje tekstową reprezentację określonej 64-bitowej nieoznaczonej liczby całkowitej do standardowego strumienia wyjściowego.Writes the text representation of the specified 64-bit unsigned integer value to the standard output stream.

WriteLine()

Zapisuje bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the current line terminator to the standard output stream.

WriteLine(Boolean)

Zapisuje tekstową reprezentację określonej wartości logicznej oraz terminatora bieżącego wiersza w standardowym strumieniu wyjściowym.Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

WriteLine(Char)

Zapisuje określony znak Unicode, a po nim bieżący terminator wiersza, wartość do standardowego strumienia wyjściowego.Writes the specified Unicode character, followed by the current line terminator, value to the standard output stream.

WriteLine(Char[])

Zapisuje określoną tablicę znaków Unicode, a po niej bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the specified array of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(Char[], Int32, Int32)

Zapisuje określoną podtablicę znaków Unicode, a po niej bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the specified subarray of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(Decimal)

Zapisuje tekstową reprezentację określonej Decimal wartości, a następnie bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the text representation of the specified Decimal value, followed by the current line terminator, to the standard output stream.

WriteLine(Double)

Zapisuje tekstową reprezentację określonej wartości zmiennoprzecinkowej podwójnej precyzji, a następnie bieżący terminator wiersza do standardowego strumienia wyjściowego.Writes the text representation of the specified double-precision floating-point value, followed by the current line terminator, to the standard output stream.

WriteLine(Int32)

Zapisuje tekstową reprezentację określonej 32-bitowej podpisanej wartości całkowitej, a po niej bieżący terminator wiersza do standardowego strumienia wyjściowego.Writes the text representation of the specified 32-bit signed integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Int64)

Zapisuje tekstową reprezentację określonej 64-bitowej podpisanej wartości całkowitej, a po niej bieżący terminator wiersza do standardowego strumienia wyjściowego.Writes the text representation of the specified 64-bit signed integer value, followed by the current line terminator, to the standard output stream.

WriteLine(Object)

Zapisuje tekstową reprezentację określonego obiektu, a następnie bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream.

WriteLine(Single)

Zapisuje tekstową reprezentację określonej wartości zmiennoprzecinkowej o pojedynczej precyzji, a następnie bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the text representation of the specified single-precision floating-point value, followed by the current line terminator, to the standard output stream.

WriteLine(String)

Zapisuje określoną wartość ciągu, a po niej bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the specified string value, followed by the current line terminator, to the standard output stream.

WriteLine(String, Object)

Zapisuje tekstową reprezentację określonego obiektu, a następnie bieżący terminator wiersza w standardowym strumieniu wyjściowym przy użyciu informacji o określonym formacie.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(String, Object, Object)

Zapisuje tekstową reprezentację określonych obiektów, a następnie bieżący terminator wiersza w standardowym strumieniu wyjściowym przy użyciu informacji o określonym formacie.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, Object, Object, Object)

Zapisuje tekstową reprezentację określonych obiektów, a następnie bieżący terminator wiersza w standardowym strumieniu wyjściowym przy użyciu informacji o określonym formacie.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, Object, Object, Object, Object)

Zapisuje tekstową reprezentację określonych obiektów i listę parametrów o zmiennej długości, a następnie bieżący terminator wiersza w standardowym strumieniu wyjściowym przy użyciu określonych informacji o formacie.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.

WriteLine(String, Object[])

Zapisuje tekstową reprezentację określonej tablicy obiektów, a po niej bieżący terminator wiersza, w standardowym strumieniu wyjściowym, korzystając z informacji o określonym formacie.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(UInt32)

Zapisuje tekstową reprezentację określonej 32-bitowej nieoznaczonej liczby całkowitej, a po niej bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the text representation of the specified 32-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

WriteLine(UInt64)

Zapisuje tekstową reprezentację określonej 64-bitowej nieoznaczonej liczby całkowitej, a po niej bieżący terminator wiersza w standardowym strumieniu wyjściowym.Writes the text representation of the specified 64-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

Zdarzenia

CancelKeyPress

Występuje po naciśnięciu klawisza modyfikującego Control (Ctrl) i klawisza C Console (C) lub klawisza Break (Ctrl + C lub Ctrl + Break).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).

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.This type is thread safe.