Console 클래스

정의

콘솔 애플리케이션에 대한 표준 입력, 출력 및 오류 스트림을 나타냅니다. 이 클래스는 상속될 수 없습니다.

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

예제

다음 예제에서는 표준 입력 및 출력 스트림에서 데이터를 읽고 데이터를 쓰는 방법을 보여 줍니다. 이러한 스트림은 및 SetOut 메서드를 사용하여 SetIn 리디렉션할 수 있습니다.

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!

설명

콘솔에 있는 사용자 상호 작용 텍스트 기반 콘솔 애플리케이션 또는 운영 체제를 사용 하 여 컴퓨터 키보드를 통해 텍스트 입력을 입력 하 여 및 컴퓨터 터미널에서 텍스트 출력을 참조 하 여 운영 체제 창입니다. 예를 들어 Windows 운영 체제에서 콘솔을 명령 프롬프트 창이라고 하며 MS-DOS 명령을 수락합니다. Console 클래스는 문자를 읽고 콘솔에 문자 쓰기는 애플리케이션에 대 한 기본 지원을 제공 합니다.

클래스를 사용하여 개발하는 방법에 Console 대한 자세한 내용은 다음 섹션을 참조하세요.

콘솔 I/O 스트림

콘솔 애플리케이션을 시작할 때 운영 체제 자동 세 I/O 스트림 콘솔: 표준 스트림, 표준 출력 스트림 및 표준 오류 출력 스트림을 입력 합니다. 애플리케이션이 표준 입력 스트림에서; 사용자 입력을 읽을 수 있습니다. 표준 출력 스트림에 일반 데이터 쓰기 및 표준 오류 출력 스트림에 오류 데이터를 작성 합니다. 이러한 스트림은 애플리케이션의 값으로는 Console.In, Console.Out, 및 Console.Error 속성입니다.

기본적으로 속성 값 In 은 키보드를 System.IO.TextReader 나타내는 개체이며 속성 및 Error 속성 값 Out 은 콘솔 창을 나타내는 개체입니다System.IO.TextWriter. 그러나 이러한 속성을 콘솔 창이나 키보드를 나타내지 않는 스트림으로 설정할 수 있습니다. 예를 들어 이러한 속성을 파일을 나타내는 스트림으로 설정할 수 있습니다. 표준 입력, 표준 출력 또는 표준 오류 스트림을 리디렉션하려면 각각 , Console.SetOut또는 Console.SetError 메서드를 Console.SetIn호출합니다. 이러한 스트림을 사용하는 I/O 작업은 동기화됩니다. 즉, 여러 스레드가 스트림에서 읽거나 쓸 수 있습니다. 즉, 일반적으로 비동기 메서드(예: TextReader.ReadLineAsync개체가 콘솔 스트림을 나타내는 경우)가 동기적으로 실행됩니다.

참고

사용 하지 마십시오는 Console 무인 애플리케이션에서 서버 애플리케이션과 같은 출력을 표시 하는 클래스입니다. 와 같은 메서드를 호출 Console.WriteConsole.WriteLine GUI 애플리케이션에는 아무런 효과가 없습니다.

Console 기본 스트림이 콘솔로 전달될 때 정상적으로 작동하는 클래스 멤버는 스트림이 파일로 리디렉션되는 경우 예외를 throw할 수 있습니다. Catch 하도록 애플리케이션 프로그램 System.IO.IOException 표준 스트림을 리디렉션하는 경우는 예외입니다. 및 속성을 사용하여 IsOutputRedirectedIsInputRedirectedIsErrorRedirected 예외를 throw하는 작업을 수행하기 전에 표준 스트림이 리디렉션되는지 여부를 확인할 수도 있습니다.System.IO.IOException

, 및 속성이 나타내는 InOut스트림 개체의 멤버를 명시적으로 호출하는 것이 유용한 경우도 있습니다Error. 예를 들어 기본적으로 메서드는 Console.ReadLine 표준 입력 스트림에서 입력을 읽습니다. 마찬가지로, 메서드는 Console.WriteLine 표준 출력 스트림에 데이터를 씁니다. 그 뒤에는 기본 줄 종료 문자열 Environment.NewLine이 잇따라 표시됩니다. 그러나 클래스는 Console 표준 오류 출력 스트림에 데이터를 쓰는 해당 메서드 또는 해당 스트림에 기록된 데이터의 줄 종료 문자열을 변경하는 속성을 제공하지 않습니다.

