Console Console Console Console Class

정의

콘솔 애플리케이션에 대한 표준 입력, 출력 및 오류 스트림을 나타냅니다.Represents the standard input, output, and error streams for console applications. 이 클래스는 상속될 수 없습니다.This class cannot be inherited.

public ref class Console abstract sealed
public static class Console
type Console = class
Public Class Console
상속
ConsoleConsoleConsoleConsole

예제

다음 예제에서는 데이터를 읽을 데이터를 표준 입력 및 출력 스트림을 작성 하는 방법을 보여 줍니다.The following example demonstrates how to read data from, and write data to, the standard input and output streams. 이러한 스트림을 사용 하 여 리디렉션될 수를 확인 합니다 SetInSetOut 메서드.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!

설명

콘솔에 있는 사용자 상호 작용 텍스트 기반 콘솔 애플리케이션 또는 운영 체제를 사용 하 여 컴퓨터 키보드를 통해 텍스트 입력을 입력 하 여 및 컴퓨터 터미널에서 텍스트 출력을 참조 하 여 운영 체제 창입니다.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

콘솔 애플리케이션을 시작할 때 운영 체제 자동 세 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.In, Console.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 키보드 및의 값을 나타내는 개체를 OutError 속성은 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.SetIn, Console.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 리디렉션되면 스트림, 예를 들어 파일을 내부 스트림에 콘솔에 지시 하는 경우 정상적으로 작동 하는 클래스 멤버에서 예외를 throw 될 수 있습니다.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. Catch 하도록 애플리케이션 프로그램 System.IO.IOException 표준 스트림을 리디렉션하는 경우는 예외입니다.Program your application to catch System.IO.IOException exceptions if you redirect a standard stream. 사용할 수도 있습니다는 IsOutputRedirected, IsInputRedirected, 및 IsErrorRedirected 표준 스트림에 throw 하는 작업을 수행 하기 전에 리디렉션되는지 여부를 결정 하는 속성을 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.

명시적으로 나타내는 스트림 개체의 멤버를 호출 하는 유용한 경우가 합니다 In, Out, 및 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.

설정 하 여이 문제를 해결할 수 있습니다 합니다 TextWriter.NewLine 의 속성을 Out 또는 Error 속성을 다른 줄 종료 문자열로 합니다.You can solve this problem by setting the TextWriter.NewLine property of the Out or Error property to another line termination string. 예를 들어 다음 C# 문을 두 캐리지 리턴 및 줄 바꿈 시퀀스를 표준 오류 출력 스트림에 대 한 줄 종료 문자열을 설정 합니다.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";

명시적으로 호출할 수 있습니다는 WriteLine 다음 C# 문에서 오류 출력 스트림 개체의 메서드: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

콘솔의 밀접 한 관련이 있는 두 가지 기능은 화면 버퍼 및 콘솔 창입니다.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. 콘솔 창은; 콘솔의 다른 특성 콘솔 자체는 운영 체제 창 아닙니다.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 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. 모든 문자를 표시 하거나 자신을 정확 하 게 나타내는 콘솔 특정 코드 페이지에 의해 매핑되지 않는 문자 표시 없게 하려고 하면 되므로 코드 페이지를 사용할 수 있는 유니코드 문자 집합만 처리할 수 있습니다.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 + 044F 하에서 U + 0410 키릴 자모 문자를 표시 하려고 합니다.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
'       
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?
'       ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?

코드 페이지 지원 외에도 합니다 Console 클래스는 u t F-8 인코딩을 지원 합니다 UTF8Encoding 클래스입니다.In addition to supporting code pages, the Console class supports UTF-8 encoding with the UTF8Encoding class. .NET Framework 4.5부터 합니다 Console 클래스에는 utf-16 인코딩을 지원 합니다 UnicodeEncoding 클래스.Beginning with the .NET Framework 4.5, the Console class also supports UTF-16 encoding with the UnicodeEncoding class. 콘솔에 유니코드 문자를 표시 합니다.To display Unicode characters to the console. 설정 된 OutputEncoding 속성을 UTF8Encoding 또는 UnicodeEncoding합니다.you set the OutputEncoding property to either UTF8Encoding or UnicodeEncoding.

