Console クラス

定義

コンソール アプリケーションの標準入力ストリーム、標準出力ストリーム、および標準エラー ストリームを表します。Represents the standard input, output, and error streams for console applications. このクラスは継承できません。This class cannot be inherited.

public ref class Console abstract sealed
public ref class Console sealed
public static class Console
public sealed class Console
type Console = class
Public Class Console
Public NotInheritable Class Console
継承
Console

次の例では、標準入力ストリームと出力ストリームに対してデータの読み取りと書き込みを行う方法を示します。The following example demonstrates how to read data from, and write data to, the standard input and output streams. これらのストリームは、SetIn および 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!

注釈

コンソールは、ユーザーがオペレーティングシステムと対話するオペレーティングシステムウィンドウであり、コンピューターのキーボードを使用してテキスト入力を入力することによって、またはコンピューターのターミナルからテキストの出力を読み取ることによって、テキストベースのコンソールアプリケーションと対話します。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. たとえば、Windows オペレーティングシステムでは、コンソールはコマンドプロンプトウィンドウと呼ばれ、MS-DOS コマンドを受け取ります。For example, in the Windows operating system, the console is called the Command Prompt window and accepts MS-DOS commands. Console クラスは、コンソールから文字を読み取ったり、コンソールに文字を書き込んだりするアプリケーションの基本的なサポートを提供します。The Console class provides basic support for applications that read characters from, and write characters to, the console.

Console クラスを使用した開発の詳細については、次のセクションを参照してください。For information about developing with the Console class, see the following sections:

コンソール i/o ストリームConsole I/O Streams

コンソールアプリケーションが起動すると、オペレーティングシステムによって自動的に3つの i/o ストリームがコンソールに関連付けられます。これは、標準入力ストリーム、標準出力ストリーム、および標準エラー出力ストリームです。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. アプリケーションでは、標準入力ストリームからユーザー入力を読み取ることができます。標準出力ストリームに通常のデータを書き込みます。とは、エラーデータを標準エラー出力ストリームに書き込みます。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. これらのストリームは、Console.InConsole.Out、および Console.Error プロパティの値としてアプリケーションに提示されます。These streams are presented to your application as the values of the Console.In, Console.Out, and Console.Error properties.

既定では、In プロパティの値は、キーボードを表す System.IO.TextReader オブジェクトであり、Out プロパティと Error プロパティの値は、コンソールウィンドウを表すオブジェクト System.IO.TextWriter ます。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. ただし、これらのプロパティは、コンソールウィンドウまたはキーボードを表さないストリームに設定できます。たとえば、これらのプロパティは、ファイルを表すストリームに設定できます。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. 標準入力、標準出力、または標準エラーストリームをリダイレクトするには、それぞれ Console.SetInConsole.SetOut、または Console.SetError メソッドを呼び出します。To redirect the standard input, standard output, or standard error stream, call the Console.SetIn, Console.SetOut, or Console.SetError method, respectively. これらのストリームを使用する i/o 操作は同期されます。つまり、複数のスレッドがストリームの読み取りまたは書き込みを行うことができます。I/O operations that use these streams are synchronized, which means that multiple threads can read from, or write to, the streams. これは、オブジェクトがコンソールストリームを表す場合に、通常は非同期のメソッド (TextReader.ReadLineAsyncなど) が同期的に実行されることを意味します。This means that methods that are ordinarily asynchronous, such as TextReader.ReadLineAsync, execute synchronously if the object represents a console stream.

注意

Console クラスを使用して、サーバーアプリケーションなどの無人アプリケーションで出力を表示することは避けてください。Do not use the Console class to display output in unattended applications, such as server applications. Console.WriteConsole.WriteLine などのメソッドの呼び出しは、GUI アプリケーションには影響しません。Calls to methods such as Console.Write and Console.WriteLine have no effect in GUI applications.

基になるストリームがコンソールに送られたときに正常に動作するクラスメンバー Console、ストリームがファイルなどにリダイレクトされると、例外がスローされることがあります。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. 標準ストリームをリダイレクトする場合に System.IO.IOException 例外をキャッチするようにアプリケーションをプログラミングします。Program your application to catch System.IO.IOException exceptions if you redirect a standard stream. また、IsOutputRedirectedIsInputRedirected、および IsErrorRedirected の各プロパティを使用して、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.