또는 Error 속성의 Out 속성을 다른 줄 종료 문자열로 설정 TextWriter.NewLine 하여 이 문제를 해결할 수 있습니다. 예를 들어 다음 C# 문은 표준 오류 출력 스트림의 줄 종료 문자열을 두 캐리지 리턴 및 줄 피드 시퀀스로 설정합니다.

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

그런 다음, 다음 C# 문에서와 같이 오류 출력 스트림 개체의 메서드를 명시적으로 호출 WriteLine 할 수 있습니다.

Console.Error.WriteLine();

화면 버퍼 및 콘솔 창

콘솔의 두 가지 밀접하게 관련된 기능은 화면 버퍼와 콘솔 창입니다. 텍스트는 실제로 본체가 소유한 스트림에서 읽거나 쓰여지지만 화면 버퍼라고 하는 콘솔이 소유한 영역에서 읽거나 쓰는 것처럼 보입니다. 화면 버퍼는 콘솔의 특성이며 각 그리드 교차 또는 문자 셀에 문자를 포함할 수 있는 행과 열의 사각형 그리드로 구성됩니다. 각 문자는 고유한 전경색을 하며 각 문자 셀에는 고유한 배경색이 있습니다.

화면 버퍼는 콘솔 창이라는 사각형 영역을 통해 표시됩니다. 콘솔 창은 콘솔의 또 다른 특성입니다. 운영 체제 창인 콘솔 자체가 아닙니다. 콘솔 창은 행과 열로 정렬되고, 화면 버퍼의 크기보다 작거나 같으며, 기본 화면 버퍼의 다른 영역을 보기 위해 이동할 수 있습니다. 화면 버퍼가 콘솔 창보다 크면 콘솔이 자동으로 스크롤 막대를 표시하므로 콘솔 창의 위치를 화면 버퍼 영역 위로 변경할 수 있습니다.

커서는 현재 텍스트를 읽거나 쓰는 화면 버퍼 위치를 나타냅니다. 커서를 숨기거나 표시할 수 있으며 높이를 변경할 수 있습니다. 커서가 표시되면 콘솔 창 위치가 자동으로 이동되므로 커서가 항상 표시됩니다.

화면 버퍼의 문자 셀 좌표 원점은 왼쪽 위 모서리이며 커서와 콘솔 창의 위치는 해당 원점과 관련하여 측정됩니다. 0부터 시작하는 인덱스를 사용하여 위치를 지정합니다. 즉, 맨 위 행을 행 0으로 지정하고 맨 왼쪽 열을 열 0으로 지정합니다. 행 및 열 인덱스의 최대값은 .입니다 Int16.MaxValue.

콘솔에 대한 유니코드 지원

일반적으로 콘솔은 입력을 읽고 시스템 로캘이 기본적으로 정의하는 현재 콘솔 코드 페이지를 사용하여 출력을 씁니다. 코드 페이지는 사용 가능한 유니코드 문자의 하위 집합만 처리할 수 있으므로 특정 코드 페이지에서 매핑되지 않은 문자를 표시하려고 하면 콘솔에서 모든 문자를 표시하거나 정확하게 나타낼 수 없습니다. 다음 예제에서는 이 문제를 보여 줍니다. U+0410에서 U+044F까지의 키릴 자모 알파벳 문자를 콘솔에 표시하려고 합니다. 콘솔 코드 페이지 437을 사용하는 시스템에서 예제를 실행하면 키릴 자모 문자가 코드 페이지 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] = (char)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
'       
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
open System

// 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()

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

이 클래스는 코드 페이지를 Console 지원하는 것 외에도 클래스를 사용한 UTF-8 인코딩을 UTF8Encoding 지원합니다. .NET Framework 4.5부터 클래스는 Console 클래스를 사용한 UTF-16 인코딩 UnicodeEncoding 도 지원합니다. 콘솔에 유니코드 문자를 표시합니다. 속성을 둘 OutputEncoding 중 하나 UTF8Encoding 또는 UnicodeEncoding.로 설정합니다.