유니코드 문자에 대 한 지원 특정 유니코드 문자를 인식 하도록 인코더와 해당 문자를 렌더링 하는 데 필요한 문자 모양이 있는 글꼴도 필요 합니다.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. 유니코드 문자를 콘솔로 성공적으로 표시 하려면 콘솔 글꼴 비 래스터 또는 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

그러나 트루타입 글꼴 문자 모양 하위 집합만 표시할 수 있습니다.However, TrueType fonts can display only a subset of glyphs. 예를 들어, Lucida Console 글꼴 U + FB02를 사용할 수 있는 약 64,000 문자 (u+0021을 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. 다음 예제에서는 라는 SimSun simsun.ttc Han 간체 문자를 표시 하는 명명 된 글꼴 파일에 연결 된 글꼴을 프로그래밍 방식으로 정의 하는 방법을 보여 줍니다.The following example illustrates how you can programmatically define a linked font named SimSun found in a font file named simsun.ttc that displays Simplified Han characters.

using Microsoft.Win32;
using System;

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

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

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

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

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

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

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

콘솔에 대 한 유니코드 지원에 다음 제한이 있습니다.Unicode support for the console has the following limitations:

  • UTF-32 인코딩은 지원 되지 않습니다.UTF-32 encoding is not supported. 유니코드는 인코딩은 utf-8 및 u t F-16이 고으로 표현 되는 경우에 지원 합니다 UTF8EncodingUnicodeEncoding 클래스 각각.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.

  • Basic Multilingual Plane 밖의 문자 표시 (즉, 서로게이트 쌍) 연결 된 글꼴 파일에 정의 된 경우에는 지원 되지 않습니다.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.

  • 결합 문자 시퀀스 (즉, 기본 문자와 조합 문자를 하나 이상의 구성 된 문자)는 별도 문자로 표시 됩니다.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. 다음 예제에서 조합 문자를 포함 하는 문자열 시퀀스 단어로 후 단일 문자를 출력 문자열은 정규화 하기 전에 두 개의 문자로 + 0308 콘솔에 표시 되는 String.Normalize 메서드가 호출 됩니다.In the following example, a string that contains the combining character sequence U+0061 U+0308 is displayed to the console as two characters before the output string is normalized, and as a single character after the String.Normalize method is called.

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

    Combining 특정에 해당 하는 미리 구성된 된 폼을 포함 하는 문자 표준 유니코드 문자 시퀀스 하는 경우에 정규화는 실행 가능한 솔루션을 참고 합니다.Note that normalization is a viable solution only if the Unicode standard for the character includes a pre-composed form that corresponds to a particular combining character sequence.

  • 개인 사용 영역에 있는 코드 포인트에 대 한 문자 모양을 제공 하는 글꼴, 해당 문자 모양 표시 됩니다.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.

다음 예제에서는 콘솔에는 유니코드 문자의 범위를 표시합니다.The following example displays a range of Unicode characters to the console. 이 예제에서는 세 개의 명령줄 매개 변수: 표시 및 현재 콘솔 인코딩을 사용할지 여부를 범위의 끝을 표시 하려면 범위의 시작 (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). 콘솔 트루타입 글꼴을 사용 하 고 있음을 가정 합니다.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  Ӱ  ӱ  Ӳ  ӳ - Ӵ  ӵ  Ӷ  ӷ -- Ӹ  ӹ  Ӻ  ӻ - Ӽ  ӽ  Ӿ  ӿ

일반 작업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 메서드를 사용 하는 단일 메서드 호출에서 버퍼 크기를 설정할 수 있습니다.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 메서드는 단일 메서드 호출의 창 크기를 설정할 수 있습니다.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 또는 커서의 크기를 설정 합니다.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 메서드를 사용 하면 단일 메서드 호출에서 이러한 값을 설정 합니다.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.

  • Get 또는 가져오기 설정 하 여 커서의 위치를 설정 합니다 CursorTopCursorLeft 속성 또는 set를 호출 하 여 커서의 위치는 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 클래스에서 반환 된 인코딩을 사용 하 여 GetConsoleCPGetConsoleOutputCP, 일반적으로 코드 페이지 인코딩.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. 프로젝트에 System.Text.Encoding.CodePages.dll 어셈블리에 대 한 참조를 추가 합니다.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. 검색 된 EncodingProvider 에서 개체를 CodePagesEncodingProvider.Instance 속성입니다.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 클래스 자동으로 사용 하 여 기본 시스템 인코딩이 UTF8 대신 호출 하기 전에 인코딩 공급자를 등록 된 Console 메서드를 출력 합니다.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 BackgroundColor BackgroundColor BackgroundColor

콘솔의 배경색을 가져오거나 설정합니다.Gets or sets the background color of the console.

BufferHeight BufferHeight BufferHeight BufferHeight

버퍼 영역의 높이를 가져오거나 설정합니다.Gets or sets the height of the buffer area.

BufferWidth BufferWidth BufferWidth BufferWidth

버퍼 영역의 너비를 가져오거나 설정합니다.Gets or sets the width of the buffer area.

CapsLock CapsLock CapsLock CapsLock

Caps Lock 키보드 토글의 설정 또는 해제 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the CAPS LOCK keyboard toggle is turned on or turned off.

CursorLeft CursorLeft CursorLeft CursorLeft

버퍼 영역 내에서 커서의 열 위치를 가져오거나 설정합니다.Gets or sets the column position of the cursor within the buffer area.

CursorSize CursorSize CursorSize CursorSize

문자 셀 내부의 커서 높이를 가져오거나 설정합니다.Gets or sets the height of the cursor within a character cell.

CursorTop CursorTop CursorTop CursorTop

버퍼 영역 내에서 커서의 행 위치를 가져오거나 설정합니다.Gets or sets the row position of the cursor within the buffer area.

CursorVisible CursorVisible CursorVisible CursorVisible

커서가 표시되는지를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value indicating whether the cursor is visible.

Error Error Error Error

표준 오류 출력 스트림을 가져옵니다.Gets the standard error output stream.

ForegroundColor ForegroundColor ForegroundColor ForegroundColor

콘솔의 전경색을 가져오거나 설정합니다.Gets or sets the foreground color of the console.

In In In In

표준 입력 스트림을 가져옵니다.Gets the standard input stream.

InputEncoding InputEncoding InputEncoding InputEncoding

콘솔이 입력을 읽기 위해 사용하는 인코딩을 가져오거나 설정합니다.Gets or sets the encoding the console uses to read input.

IsErrorRedirected IsErrorRedirected IsErrorRedirected IsErrorRedirected

오류 출력 스트림이 표준 오류 스트림에서 리디렉션되었는지를 나타내는 값을 가져옵니다.Gets a value that indicates whether the error output stream has been redirected from the standard error stream.

IsInputRedirected IsInputRedirected IsInputRedirected IsInputRedirected

입력이 표준 입력 스트림에서 리디렉션되었는지를 나타내는 값을 가져옵니다.Gets a value that indicates whether input has been redirected from the standard input stream.

IsOutputRedirected IsOutputRedirected IsOutputRedirected IsOutputRedirected

출력이 표준 출력 스트림에서 리디렉션되었는지를 나타내는 값을 가져옵니다.Gets a value that indicates whether output has been redirected from the standard output stream.

KeyAvailable KeyAvailable KeyAvailable KeyAvailable

입력 스트림에서 키 누름을 사용할 수 있는지를 나타내는 값을 가져옵니다.Gets a value indicating whether a key press is available in the input stream.

LargestWindowHeight LargestWindowHeight LargestWindowHeight LargestWindowHeight

현재 글꼴 및 화면 해상도에 따라 콘솔 창 행의 가능한 최대 수를 가져옵니다.Gets the largest possible number of console window rows, based on the current font and screen resolution.

LargestWindowWidth LargestWindowWidth LargestWindowWidth LargestWindowWidth

현재 글꼴 및 화면 해상도에 따라 콘솔 창 열의 가능한 최대 수를 가져옵니다.Gets the largest possible number of console window columns, based on the current font and screen resolution.

NumberLock NumberLock NumberLock NumberLock

Num Lock 키보드 토글의 설정 또는 해제 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the NUM LOCK keyboard toggle is turned on or turned off.

Out Out Out Out

표준 출력 스트림을 가져옵니다.Gets the standard output stream.

OutputEncoding OutputEncoding OutputEncoding OutputEncoding

콘솔이 출력을 쓰기 위해 사용하는 인코딩을 가져오거나 설정합니다.Gets or sets the encoding the console uses to write output.

Title Title Title Title

콘솔 제목 표시줄에 표시할 제목을 가져오거나 설정합니다.Gets or sets the title to display in the console title bar.

TreatControlCAsInput TreatControlCAsInput TreatControlCAsInput 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 WindowHeight WindowHeight WindowHeight

콘솔 창 영역의 높이를 가져오거나 설정합니다.Gets or sets the height of the console window area.

WindowLeft WindowLeft WindowLeft WindowLeft

화면 버퍼에 상대적인 콘솔 창 영역의 맨 왼쪽 위치를 가져오거나 설정합니다.Gets or sets the leftmost position of the console window area relative to the screen buffer.

WindowTop WindowTop WindowTop WindowTop

화면 버퍼에 상대적인 콘솔 창 영역의 위쪽 위치를 가져오거나 설정합니다.Gets or sets the top position of the console window area relative to the screen buffer.

WindowWidth WindowWidth WindowWidth WindowWidth

콘솔 창의 컨트롤의 너비를 가져오거나 설정합니다.Gets or sets the width of the console window.

메서드

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

콘솔 스피커를 통해 경고음을 재생합니다.Plays the sound of a beep through the console speaker.

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

지정한 시간 동안 지정한 주파수로 콘솔 스피커를 통해 경고음을 재생합니다.Plays the sound of a beep of a specified frequency and duration through the console speaker.

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

콘솔 버퍼와 해당 콘솔 창에서 표시 정보를 지웁니다.Clears the console buffer and corresponding console window of display information.

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

화면 버퍼의 지정한 소스 영역을 지정한 대상 영역에 복사합니다.Copies a specified source area of the screen buffer to a specified destination area.

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

화면 버퍼의 지정한 소스 영역을 지정한 대상 영역에 복사합니다.Copies a specified source area of the screen buffer to a specified destination area.

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

표준 오류 스트림을 가져옵니다.Acquires the standard error stream.

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

표준 오류 스트림을 가져와 지정한 버퍼 크기로 설정합니다.Acquires the standard error stream, which is set to a specified buffer size.

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

표준 입력 스트림을 가져옵니다.Acquires the standard input stream.

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

표준 입력 스트림을 가져와 지정한 버퍼 크기로 설정합니다.Acquires the standard input stream, which is set to a specified buffer size.

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

표준 출력 스트림을 가져옵니다.Acquires the standard output stream.

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

표준 출력 스트림을 가져와 지정한 버퍼 크기로 설정합니다.Acquires the standard output stream, which is set to a specified buffer size.

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

표준 입력 스트림에서 다음 문자를 읽습니다.Reads the next character from the standard input stream.

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

다음 문자나 사용자가 누른 기능 키를 가져옵니다.Obtains the next character or function key pressed by the user. 누른 키는 콘솔 창에 표시됩니다.The pressed key is displayed in the console window.

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

다음 문자나 사용자가 누른 기능 키를 가져옵니다.Obtains the next character or function key pressed by the user. 누른 키는 선택적으로 콘솔 창에 표시됩니다.The pressed key is optionally displayed in the console window.

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

표준 입력 스트림에서 다음 줄의 문자를 읽습니다.Reads the next line of characters from the standard input stream.

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

콘솔의 전경색과 배경색을 해당 기본값으로 설정합니다.Sets the foreground and background console colors to their defaults.

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

화면 버퍼의 높이와 너비를 지정한 값으로 설정합니다.Sets the height and width of the screen buffer area to the specified values.

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

커서의 위치를 설정합니다.Sets the position of the cursor.

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

Error 속성을 지정한 TextWriter 개체로 설정합니다.Sets the Error property to the specified TextWriter object.

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

In 속성을 지정한 TextReader 개체로 설정합니다.Sets the In property to the specified TextReader object.

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

Out 속성을 TextWriter 개체를 대상으로 설정합니다.Sets the Out property to target the TextWriter object.

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

화면 버퍼에 상대적인 콘솔 창의 위치를 설정합니다.Sets the position of the console window relative to the screen buffer.

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

콘솔 창의 높이와 너비를 지정한 값으로 설정합니다.Sets the height and width of the console window to the specified values.

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

지정한 형식 정보를 사용하여 지정한 개체 및 가변 길이 매개 변수 목록의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified objects and variable-length parameter list to the standard output stream using the specified format information.

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

지정한 형식 정보를 사용하여 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified objects to the standard output stream using the specified format information.

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

지정한 형식 정보를 사용하여 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified objects to the standard output stream using the specified format information.

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

지정한 형식 정보를 사용하여 지정한 개체 배열의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified array of objects to the standard output stream using the specified format information.

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

지정한 형식 정보를 사용하여 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified object to the standard output stream using the specified format information.

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

지정한 부호 없는 64비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified 64-bit unsigned integer value to the standard output stream.

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

지정한 부호 없는 32비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified 32-bit unsigned integer value to the standard output stream.

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

지정한 문자열 값을 표준 출력 스트림에 씁니다.Writes the specified string value to the standard output stream.

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

지정한 유니코드 문자의 하위 배열을 표준 출력 스트림에 씁니다.Writes the specified subarray of Unicode characters to the standard output stream.

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

지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified object to the standard output stream.

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

지정한 단정밀도 부동 소수점 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified single-precision floating-point value to the standard output stream.

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

지정한 유니코드 문자 값을 표준 출력 스트림에 씁니다.Writes the specified Unicode character value to the standard output stream.

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

지정한 유니코드 문자의 배열을 표준 출력 스트림에 씁니다.Writes the specified array of Unicode characters to the standard output stream.

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

지정한 부울 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified Boolean value to the standard output stream.

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

지정한 배정밀도 부동 소수점 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified double-precision floating-point value to the standard output stream.

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

지정한 부호 있는 32비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified 32-bit signed integer value to the standard output stream.

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

지정한 부호 있는 64비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified 64-bit signed integer value to the standard output stream.

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

지정한 Decimal 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified Decimal value to the standard output stream.

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

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.

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

뒤에 현재 줄 종결자가 오는, 지정한 문자열 값을 표준 출력 스트림에 씁니다.Writes the specified string value, followed by the current line terminator, to the standard output stream.

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

뒤에 현재 줄 종결자가 오는, 지정한 유니코드 문자의 하위 배열을 표준 출력 스트림에 씁니다.Writes the specified subarray of Unicode characters, followed by the current line terminator, to the standard output stream.

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

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체 배열의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified array of objects, followed by the current line terminator, to the standard output stream using the specified format information.

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

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream using the specified format information.

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

뒤에 현재 줄 종결자가 오는, 부호 없는 64비트 정수 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified 64-bit unsigned integer value, followed by the current line terminator, to the standard output stream.

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

뒤에 현재 줄 종결자가 오는, 부호 없는 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(Single) WriteLine(Single) WriteLine(Single) 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(Decimal) WriteLine(Decimal) WriteLine(Decimal) WriteLine(Decimal)

뒤에 현재 줄 종결자가 오는, 지정한 Decimal 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified Decimal value, followed by the current line terminator, to the standard output stream.

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

뒤에 현재 줄 종결자가 오는, 부호 있는 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(Int32) WriteLine(Int32) WriteLine(Int32) 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(Double) WriteLine(Double) WriteLine(Double) 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(Char[]) WriteLine(Char[]) WriteLine(Char[]) WriteLine(Char[])

뒤에 현재 줄 종결자가 오는, 지정한 유니코드 문자의 배열을 표준 출력 스트림에 씁니다.Writes the specified array of Unicode characters, followed by the current line terminator, to the standard output stream.

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

뒤에 현재 줄 종결자가 오는, 지정한 유니코드 문자 값을 표준 출력 스트림에 씁니다.Writes the specified Unicode character, followed by the current line terminator, value to the standard output stream.

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

뒤에 현재 줄 종결자가 오는, 지정한 부울 값의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified Boolean value, followed by the current line terminator, to the standard output stream.

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

현재 줄 종결자를 표준 출력 스트림에 씁니다.Writes the current line terminator to the standard output stream.

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

지정한 형식 정보를 사용하여 뒤에 현재 줄 종결자가 오는, 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified objects, followed by the current line terminator, to the standard output stream using the specified format information.

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

뒤에 현재 줄 종결자가 오는, 지정한 개체의 텍스트 표현을 표준 출력 스트림에 씁니다.Writes the text representation of the specified object, followed by the current line terminator, to the standard output stream.

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

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

이벤트

CancelKeyPress CancelKeyPress CancelKeyPress CancelKeyPress

Control 보조 키(Ctrl)와 C 콘솔 키(C) 또는 Break 키를 동시에 누르면(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.