InOut、および Error プロパティによって表されるストリームオブジェクトのメンバーを明示的に呼び出すと便利な場合があります。It is sometimes useful to explicitly call the members of the stream objects represented by the In, Out, and Error properties. たとえば、既定では、Console.ReadLine メソッドは標準入力ストリームから入力を読み取ります。For example, by default, the Console.ReadLine method reads input from the standard input stream. 同様に、Console.WriteLine メソッドはデータを標準出力ストリームに書き込み、その後に既定の行終了文字列 (復帰とラインフィード ("\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"). ただし、Console クラスには、標準エラー出力ストリームにデータを書き込むための対応するメソッドが用意されていません。また、プロパティを使用して、そのストリームに書き込まれるデータの行終了文字列を変更することもできません。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.

この問題を解決するには、Out または Error プロパティの TextWriter.NewLine プロパティを別の行の終了文字列に設定します。You can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. たとえば、次C#のステートメントは、標準エラー出力ストリームの行終了文字列を、2つの復帰とラインフィードシーケンスに設定します。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";

その後、次C#のステートメントのように、エラー出力ストリームオブジェクトの WriteLine メソッドを明示的に呼び出すことができます。You can then explicitly call the WriteLine method of the error output stream object, as in the following C# statement:

Console.Error.WriteLine();

画面バッファーとコンソールウィンドウScreen Buffer and Console Window

コンソールの2つの密接に関連する機能は、画面バッファーとコンソールウィンドウです。Two closely related features of the console are the screen buffer and the console window. テキストは、実際にはコンソールによって所有されているストリームの読み取りまたは書き込みを行いますが、コンソールが所有する領域に対しては、画面バッファーと呼ばれるように見えます。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. 画面バッファーは、コンソールの属性であり、各グリッドの交差部分または文字セルに文字を含めることができる、行と列の四角形のグリッドとして構成されています。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. 各文字には独自の前景色があり、各文字セルには独自の背景色があります。Each character has its own foreground color, and each character cell has its own background color.

画面バッファーは、コンソールウィンドウと呼ばれる四角形の領域から表示されます。The screen buffer is viewed through a rectangular region called the console window. コンソールウィンドウは、コンソールのもう1つの属性です。これは、オペレーティングシステムウィンドウであるコンソール自体ではありません。The console window is another attribute of the console; it is not the console itself, which is an operating system window. コンソールウィンドウは、画面バッファーのサイズ以下の行と列に配置されています。移動すると、基になる画面バッファーのさまざまな領域を表示できます。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. 画面バッファーがコンソールウィンドウよりも大きい場合は、コンソールウィンドウを画面バッファー領域の上に移動できるように、コンソールに自動的にスクロールバーが表示されます。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.

カーソルは、テキストが現在読み取られている、または書き込んでいる画面バッファーの位置を示します。A cursor indicates the screen buffer position where text is currently read or written. カーソルは非表示にしたり表示したりすることができ、その高さを変更できます。The cursor can be hidden or made visible, and its height can be changed. カーソルが表示されている場合は、カーソルが常に表示されるように、コンソールウィンドウの位置が自動的に移動されます。If the cursor is visible, the console window position is moved automatically so the cursor is always in view.

画面バッファー内の文字セル座標の原点は左上隅で、カーソルとコンソールウィンドウの位置はその原点を基準にして測定されます。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. 位置を指定するには、0から始まるインデックスを使用します。つまり、最上位の行を行0、左端の列を列0として指定します。Use zero-based indexes to specify positions; that is, specify the topmost row as row 0, and the leftmost column as column 0. 行インデックスと列インデックスの最大値は Int16.MaxValueです。The maximum value for the row and column indexes is Int16.MaxValue.

コンソールの Unicode サポートUnicode Support for the Console

一般に、コンソールは、現在のコンソールのコードページを使用して、入力を読み取り、出力を書き込みます。システムロケールは、既定で定義されます。In general, the console reads input and writes output by using the current console code page, which the system locale defines by default. コードページは、使用可能な Unicode 文字のサブセットのみを処理できるため、特定のコードページによってマップされていない文字を表示しようとしても、コンソールはすべての文字を表示したり、正確に表現したりすることはできません。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. この問題を説明する例を次に示します。The following example illustrates this problem. このメソッドは、U + 0410 から U + 044F までのキリル文字をコンソールに表示しようとします。It tries to display the characters of the Cyrillic alphabet from U+0410 to U+044F to the console. コンソールコードページ437を使用するシステムでこの例を実行した場合、キリル文字はコードページ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
//
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
//    ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?

Console クラスでは、コードページのサポートに加えて、UTF8Encoding クラスを使用した UTF-8 エンコードがサポートされています。In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. .NET Framework 4.5 以降では、Console クラスは UnicodeEncoding クラスを使用した UTF-16 エンコードもサポートしています。Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. を入力すると、Unicode 文字がコンソールに表示されます。To display Unicode characters to the console. OutputEncoding プロパティを UTF8Encoding または UnicodeEncodingに設定します。you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

Unicode 文字をサポートするには、エンコーダーが特定の Unicode 文字を認識する必要があります。また、その文字を表示するために必要なグリフを持つフォントも必要です。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. コンソールに Unicode 文字を正しく表示するには、コンソールのフォントを非ラスターまたは TrueType フォント (Consolas, や 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. 次の例では、ラスターフォントのフォントを 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
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

ただし、TrueType フォントでは、グリフのサブセットのみを表示できます。However, TrueType fonts can display only a subset of glyphs. たとえば、Lucida コンソールのフォントでは、U + 0021 から U + FB02 までの使用可能な約64000文字が643だけが表示されます。For example, the Lucida Console font displays only 643 of the approximately 64,000 available characters from U+0021 to U+FB02. 特定のフォントでサポートされている文字を確認するには、コントロールパネルの [フォント] アプレットを開き、[文字の検索] オプションを選択します。次に、文字マップウィンドウの [フォント] の一覧で、検査する文字セットのフォントを選択します。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 では、フォントリンクを使用して、特定のフォントで使用できないグリフが表示されます。Windows uses font linking to display glyphs that are not available in a particular font. 追加の文字セットを表示するためのフォントリンクの詳細については、「グローバリゼーションのステップバイステップ: フォント」を参照してください。For information about font linking to display additional character sets, see Globalization Step-by-Step: Fonts. リンクされたフォントは、レジストリの 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. このサブキーに関連付けられている各エントリは、基本フォントの名前に対応します。その値は、フォントファイルと、基本フォントにリンクされているフォントを定義する文字列配列です。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. 配列の各メンバーは、リンクされたフォントを定義し、フォントファイル名フォント名の形式をとります。Each member of the array defines a linked font and takes the form font-file-name,font-name. 次の例では、簡略化された文字を表示する .ttc という名前のフォントファイルで、簡単に使用できるリンクされたフォントをプログラムによって定義する方法を示します。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
    

コンソールの Unicode サポートには、次の制限があります。Unicode support for the console has the following limitations:

  • 32 UTF-8 エンコードはサポートされていません。UTF-32 encoding is not supported. サポートされている Unicode エンコーディングは、UTF-8 と UTF-16 だけです。これは、それぞれ UTF8Encoding クラスと UnicodeEncoding クラスによって表されます。The only supported Unicode encodings are UTF-8 and UTF-16, which are represented by the UTF8Encoding and UnicodeEncoding classes, respectively.

  • 双方向の出力はサポートされていません。Bidirectional output is not supported.

  • 基本多言語プレーン (サロゲートペア) 以外の文字の表示は、リンクされたフォントファイルで定義されていても、サポートされていません。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.

  • 複雑なスクリプトでの文字の表示はサポートされていません。Display of characters in complex scripts is not supported.

  • 文字シーケンス (つまり、基本文字と1つ以上の組み合わせ文字で構成される文字) を組み合わせると、個別の文字として表示されます。Combining character sequences (that is, characters that consist of a base character and one or more combining characters) are displayed as separate characters. この制限を回避するには、コンソールに出力を送信する前に、String.Normalize メソッドを呼び出して、表示される文字列を正規化します。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. 次の例では、結合文字シーケンス U + 0061 U + 0308 を含む文字列が、出力文字列が正規化される前の2文字としてコンソールに表示され、String.Normalize メソッドが呼び出された後の1文字として表示されます。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"
    //       ä
    

    正規化は、文字の Unicode 標準に、特定の組み合わせ文字シーケンスに対応する事前に構成された形式が含まれている場合にのみ、実行可能な解決策になることに注意してください。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.

  • フォントがプライベート使用領域のコードポイントのグリフを提供する場合、そのグリフが表示されます。If a font provides a glyph for a code point in the private use area, that glyph will be displayed. ただし、プライベートな使用領域の文字はアプリケーションに固有であるため、これは予期されるグリフではない可能性があります。However, because characters in the private use area are application-specific, this may not be the expected glyph.

次の例では、Unicode 文字の範囲をコンソールに表示します。The following example displays a range of Unicode characters to the console. この例では、3つのコマンドラインパラメーター (表示する範囲の先頭、表示する範囲の末尾、現在のコンソールエンコード (false) または 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). コンソールで 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  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ

一般的な操作Common Operations

Console クラスには、コンソール入力を読み取り、コンソール出力を書き込むための次のメソッドが含まれています。The Console class contains the following methods for reading console input and writing console output:

  • ReadKey メソッドのオーバーロードは、個々の文字を読み取ります。The overloads of the ReadKey method read an individual character.

  • ReadLine メソッドは、入力行全体を読み取ります。The ReadLine method reads an entire line of input.

  • Write メソッドのオーバーロードは、値型のインスタンス、文字の配列、または一連のオブジェクトを書式設定された文字列または書式設定されていない文字列に変換し、その文字列をコンソールに書き込みます。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.

  • WriteLine メソッドオーバーロードの並列セットは、Write オーバーロードと同じ文字列を出力しますが、行終端文字列も追加します。A parallel set of WriteLine method overloads output the same string as the Write overloads but also add a line termination string.

Console クラスには、次の操作を実行するためのメソッドとプロパティも含まれています。The Console class also contains methods and properties to perform the following operations:

  • 画面バッファーのサイズを取得または設定します。Get or set the size of the screen buffer. BufferHeight プロパティと BufferWidth プロパティを使用すると、バッファーの高さと幅をそれぞれ取得または設定できます。 SetBufferSize メソッドを使用すると、1回のメソッド呼び出しでバッファーサイズを設定できます。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.

  • コンソールウィンドウのサイズを取得または設定します。Get or set the size of the console window. WindowHeight プロパティと WindowWidth プロパティを使用すると、ウィンドウの高さと幅をそれぞれ取得または設定できます。また、SetWindowSize メソッドを使用すると、1回のメソッド呼び出しでウィンドウのサイズを設定できます。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.

  • カーソルのサイズを取得または設定します。Get or set the size of the cursor. CursorSize プロパティは、文字セル内のカーソルの高さを指定します。The CursorSize property specifies the height of the cursor in a character cell.

  • 画面バッファーに対するコンソールウィンドウの相対位置を取得または設定します。Get or set the position of the console window relative to the screen buffer. WindowTop プロパティと WindowLeft プロパティを使用すると、コンソールウィンドウに表示される画面バッファーの先頭行と左端の列を取得または設定できます。また、SetWindowPosition メソッドを使用すると、これらの値を1回のメソッド呼び出しで設定できます。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.

  • CursorTop および CursorLeft プロパティを取得または設定するか、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.

  • MoveBufferArea または Clear メソッドを呼び出して、画面バッファー内のデータを移動またはクリアします。Move or clear data in the screen buffer by calling the MoveBufferArea or Clear method.

  • ForegroundColorBackgroundColor のプロパティを使用して、前景色と背景色を取得または設定します。 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.

  • Beep メソッドを呼び出して、コンソールのスピーカーからビープ音を再生します。Play the sound of a beep through the console speaker by calling the Beep method.

.NET Core.NET Core での注意Notes

デスクトップの .NET Framework では、Console クラスは GetConsoleCP および GetConsoleOutputCPによって返されるエンコーディングを使用します。これは通常、コードページのエンコーディングです。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. コード例として、カルチャが英語 (米国) であるシステムでは、コードページ437が既定で使用されるエンコーディングです。For example code, on systems whose culture is English (United States), code page 437 is the encoding that is used by default. しかし、.NET Core.NET Core では、これらのエンコードの限られたサブセットしか使用できないことがあります。However, .NET Core.NET Core may make only a limited subset of these encodings available. この場合、コンソールの既定のエンコードとして Encoding.UTF8 が使用されます。Where this is the case, Encoding.UTF8 is used as the default encoding for the console.

アプリが特定のコードページエンコーディングに依存している場合でも、Console メソッドを呼び出す前に、次の手順を実行して使用可能にすることができます。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. プロジェクトに、参照を追加して、コードページ...........................Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. CodePagesEncodingProvider.Instance プロパティから、EncodingProvider オブジェクトを取得します。Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. EncodingProvider オブジェクトを Encoding.RegisterProvider メソッドに渡すと、エンコーディング プロバイダーでサポートされているその他のエンコードを利用できるようになります。Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

Console クラスは、Console 出力メソッドを呼び出す前にエンコードプロバイダーを登録した場合、UTF8 ではなく既定のシステムエンコードを自動的に使用します。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.

プロパティ

BackgroundColor

コンソールの背景色を取得または設定します。Gets or sets the background color of the console.

BufferHeight

バッファー領域の高さを取得または設定します。Gets or sets the height of the buffer area.

BufferWidth

バッファー領域の幅を取得または設定します。Gets or sets the width of the buffer area.

CapsLock

CapsLock がオンかオフかを示す値を取得します。Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft

バッファー領域におけるカーソルの列位置を取得または設定します。Gets or sets the column position of the cursor within the buffer area.

CursorSize

文字セル内のカーソルの高さを取得または設定します。Gets or sets the height of the cursor within a character cell.

CursorTop

バッファー領域におけるカーソルの行位置を取得または設定します。Gets or sets the row position of the cursor within the buffer area.

CursorVisible

カーソルを表示するかどうかを示す値を取得または設定します。Gets or sets a value indicating whether the cursor is visible.

Error

標準エラー出力ストリームを取得します。Gets the standard error output stream.

ForegroundColor

コンソールの前景色を取得または設定します。Gets or sets the foreground color of the console.

In

標準入力ストリームを取得します。Gets the standard input stream.

InputEncoding

コンソールが入力内容の読み取り時に使用するエンコーディングを取得または設定します。Gets or sets the encoding the console uses to read input.

IsErrorRedirected

エラー出力ストリームが標準エラー ストリームからリダイレクトされているかどうかを示す値を取得します。Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected

入力が標準入力ストリームからリダイレクトされているかどうかを示す値を取得します。Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected

出力が標準出力ストリームからリダイレクトされているかどうかを示す値を取得します。Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable

キーが押されたかどうか、つまり、押されたキーが入力ストリームに存在するかどうかを示す値を取得します。Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight

現在のフォントおよび画面解像度に基づいて、コンソール ウィンドウの最大行数を取得します。Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth

現在のフォントおよび画面解像度に基づいて、コンソール ウィンドウの最大列数を取得します。Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock

NumLock がオンかオフかを示す値を取得します。Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out

標準出力ストリームを取得します。Gets the standard output stream.

OutputEncoding

コンソールが出力内容の書き込み時に使用するエンコーディングを取得または設定します。Gets or sets the encoding the console uses to write output.

Title

コンソールのタイトル バーに表示するタイトルを取得または設定します。Gets or sets the title to display in the console title bar.

TreatControlCAsInput

Control 修飾キーと C コンソール キーの組み合わせ (Ctrl + C) を、通常の入力として扱うか、オペレーティング システムにより処理される割り込みとして扱うかを示す値を取得または設定します。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

コンソール ウィンドウ領域の高さを取得または設定します。Gets or sets the height of the console window area.

WindowLeft

コンソール ウィンドウ領域の左端の位置を、画面バッファーに対する相対位置として取得または設定します。Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop

コンソール ウィンドウ領域の上端の位置を、画面バッファーに対する相対位置として取得または設定します。Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth

コンソール ウィンドウの幅を取得または設定します。Gets or sets the width of the console window.

メソッド

Beep()

コンソールのスピーカーからビープ音を出します。Plays the sound of a beep through the console speaker.

Beep(Int32, Int32)

周波数と時間を指定して、コンソールのスピーカーからビープ音を出します。Plays the sound of a beep of a specified frequency and duration through the console speaker.

Clear()

コンソール バッファーおよび対応するコンソール ウィンドウをクリアします。Clears the console buffer and corresponding console window of display information.

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

画面バッファーの特定の領域を、指定した領域にコピーします。Copies a specified source area of the screen buffer to a specified destination area.

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

画面バッファーの特定の領域を、指定した領域にコピーします。Copies a specified source area of the screen buffer to a specified destination area.

OpenStandardError()

標準エラー ストリームを取得します。Acquires the standard error stream.

OpenStandardError(Int32)

指定したバッファー サイズに設定された標準エラー ストリームを取得します。Acquires the standard error stream, which is set to a specified buffer size.

OpenStandardInput()

標準入力ストリームを取得します。Acquires the standard input stream.

OpenStandardInput(Int32)

指定したバッファー サイズに設定された標準入力ストリームを取得します。Acquires the standard input stream, which is set to a specified buffer size.

OpenStandardOutput()

標準出力ストリームを取得します。Acquires the standard output stream.

OpenStandardOutput(Int32)

指定したバッファー サイズに設定された標準出力ストリームを取得します。Acquires the standard output stream, which is set to a specified buffer size.

Read()

標準入力ストリームから次の文字を読み取ります。Reads the next character from the standard input stream.

ReadKey()

ユーザーによって押された次の文字キーまたはファンクション キーを取得します。Obtains the next character or function key pressed by the user. 押されたキーは、コンソール ウィンドウに表示されます。The pressed key is displayed in the console window.

ReadKey(Boolean)

ユーザーによって押された次の文字キーまたはファンクション キーを取得します。Obtains the next character or function key pressed by the user. 押されたキーは、オプションでコンソール ウィンドウに表示されます。The pressed key is optionally displayed in the console window.

ReadLine()

標準入力ストリームから次の 1 行分の文字を読み取ります。Reads the next line of characters from the standard input stream.

ResetColor()

コンソールの前景色および背景色を既定値に設定します。Sets the foreground and background console colors to their defaults.

SetBufferSize(Int32, Int32)

画面バッファー領域の高さと幅を指定された値に設定します。Sets the height and width of the screen buffer area to the specified values.

SetCursorPosition(Int32, Int32)

カーソルの位置を設定します。Sets the position of the cursor.

SetError(TextWriter)

指定された Error オブジェクトに TextWriter プロパティを設定します。Sets the Error property to the specified TextWriter object.

SetIn(TextReader)

指定された In オブジェクトに TextReader プロパティを設定します。Sets the In property to the specified TextReader object.

SetOut(TextWriter)

Out プロパティを TextWriter オブジェクトをターゲットとするように設定します。Sets the Out property to target the TextWriter object.

SetWindowPosition(Int32, Int32)

画面バッファーに対するコンソール ウィンドウの相対位置を設定します。Sets the position of the console window relative to the screen buffer.

SetWindowSize(Int32, Int32)

コンソール ウィンドウの高さと幅を指定された値に設定します。Sets the height and width of the console window to the specified values.

Write(Boolean)

指定した Boolean 値のテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified Boolean value to the standard output stream.

Write(Char)

指定した Unicode 文字値を標準出力ストリームに書き込みます。Writes the specified Unicode character value to the standard output stream.

Write(Char[])

指定した Unicode 文字配列を標準出力ストリームに書き込みます。Writes the specified array of Unicode characters to the standard output stream.

Write(Char[], Int32, Int32)

指定した Unicode 文字の部分配列を標準出力ストリームに書き込みます。Writes the specified subarray of Unicode characters to the standard output stream.

Write(Decimal)

指定した Decimal 値のテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified Decimal value to the standard output stream.

Write(Double)

指定した倍精度浮動小数点値のテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified double-precision floating-point value to the standard output stream.

Write(Int32)

指定した 32 ビット符号付き整数値のテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified 32-bit signed integer value to the standard output stream.

Write(Int64)

指定した 64 ビット符号付き整数値のテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified 64-bit signed integer value to the standard output stream.

Write(Object)

指定したオブジェクトのテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified object to the standard output stream.

Write(Single)

指定した単精度浮動小数点値のテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified single-precision floating-point value to the standard output stream.

Write(String)

指定した文字列値を標準出力ストリームに書き込みます。Writes the specified string value to the standard output stream.

Write(String, Object)

指定した書式情報を使用して、指定したオブジェクトのテキスト表現を標準出力ストリームに書き込みます。Writes the text representation of the specified object to the standard output stream using the specified format information.

Write(String, Object, Object)

指定した書式情報を使用して、指定したオブジェクトのテキスト表現を標準出力ストリームに書き込みます。Writes the text representation of the specified objects to the standard output stream using the specified format information.

Write(String, Object, Object, Object)

指定した書式情報を使用して、指定したオブジェクトのテキスト表現を標準出力ストリームに書き込みます。Writes the text representation of the specified objects to the standard output stream using the specified format information.

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

指定した書式情報を使用して、指定したオブジェクトのテキスト表現と可変長パラメーター リストを標準出力ストリームに書き込みます。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[])

指定された書式情報を使用して、指定したオブジェクト配列のテキスト表現を標準出力ストリームに書き込みます。Writes the text representation of the specified array of objects to the standard output stream using the specified format information.

Write(UInt32)

指定した 32 ビット符号なし整数値のテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified 32-bit unsigned integer value to the standard output stream.

Write(UInt64)

指定した 64 ビット符号なし整数値のテキスト形式を標準出力ストリームに書き込みます。Writes the text representation of the specified 64-bit unsigned integer value to the standard output stream.

WriteLine()

現在の行終端記号を標準出力ストリームに書き込みます。Writes the current line terminator to the standard output stream.

WriteLine(Boolean)

指定した Boolean 値のテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

WriteLine(Char)

指定した Unicode 文字を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。Writes the specified Unicode character, followed by the current line terminator, value to the standard output stream.

WriteLine(Char[])

指定した Unicode 文字配列を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。Writes the specified array of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(Char[], Int32, Int32)

指定した Unicode 文字の部分配列を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。Writes the specified subarray of Unicode characters, followed by the current line terminator, to the standard output stream.

WriteLine(Decimal)

指定した Decimal 値のテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。Writes the text representation of the specified Decimal value, followed by the current line terminator, to the standard output stream.

WriteLine(Double)

指定した倍精度浮動小数点値のテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定した 32 ビット符号付き整数値のテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定した 64 ビット符号付き整数値のテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定したオブジェクトのテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream.

WriteLine(Single)

指定した単精度浮動小数点値のテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定した文字列値を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。Writes the specified string value, followed by the current line terminator, to the standard output stream.

WriteLine(String, Object)

指定した書式情報を使用して、指定したオブジェクトのテキスト表現を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定した書式情報を使用して、指定したオブジェクトのテキスト表現を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定した書式情報を使用して、指定したオブジェクトのテキスト表現を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定した書式情報を使用して、指定したオブジェクトのテキスト表現と可変長パラメーター リストを標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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[])

指定した書式情報を使用して、指定したオブジェクト配列のテキスト表現を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定した 32 ビット符号なし整数値のテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。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)

指定した 64 ビット符号なし整数値のテキスト形式を標準出力ストリームに書き込み、続けて現在の行終端記号を書き込みます。Writes the text representation of the specified 64-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

イベント

CancelKeyPress

Control の修飾子キー (Ctrl) と C コンソール キー (c) または中断キーが同時にプッシュされた場合 (Ctrl + C または 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).

適用対象

スレッド セーフ

この型はスレッド セーフです。This type is thread safe.