유니코드 문자를 지원하려면 인코더가 특정 유니코드 문자를 인식해야 하며 해당 문자를 렌더링하는 데 필요한 문자 모양이 있는 글꼴도 필요합니다. 콘솔에 유니코드 문자를 성공적으로 표시하려면 콘솔 글꼴을 비레이스터 또는 TrueType 글꼴(예: Consolas 또는 Lucida Console)로 설정해야 합니다. 다음 예제에서는 래스터 글꼴에서 Lucida 콘솔로 글꼴을 프로그래밍 방식으로 변경하는 방법을 보여 줍니다.

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 글꼴은 문자 모양의 하위 집합만 표시할 수 있습니다. 예를 들어 Lucida 콘솔 글꼴은 U+0021에서 U+FB02까지 사용 가능한 약 64,000자 중 643개만 표시합니다. 특정 글꼴이 지원하는 문자를 보려면 제어판 글꼴 애플릿을 열고 문자 찾기 옵션을 선택한 다음 문자 창의 글꼴 목록에서 검사할 문자 집합의 글꼴 을 선택합니다.

Windows 글꼴 연결을 사용하여 특정 글꼴에서 사용할 수 없는 문자 모양을 표시합니다. 추가 문자 집합을 표시하는 글꼴 연결에 대한 자세한 내용은 전역화 단계별: 글꼴을 참조하세요. 연결된 글꼴은 레지스트리의 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink 하위 키에 정의됩니다. 이 하위 키와 연결된 각 항목은 기본 글꼴의 이름에 해당하며 해당 값은 기본 글꼴에 연결된 글꼴 파일 및 글꼴을 정의하는 문자열 배열입니다. 배열의 각 멤버는 연결된 글꼴을 정의하고 글꼴-파일 이름, font-name 형식을 사용합니다. 다음 예제에서는 Simsun.ttc라는 글꼴 파일에 있는 SimSun이라는 연결된 글꼴을 프로그래밍 방식으로 정의하여 간체 한 문자를 표시하는 방법을 보여 줍니다.

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
open System
open Microsoft.Win32

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()

콘솔에 대한 유니코드 지원에는 다음과 같은 제한 사항이 있습니다.

  • UTF-32 인코딩은 지원되지 않습니다. 지원되는 유니코드 인코딩은 각각 UTF-8 및 UTF-16입니다. 이 인코딩은 각각 및 UnicodeEncoding 클래스로 UTF8Encoding 표시됩니다.

  • 양방향 출력은 지원되지 않습니다.

  • 연결된 글꼴 파일에 정의된 경우에도 기본 다국어 평면(즉, 서로게이트 쌍) 외부의 문자 표시는 지원되지 않습니다.

  • 복잡한 스크립트의 문자 표시는 지원되지 않습니다.

  • 문자 시퀀스 결합(즉, 기본 문자와 하나 이상의 결합 문자로 구성된 문자)은 별도의 문자로 표시됩니다. 이 제한을 해결하기 위해 콘솔에 출력을 보내기 전에 메서드를 String.Normalize 호출하여 표시할 문자열을 정규화할 수 있습니다. 다음 예제에서는 결합 문자 시퀀스 U+0061 U+0308이 포함된 문자열이 출력 문자열이 정규화되기 전에 두 문자로 콘솔에 표시되고 메서드가 호출된 후 String.Normalize 단일 문자로 표시됩니다.

    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"
    '       ä
    
    open System
    
    let chars = [| '\u0061'; '\u0308' |]
    
    let combining = String chars
    Console.WriteLine combining
    
    let combining2 = combining.Normalize()
    Console.WriteLine combining2
    
    
    // The example displays the following output:
    //       a"
    //       ä
    

    정규화는 문자의 유니코드 표준에 특정 결합 문자 시퀀스에 해당하는 미리 구성된 형식이 포함된 경우에만 실행 가능한 솔루션입니다.

  • 글꼴이 프라이빗 사용 영역의 코드 포인트에 대한 문자 모양을 제공하는 경우 해당 문자 모양이 표시됩니다. 그러나 개인 사용 영역의 문자 애플리케이션별 이기 때문에이 아닐 예상된 문자 모양입니다.

다음 예제에서는 콘솔에 유니코드 문자 범위를 표시합니다. 이 예제에서는 표시할 범위의 시작, 표시할 범위의 끝, 현재 콘솔 인코딩() 또는 UTF-16 인코딩(false)을 사용할지 여부 등 세 가지 명령줄 매개 변수를true 허용합니다. 콘솔에서 트루타입 글꼴을 사용하고 있다고 가정합니다.

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($" {(char)(0x20)} ");
            }
            else if (end < cur) {
               Console.Write($" {(char)(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($" {(char)(0x20)} ");
               // Display a space for code points in the private use area.
               else if (CharUnicodeInfo.GetUnicodeCategory(chars[0]) ==
                                              UnicodeCategory.PrivateUse)
                 Console.Write($" {(char)(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($" {(char)(0x20)} ");
               else
                  Console.Write($" {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  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ

일반 작업

Console 클래스에는 콘솔 입력을 읽고 콘솔 출력을 작성하기 위한 다음 메서드가 포함되어 있습니다.

  • 메서드의 ReadKey 오버로드는 개별 문자를 읽습니다.

  • 메서드는 ReadLine 전체 입력 줄을 읽습니다.

  • Write 메서드 오버로드는 값 형식의 인스턴스, 문자 배열 또는 개체 집합을 형식이 지정되거나 서식이 지정되지 않은 문자열로 변환한 다음 해당 문자열을 콘솔에 씁니다.

  • 메서드 오버로드의 WriteLine 병렬 집합은 오버로드와 동일한 문자열을 Write 출력하지만 줄 종료 문자열도 추가합니다.

클래스에는 Console 다음 작업을 수행하는 메서드 및 속성도 포함되어 있습니다.

  • 화면 버퍼의 크기를 가져오기 또는 설정합니다. BufferHeightBufferWidth 속성을 사용하면 각각 버퍼 높이와 너비를 얻거나 설정할 수 있으며, 메서드를 SetBufferSize 사용하면 단일 메서드 호출에서 버퍼 크기를 설정할 수 있습니다.

  • 콘솔 창의 크기를 가져오기 또는 설정합니다. WindowHeightWindowWidth 속성을 사용하면 창 높이와 너비를 각각 얻거나 설정할 수 있으며, 메서드를 SetWindowSize 사용하면 단일 메서드 호출에서 창 크기를 설정할 수 있습니다.

  • 커서의 크기를 가져오기 또는 설정합니다. 이 속성은 CursorSize 문자 셀에 있는 커서의 높이를 지정합니다.

  • 화면 버퍼를 기준으로 콘솔 창의 위치를 설정하거나 가져옵니다. WindowTopWindowLeft 속성을 사용하면 콘솔 창에 표시되는 화면 버퍼의 맨 위 행과 맨 왼쪽 열을 얻거나 설정할 수 있으며SetWindowPosition, 이 메서드를 사용하면 단일 메서드 호출에서 이러한 값을 설정할 수 있습니다.

  • 및 속성을 가져오거나 설정 CursorTop CursorLeft 하여 커서의 위치를 가져오거나 설정하거나 메서드를 호출 SetCursorPosition 하여 커서의 위치를 설정합니다.

  • 또는 메서드를 호출 MoveBufferArea 하여 화면 버퍼에서 데이터를 이동하거나 Clear 지웁 수 있습니다.

  • 및 속성을 사용하여 ForegroundColor 전경색과 BackgroundColor 배경색을 얻거나 설정하거나 메서드를 호출 ResetColor 하여 배경색과 전경을 기본 색으로 다시 설정합니다.

  • 메서드를 호출하여 콘솔 스피커를 통해 경고음 소리를 재생합니다 Beep .

.NET Core 참고 사항

데스크톱 Console 의 .NET Framework 클래스는 반환되는 인코딩 GetConsoleCP 을 사용하며GetConsoleOutputCP, 일반적으로 코드 페이지 인코딩입니다. 예를 들어 문화권이 영어(미국)인 시스템에서 코드 페이지 437은 기본적으로 사용되는 인코딩입니다. 그러나 .NET Core는 이러한 인코딩의 제한된 하위 집합만 사용할 수 있도록 할 수 있습니다. 이 경우 Encoding.UTF8 콘솔의 기본 인코딩으로 사용됩니다.

앱이 특정 코드 페이지 인코딩에 의존하는 경우 메서드를 호출 Console 하기 전에 다음을 수행하여 계속 사용할 수 있습니다.

  1. 프로젝트에 System.Text.Encoding.CodePages.dll 어셈블리에 대한 참조를 추가합니다.

  2. 속성에서 EncodingProvider 개체를 검색합니다 CodePagesEncodingProvider.Instance .

  3. 개체를 EncodingProvider 메서드에 Encoding.RegisterProvider 전달하여 인코딩 공급자가 지원하는 추가 인코딩을 사용할 수 있도록 합니다.

Console 그러면 출력 메서드를 호출 Console 하기 전에 인코딩 공급자를 등록한 경우 클래스는 UTF8이 아닌 기본 시스템 인코딩을 자동으로 사용합니다.

속성

BackgroundColor

콘솔의 배경색을 가져오거나 설정합니다.

BufferHeight

버퍼 영역의 높이를 가져오거나 설정합니다.

BufferWidth

버퍼 영역의 너비를 가져오거나 설정합니다.

CapsLock

Caps Lock 키보드 토글의 설정 또는 해제 여부를 나타내는 값을 가져옵니다.

CursorLeft

버퍼 영역 내에서 커서의 열 위치를 가져오거나 설정합니다.

CursorSize

문자 셀 내부의 커서 높이를 가져오거나 설정합니다.

CursorTop

버퍼 영역 내에서 커서의 행 위치를 가져오거나 설정합니다.

CursorVisible

커서가 표시되는지를 나타내는 값을 가져오거나 설정합니다.

Error

표준 오류 출력 스트림을 가져옵니다.

ForegroundColor

콘솔의 전경색을 가져오거나 설정합니다.

In

표준 입력 스트림을 가져옵니다.

InputEncoding

콘솔이 입력을 읽기 위해 사용하는 인코딩을 가져오거나 설정합니다.

IsErrorRedirected

오류 출력 스트림이 표준 오류 스트림에서 리디렉션되었는지를 나타내는 값을 가져옵니다.

IsInputRedirected

입력이 표준 입력 스트림에서 리디렉션되었는지를 나타내는 값을 가져옵니다.

IsOutputRedirected

출력이 표준 출력 스트림에서 리디렉션되었는지를 나타내는 값을 가져옵니다.

KeyAvailable

입력 스트림에서 키 누름을 사용할 수 있는지를 나타내는 값을 가져옵니다.

LargestWindowHeight

현재 글꼴 및 화면 해상도에 따라 콘솔 창 행의 가능한 최대 수를 가져옵니다.

LargestWindowWidth

현재 글꼴 및 화면 해상도에 따라 콘솔 창 열의 가능한 최대 수를 가져옵니다.

NumberLock

Num Lock 키보드 토글의 설정 또는 해제 여부를 나타내는 값을 가져옵니다.

Out

표준 출력 스트림을 가져옵니다.

OutputEncoding

콘솔이 출력을 쓰기 위해 사용하는 인코딩을 가져오거나 설정합니다.

Title

콘솔 제목 표시줄에 표시할 제목을 가져오거나 설정합니다.

TreatControlCAsInput

Control 보조키와 C 콘솔 키의 조합(Ctrl+C)이 일반 입력으로 처리되는지 운영 체제에서 처리하는 충돌로 처리되는지를 나타내는 값을 가져오거나 설정합니다.

WindowHeight

콘솔 창 영역의 높이를 가져오거나 설정합니다.

WindowLeft

화면 버퍼에 상대적인 콘솔 창 영역의 맨 왼쪽 위치를 가져오거나 설정합니다.

WindowTop

화면 버퍼에 상대적인 콘솔 창 영역의 위쪽 위치를 가져오거나 설정합니다.

WindowWidth

콘솔 창의 컨트롤의 너비를 가져오거나 설정합니다.

메서드

Beep()

콘솔 스피커를 통해 경고음을 재생합니다.

Beep(Int32, Int32)

지정한 시간 동안 지정한 주파수로 콘솔 스피커를 통해 경고음을 재생합니다.

Clear()

콘솔 버퍼와 해당 콘솔 창에서 표시 정보를 지웁니다.

GetCursorPosition()

커서의 위치를 가져옵니다.

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

화면 버퍼의 지정한 소스 영역을 지정한 대상 영역에 복사합니다.

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

화면 버퍼의 지정한 소스 영역을 지정한 대상 영역에 복사합니다.

OpenStandardError()

표준 오류 스트림을 가져옵니다.

OpenStandardError(Int32)

표준 오류 스트림을 가져와 지정한 버퍼 크기로 설정합니다.

OpenStandardInput()

표준 입력 스트림을 가져옵니다.

OpenStandardInput(Int32)

표준 입력 스트림을 가져와 지정한 버퍼 크기로 설정합니다.

OpenStandardOutput()

표준 출력 스트림을 가져옵니다.

OpenStandardOutput(Int32)

표준 출력 스트림을 가져와 지정한 버퍼 크기로 설정합니다.

Read()

표준 입력 스트림에서 다음 문자를 읽습니다.

ReadKey()

다음 문자나 사용자가 누른 기능 키를 가져옵니다. 누른 키는 콘솔 창에 표시됩니다.

ReadKey(Boolean)

다음 문자나 사용자가 누른 기능 키를 가져옵니다. 누른 키는 선택적으로 콘솔 창에 표시됩니다.

ReadLine()

표준 입력 스트림에서 다음 줄의 문자를 읽습니다.

ResetColor()

콘솔의 전경색과 배경색을 해당 기본값으로 설정합니다.

SetBufferSize(Int32, Int32)

화면 버퍼의 높이와 너비를 지정한 값으로 설정합니다.

SetCursorPosition(Int32, Int32)

커서의 위치를 설정합니다.

SetError(TextWriter)

Error 속성을 지정한 TextWriter 개체로 설정합니다.

SetIn(TextReader)

In 속성을 지정한 TextReader 개체로 설정합니다.

SetOut(TextWriter)

Out 속성을 TextWriter 개체를 대상으로 설정합니다.

SetWindowPosition(Int32, Int32)

화면 버퍼에 상대적인 콘솔 창의 위치를 설정합니다.

SetWindowSize(Int32, Int32)

콘솔 창의 높이와 너비를 지정한 값으로 설정합니다.

Write(Boolean)

지정한 부울 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(Char)

지정한 유니코드 문자 값을 표준 출력 스트림에 씁니다.

Write(Char[])

지정한 유니코드 문자의 배열을 표준 출력 스트림에 씁니다.

Write(Char[], Int32, Int32)

지정한 유니코드 문자의 하위 배열을 표준 출력 스트림에 씁니다.

Write(Decimal)

지정한 Decimal 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(Double)

지정한 배정밀도 부동 소수점 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(Int32)

지정한 부호 있는 32비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(Int64)

지정한 부호 있는 64비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(Object)

지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(Single)

지정한 단정밀도 부동 소수점 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(String)

지정한 문자열 값을 표준 출력 스트림에 씁니다.

Write(String, Object)

지정한 형식 정보를 사용하여 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(String, Object, Object)

지정한 형식 정보를 사용하여 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(String, Object, Object, Object)

지정한 형식 정보를 사용하여 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.

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

지정한 형식 정보를 사용하여 지정한 개체 및 가변 길이 매개 변수 목록의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(String, Object[])

지정한 형식 정보를 사용하여 지정한 개체 배열의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(UInt32)

지정한 부호 없는 32비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

Write(UInt64)

지정한 부호 없는 64비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine()

현재 줄 종결자를 표준 출력 스트림에 씁니다.

WriteLine(Boolean)

뒤에 현재 줄 종결자가 오는, 지정한 부울 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(Char)

뒤에 현재 줄 종결자가 오는, 지정한 유니코드 문자 값을 표준 출력 스트림에 씁니다.

WriteLine(Char[])

뒤에 현재 줄 종결자가 오는, 지정한 유니코드 문자의 배열을 표준 출력 스트림에 씁니다.

WriteLine(Char[], Int32, Int32)

뒤에 현재 줄 종결자가 오는, 지정한 유니코드 문자의 하위 배열을 표준 출력 스트림에 씁니다.

WriteLine(Decimal)

뒤에 현재 줄 종결자가 오는, 지정한 Decimal 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(Double)

뒤에 현재 줄 종결자가 오는, 지정한 배정밀도 부동 소수점 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(Int32)

뒤에 현재 줄 종결자가 오는, 부호 있는 32비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(Int64)

뒤에 현재 줄 종결자가 오는, 부호 있는 64비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(Object)

뒤에 현재 줄 종결자가 오는, 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(Single)

뒤에 현재 줄 종결자가 오는, 지정한 단정밀도 부동 소수점 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(String)

뒤에 현재 줄 종결자가 오는, 지정한 문자열 값을 표준 출력 스트림에 씁니다.

WriteLine(String, Object)

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(String, Object, Object)

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(String, Object, Object, Object)

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.

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

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체 및 가변 길이 매개 변수 목록의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(String, Object[])

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체 배열의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(UInt32)

뒤에 현재 줄 종결자가 오는, 부호 없는 32비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

WriteLine(UInt64)

뒤에 현재 줄 종결자가 오는, 부호 없는 64비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.

이벤트

CancelKeyPress

Control 보조 키(Ctrl)와 C 콘솔 키(C) 또는 Break 키를 동시에 누르면(Ctrl+C 또는 Ctrl+Break) 발생합니다.

적용 대상

스레드 보안

이 형식은 스레드로부터 안전합니다.