String.Format String.Format String.Format String.Format Method

Definition

지정된 형식에 따라 개체의 값을 문자열로 변환하여 다른 문자열에 삽입 합니다. Converts the value of objects to strings based on the formats specified and inserts them into another string. String.Format 메서드를 처음 사용하는 경우 String.Format 메서드 시작 섹션에서 대략적인 내용을 살펴보세요. If you are new to the String.Format method, see the Get started with the String.Format method section for a quick overview. String.Format 메서드에 대한 일반 설명서는 설명 섹션을 참조하세요. See the Remarks section for general documentation for the String.Format method.

Overloads

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 세 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representation of three specified objects. 매개 변수에서 문화권별 형식 지정 정보를 제공합니다. An parameter supplies culture-specific formatting information.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 세 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representation of three specified objects.

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 두 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representation of two specified objects. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다. A parameter supplies culture-specific formatting information.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 두 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representation of two specified objects.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

문자열의 형식 항목을 지정된 배열에 있는 해당 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representations of corresponding objects in a specified array. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다. A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object)

지정된 문자열에 있는 하나의 형식 항목 또는 여러 개의 형식 항목을 해당하는 개체의 문자열 표현으로 바꿉니다. Replaces the format item or items in a specified string with the string representation of the corresponding object. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다. A parameter supplies culture-specific formatting information.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

지정된 문자열의 형식 항목을 지정된 배열에 있는 해당 개체의 문자열 표현으로 바꿉니다. Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

Format(String, Object) Format(String, Object) Format(String, Object) Format(String, Object)

문자열에 있는 하나 이상의 형식 항목을 지정된 개체의 문자열 표현으로 바꿉니다. Replaces one or more format items in a string with the string representation of a specified object.

Examples

호출 하는 다양 한 예제는 Format 메서드를 통해 섞여는 합니다 주의 이 문서의 섹션입니다.Numerous examples that call the Format method are interspersed through the Remarks section of this article.

참고

이 문서의 C# 예제는 Try.NET 인라인 코드 러너 및 놀이터에서 실행됩니다.The C# examples in this article run in the Try.NET inline code runner and playground. 대화형 창에서 예제를 실행하려면 실행 버튼을 선택합니다.Select the Run button to run an example in an interactive window. 코드를 실행하면 실행을 다시 선택하여 코드를 수정하고 수정된 코드를 실행할 수 있습니다.Once you execute the code, you can modify it and run the modified code by selecting Run again. 수정된 코드는 대화형 창에서 실행되거나, 컴파일이 실패하면 대화형 창에 모든 C# 컴파일러 오류 메시지가 표시됩니다.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

전체 집합을 다운로드할 수도 있습니다 String.Format 포함 된 예는 C#에 대 한.NET Core 2.0 프로젝트Visual basic.NET Core 2.0 프로젝트에서 dotnet / 샘플 GitHub 리포지토리합니다.You can also download a complete set of String.Format examples, which are included a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

다음은 일부 문서에 포함 된 예제입니다.The following are some of the examples included in the article:

형식 문자열을 만들려면Create a format string

문자열을 삽입Inserting a string
형식 항목The format item
동일한 인덱스에 있는 형식 항목Format items that have the same index

서식이 지정 된 출력 제어Control formatted output

서식 제어Controlling formatting
간격을 제어합니다.Controlling spacing
맞춤을 제어합니다.Controlling alignment
정수 자릿수를 제어합니다.Controlling the number of integral digits
소수 자릿수를 소수 구분 기호 뒤 제어Controlling the number of digits after the decimal separator
결과 문자열에 리터럴 중괄호를 포함 하 여Including literal braces in a result string

문화권 구분 서식 문자열 확인Make format strings culture-sensitive

문화권 구분 서식 지정Culture-sensitive formatting

서식 지정 작업을 사용자 지정Customize the formatting operation

사용자 지정 서식 지정 작업A custom formatting operation
절편 공급자 및 로마 숫자 포맷터An intercept provider and Roman numeral formatter

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

섹션 내용In this section:

String.Format 메서드 시작 Get started with the String.Format method
메서드 호출 합니까? Which method do I call?
개요에서 Format 메서드 The Format method in brief
형식 항목 The Format item
인수 형식 지정 방법을 How arguments are formatted
동일한 인덱스에 있는 형식 항목 Format items that have the same index
서식 지정 및 문화권 Formatting and culture
사용자 지정 서식 지정 작업 Custom formatting operations
String.Format q&aString.Format Q & A

String.Format 메서드 시작Get started with the String.Format method

사용 하 여 String.Format 다른 문자열에는 개체, 변수 또는 식의 값을 삽입 하는 경우.Use String.Format if you need to insert the value of an object, variable, or expression into another string. 예를 들어,의 값을 삽입할 수 있습니다를 Decimal 값을 단일 문자열로 사용자에 게 표시할 문자열입니다.For example, you can insert the value of a Decimal value into a string to display it to the user as a single string:

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0} per ounce.",
                           pricePerOunce);
// Result: The current price is 17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0} per ounce.",
                                pricePerOunce)
' Result: The current price is 17.36 per ounce.

및 해당 값의 서식을 제어할 수 있습니다.And you can control that value's formatting:

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0:C2} per ounce.",
                           pricePerOunce);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
                                pricePerOunce)
' Result if current culture is en-US:
'      The current price is $17.36 per ounce.

서식 지정 하는 것 외에도 맞춤 및 간격을 제어할 수 있습니다.Besides formatting, you can also control alignment and spacing.

문자열을 삽입Inserting a string

String.Format 하나 이상의 개체 또는 문자열로 변환 되며 형식 문자열에서 지정된 된 위치에 삽입 하는 식 뒤에 형식 문자열을 사용 하 여 시작 합니다.String.Format starts with a format string, followed by one or more objects or expressions that will be converted to strings and inserted at a specified place in the format string. 예:For example:

Decimal temp = (Decimal)20.4;
String^ s = String::Format("The temperature is {0}°C.", temp);
Console::WriteLine(s);
// Displays 'The temperature is 20.4°C.'
decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'
Dim temp As Decimal = 20.4d
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'

{0} 형식 문자열의 형식 항목입니다.The {0} in the format string is a format item. 0 문자열 값인 해당 위치에 삽입할 개체의 인덱스가입니다.0 is the index of the object whose string value will be inserted at that position. (인덱스 0부터 시작)입니다. 삽입할 개체는 문자열이 아닌 경우 해당 ToString 메서드를 호출 하는 결과 문자열에 삽입 하기 전에 하나를 변환 합니다.(Indexes start at 0.) If the object to be inserted is not a string, its ToString method is called to convert it to one before inserting it in the result string.

개체 목록에서 두 개의 형식 항목이 및 두 개의 개체를 사용 하는 또 다른 예는 다음과 같습니다.Here's another example that uses two format items and two objects in the object list:

String^ s = String::Format("At {0}, the temperature is {1}°C.",
                           DateTime::Now, 20.4);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
string s = String.Format("At {0}, the temperature is {1}°C.",
                         DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
                                Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

만큼 서식 항목이 있을 수 있으며 모든 서식 항목의 인덱스 개체 목록에서 일치 하는 개체에 많은 개체와 개체 목록에서 원하는 합니다.You can have as many format items and as many objects in the object list as you want, as long as the index of every format item has a matching object in the object list. 또한 필요가 걱정는 오버 로드에 대 한 호출입니다. 컴파일러는 적절 한 수를 선택 합니다.You also don't have to worry about which overload you call; the compiler will select the appropriate one for you.

서식 제어Controlling formatting

개체의 서식 지정 하는 방법을 제어 하는 서식 문자열을 사용 하 여 형식 항목의 인덱스를 따를 수 있습니다.You can follow the index in a format item with a format string to control how an object is formatted. 예를 들어 {0:d} "d" 서식 문자열 개체 목록의 첫 번째 개체에 적용 됩니다.For example, {0:d} applies the "d" format string to the first object in the object list. 다음은 단일 개체를 사용 하 여 예제 및 두 항목의 서식을 지정 합니다.Here is an example with a single object and two format items:

String^ s = String::Format("It is now {0:d} at {0:t}",
                           DateTime::Now);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Dim s As String = String.Format("It is now {0:d} at {0:t}",
                                Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'

형식 문자열, 모든 숫자 형식을 비롯 한 다양 한 형식 지원 (둘 다 표준사용자 지정 형식 문자열), 모든 날짜 및 시간 (둘 다 표준 하고사용자 지정 형식 문자열) 및 시간 간격 (둘 다 표준 하 고 사용자 지정 형식 문자열), 모든 열거형 형식은 열거형 형식 , 및 Guid합니다.A number of types support format strings, including all numeric types (both standard and custom format strings), all dates and times (both standard and custom format strings) and time intervals (both standard and custom format strings), all enumeration types enumeration types, and GUIDs. 또한 사용자 고유의 형식에 형식 문자열에 대 한 지원을 추가할 수 있습니다.You can also add support for format strings to your own types.

간격을 제어합니다.Controlling spacing

와 같은 구문을 사용 하 여 결과 문자열에 삽입 되는 문자열의 너비를 정의할 수 있습니다 {0,12}, 12 문자열 삽입 합니다.You can define the width of the string that is inserted into the result string by using syntax such as {0,12}, which inserts a 12-character string. 이 예제의 첫 번째 개체의 문자열 표현을 12 자 필드에 오른쪽 맞춤를 경우.In this case, the string representation of the first object is right-aligned in the 12-character field. (첫 번째 개체의 문자열 표현을 길이가 12 개 이상의 문자 이면 그러나 기본 필드 너비를 무시 되 고 전체 문자열이 결과 문자열에 삽입 됩니다.)(If the string representation of the first object is more than 12 characters in length, though, the preferred field width is ignored, and the entire string is inserted into the result string.)

다음 예제에서는 문자열을 보관할 6 자리 필드 정의 "Year" 및 일부 연도 문자열 뿐만 15 자 필드를 "채우기" 문자열을 보유할 수 및 일부 인구 데이터입니다.The following example defines a 6-character field to hold the string "Year" and some year strings, as well as an 15-character field to hold the string "Population" and some population data. 문자는 오른쪽 맞춤 필드 note 합니다.Note that the characters are right-aligned in the field.

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
StringBuiler^ sb = gcnew StringBuilder();
sb->Append(String::Format("{0,6} {1,15}\n\n", "Year", "Population"));
for(int index = 0; index < years->Length; index++)
   sb->AppendFormat("{0,6} {1,15:N0}\n",
                    years[index], population[index]);
// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203
using System;
using System.Text;
 
class Example
{
   public static void Main()
   {
       // <Snippet33>
       int[] years = { 2013, 2014, 2015 };
       int[] population = { 1025632, 1105967, 1148203 };
       var sb = new StringBuilder();
       sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
       for (int index = 0; index < years.Length; index++)
          sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));
  
       Console.WriteLine(sb);
   }
}  
// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203


Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer  = { 1025632, 1105967, 1148203 }
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
                        "Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
   sb.AppendFormat("{0,6} {1,15:N0}{2}",
                   years(index), population(index), vbCrLf)
Next
' Result:
'      Year      Population
'
'      2013       1,025,632
'      2014       1,105,967
'      2015       1,148,203

맞춤을 제어합니다.Controlling alignment

기본적으로 문자열은 해당 필드 내에서 오른쪽 정렬 필드 너비를 지정 하는 경우입니다.By default, strings are right-aligned within their field if you specify a field width. 문자열 필드에서를 왼쪽에 맞추려면 앞 음수 기호를 사용 하 여 필드 너비와 같은 {0,-12} 12 문자 왼쪽으로 맞춰져 있으며 필드를 정의 합니다.To left-align strings in a field, you preface the field width with a negative sign, such as {0,-12} to define a 12-character left-aligned field.

다음 예제에서는 왼쪽 맞춤 레이블 및 데이터를 둘 다는 점을 제외 하 고 이전 쿼리와 비슷합니다.The following example is similar to the previous one, except that it left-aligns both labels and data.

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
String^ s = String::Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years->Length; index++)
   s += String::Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer  = { 1025632, 1105967, 1148203 }
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
                                "Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
   s += String.Format("{0,-10} {1,-10:N0}{2}",
                      years(index), population(index), vbCrLf)
Next
' Result:
'    Year       Population
'
'    2013       1,025,632
'    2014       1,105,967
'    2015       1,148,203

String.Format 에서는 복합 서식 지정 기능을 활용합니다.String.Format makes use of the composite formatting feature. 자세한 내용은 복합 서식 지정을 참조하세요.For more information, see Composite Formatting.

메서드 호출 합니까?Which method do I call?

대상To CallCall
현재 문화권의 규칙을 사용 하 여 하나 이상의 개체 형식을 지정 합니다.Format one or more objects by using the conventions of the current culture. 포함 하는 오버 로드를 제외 하 고는 provider 매개 변수를 나머지 Format 오버 로드 포함을 String 하나 이상의 개체 매개 변수 뒤에 매개 변수입니다.Except for the overloads that include a provider parameter, the remaining Format overloads include a String parameter followed by one or more object parameters. 이 인해 결정 필요가 Format 호출 하려는 오버 로드 합니다.Because of this, you don't have to determine which Format overload you intend to call. 없는 오버 로드 중에서 적절 한 오버 로드를 선택 하는 언어 컴파일러는 provider 매개 변수를 인수 목록에 기반 합니다.Your language compiler selects the appropriate overload from among the overloads that don't have a provider parameter, based on your argument list. 예를 들어, 인수 목록에 다섯 개의 인수, 있는 경우 컴파일러를 호출 합니다 Format(String, Object[]) 메서드.For example, if your argument list has five arguments, the compiler calls the Format(String, Object[]) method.
특정 문화권의 규칙을 사용 하 여 하나 이상의 개체 형식을 지정 합니다.Format one or more objects by using the conventions of a specific culture. Format 시작 하는 오버 로드 된 provider 뒤에 매개 변수를 String 매개 변수 및 하나 이상의 매개 변수 개체입니다.Each Format overload that begins with a provider parameter is followed by a String parameter and one or more object parameters. 이 인해 특정 확인할 필요가 Format 호출 하려는 오버 로드 합니다.Because of this, you don't have to determine which specific Format overload you intend to call. 언어 컴파일러는 오버 로드 중에서 적절 한 오버 로드를 선택는 provider 매개 변수를 인수 목록에 기반 합니다.Your language compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. 예를 들어, 인수 목록에 다섯 개의 인수, 있는 경우 컴파일러를 호출 합니다 Format(IFormatProvider, String, Object[]) 메서드.For example, if your argument list has five arguments, the compiler calls the Format(IFormatProvider, String, Object[]) method.
사용 하 여 사용자 지정 서식 지정 작업 수행을 ICustomFormatter 구현 또는 IFormattable 구현 합니다.Perform a custom formatting operation either with an ICustomFormatter implementation or an IFormattable implementation. 4 개의 오버 로드 중 하나는 provider 매개 변수입니다.Any of the four overloads with a provider parameter. 컴파일러는 오버 로드 중에서 적절 한 오버 로드를 선택는 provider 매개 변수를 인수 목록에 기반 합니다.The compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list.

개요에서 Format 메서드The Format method in brief

각 오버 로드는 Format 메서드를 복합 서식 지정 기능 호출부터 인덱싱된 자리 표시자를 포함 하도록 항목의 서식을 지정, 복합 형식 문자열에 합니다.Each overload of the Format method uses the composite formatting feature to include zero-based indexed placeholders, called format items, in a composite format string. 런타임 시 각 서식 항목 매개 변수 목록에서 해당 인수의 문자열 표현으로 바뀝니다.At run time, each format item is replaced with the string representation of the corresponding argument in a parameter list. 인수의 값이 null, 형식 항목으로 바뀝니다. String.Empty합니다.If the value of the argument is null, the format item is replaced with String.Empty. 다음을 호출 하는 예를 들어를 Format(String, Object, Object, Object) 메서드는 세 가지 형식 항목을 사용 하 여 형식 문자열을 포함할 {0}, {1}, 및 {2}, 및 세 개 항목으로 인수 목록.For example, the following call to the Format(String, Object, Object, Object) method includes a format string with three format items, {0}, {1}, and {2}, and an argument list with three items.

using namespace System;

void main()
{
   DateTime^ dat = gcnew DateTime(2012, 1, 17, 9, 30, 0); 
   String^ city = "Chicago";
   int temp = -16;
   String^ output = String::Format("At {0} in {1}, the temperature was {2} degrees.",
                                   dat, city, temp);
   Console::WriteLine(output);
}
// The example displays the following output: 
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   
DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0); 
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                              dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   
Dim dat As Date = #1/17/2012 9:30AM# 
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                                     dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
'    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   

형식 항목The format item

형식 항목에이 구문이 있습니다.A format item has this syntax:

{index[,alignment][:formatString]}  

대괄호는 선택적 요소를 나타냅니다.Brackets denote optional elements. 여는 태그와 닫는 중괄호는 필요 합니다.The opening and closing braces are required. (리터럴 여 포함 하거나 참조 형식 문자열에서는 닫는 중괄호는 중괄호 이스케이프 섹션을 복합 서식 지정 문서입니다.)(To include a literal opening or closing brace in the format string, see the Escaping Braces section in the Composite Formatting article.)

예를 들어 통화 값 서식을 지정 하려면 형식 항목은 다음과 같이 나타날 수 있습니다.For example, a format item to format a currency value might appear like this:

String::Format("{0,-10:C}", (Decimal) 126347.89);         
var value = String.Format("{0,-10:C}", 126347.89m);         
Console.WriteLine(value);
String.Format("{0,-10:C}", 126347.89d)        

형식 항목에는 다음 요소가 있습니다.A format item has the following elements:

indexindex
문자열 표현의 인수의 인덱스 문자열의이 위치에 포함 합니다.The zero-based index of the argument whose string representation is to be included at this position in the string. 이 인수가 null, 빈 문자열은 문자열의이 위치에 포함 됩니다.If this argument is null, an empty string will be included at this position in the string.

alignmentalignment
선택 사항입니다.Optional. 인수 삽입 되는 지, 오른쪽 맞춤 되 (양의 정수) 왼쪽 맞춤 (음의 정수)에 필드의 총 길이 나타내는 부호 있는 정수입니다.A signed integer that indicates the total length of the field into which the argument is inserted and whether it is right-aligned (a positive integer) or left-aligned (a negative integer). 생략 하면 맞춤, 선행 또는 후행 공백 없이 필드에 해당 인수의 문자열 표현을 삽입 됩니다.If you omit alignment, the string representation of the corresponding argument is inserted in a field with no leading or trailing spaces.

경우 값 맞춤 삽입할 인수의 길이 보다 작으면 맞춤 무시 됩니다 및 인수의 문자열 표현의 길이가 필드 너비로 사용 됩니다.If the value of alignment is less than the length of the argument to be inserted, alignment is ignored and the length of the string representation of the argument is used as the field width.

formatStringformatString
선택 사항입니다.Optional. 해당 인수의 결과 문자열의 형식을 지정 하는 문자열입니다.A string that specifies the format of the corresponding argument's result string. 생략 하면 formatString에 해당 인수가 매개 변수가 없는 ToString 메서드를 호출 하는 문자열 표현을 생성 합니다.If you omit formatString, the corresponding argument's parameterless ToString method is called to produce its string representation. 지정 하는 경우 formatString, 형식 항목에서 참조 하는 인수를 구현 해야 합니다는 IFormattable 인터페이스입니다.If you specify formatString, the argument referenced by the format item must implement the IFormattable interface. 형식 문자열을 지 원하는 형식이 포함 합니다.Types that support format strings include:

그러나 모든 사용자 지정 형식을 구현할 수 있습니다 IFormattable 기존 형식을 확장할 또는 IFormattable 구현 합니다.However, note that any custom type can implement IFormattable or extend an existing type's IFormattable implementation.

다음 예제에서는 합니다 alignmentformatString 인수 형식이 지정 된 출력을 생성 합니다.The following example uses the alignment and formatString arguments to produce formatted output.

using namespace System;

void main()
{
   // Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
   array<Tuple<String^, DateTime, int, DateTime, int>^>^ cities = gcnew array<Tuple<String^, DateTime, int, DateTime, int>^> 
         { gcnew Tuple<String^, DateTime, int, DateTime, int>("Los Angeles", DateTime(1940, 1, 1), 1504277, 
                        DateTime(1950, 1, 1), 1970358),
         gcnew Tuple<String^, DateTime, int, DateTime, int>("New York", DateTime(1940, 1, 1), 7454995, 
                        DateTime(1950, 1, 1), 7891957),  
         gcnew Tuple<String^, DateTime, int, DateTime, int>("Chicago", DateTime(1940, 1, 1), 3396808, 
                        DateTime(1950, 1, 1), 3620962),  
         gcnew Tuple<String^, DateTime, int, DateTime, int>("Detroit", DateTime(1940, 1, 1), 1623452, 
                        DateTime(1950, 1, 1), 1849568) };

   // Display header
   String^ header = String::Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                                   "City", "Year", "Population", "Change (%)");
   Console::WriteLine(header);
   String^ output;      
   for each (Tuple<String^, DateTime, int, DateTime, int>^ city in cities) {
      output = String::Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                              city->Item1, city->Item2, city->Item3, city->Item4, city->Item5,
                              (city->Item5 - city->Item3)/ (double)city->Item3);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//    
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
using System;

public class Example
{
   public static void Main()
   {
      // Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
      Tuple<string, DateTime, int, DateTime, int>[] cities = 
          { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277, 
                         new DateTime(1950, 1, 1), 1970358),
            Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995, 
                         new DateTime(1950, 1, 1), 7891957),  
            Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808, 
                         new DateTime(1950, 1, 1), 3620962),  
            Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452, 
                         new DateTime(1950, 1, 1), 1849568) };

      // Display header
      var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                                    "City", "Year", "Population", "Change (%)");
      Console.WriteLine(header);
      foreach (var city in cities) {
         var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                                city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                                (city.Item5 - city.Item3)/ (double)city.Item3);
         Console.WriteLine(output);
      }
   }
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//    
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
Module Example
   Public Sub Main()
      ' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
      Dim cities()  = _
          { Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
            Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),  
            Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),  
            Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568) }

      ' Display header
      Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
                                           "City", "Year", "Population", "Change (%)")
      Console.WriteLine(header)
      Console.WriteLine()
      For Each city In cities
         Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                                city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                                (city.Item5 - city.Item3)/city.Item3)
         Console.WriteLine(output)
      Next
   End Sub
End Module
' The example displays the following output:
'    City            Year  Population    Year  Population    Change (%)
'    
'    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
'    New York        1940   7,454,995    1950   7,891,957         5.9 %
'    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
'    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

인수 형식 지정 방법을How arguments are formatted

형식 항목 문자열의 시작 부분에서 순차적으로 처리 됩니다.Format items are processed sequentially from the beginning of the string. 각 서식 항목 메서드의 인수 목록에서 개체에 해당 하는 인덱스를 있습니다.Each format item has an index that corresponds to an object in the method's argument list. Format 메서드 인수를 검색 하 고 해당 문자열 표현에 다음과 같이 파생 됩니다.The Format method retrieves the argument and derives its string representation as follows:

에 대 한 호출을 가로채는 예는 ICustomFormatter.Format 메서드 어떤 정보를 볼 수 있습니다 합니다 Format 메서드가 전달 복합 형식 문자열의 각 서식 항목에 대 한 형식 지정 메서드를 참조 하세요 예제: 절편 공급자로 및 로마 숫자 포맷터합니다.For an example that intercepts calls to the ICustomFormatter.Format method and allows you to see what information the Format method passes to a formatting method for each format item in a composite format string, see Example: An intercept provider and Roman numeral formatter.

자세한 내용은 참조 하세요. 합니다 처리 순서 섹션을 복합 서식 지정 문서.For more information, see the Processing Order section in the Composite Formatting article.

동일한 인덱스에 있는 형식 항목Format items that have the same index

합니다 Format 메서드가 throw를 FormatException 인덱스 항목의 인덱스는 인수 목록의 인수 개수 보다 크거나 같으면 예외입니다.The Format method throws a FormatException exception if the index of an index item is greater than or equal to the number of arguments in the argument list. 그러나 format 여러 서식 항목이 동일한 인덱스를가지고 있다면 인수가 있으면 것 보다 많은 수의 서식 항목이 포함 될 수 있습니다.However, format can include more format items than there are arguments, as long as multiple format items have the same index. 호출에는 Format(String, Object) 다음 예제에서는 인수 목록에에서 메서드는 단일 인수를 갖지만 형식 문자열에 두 개의 형식 항목이 포함 되어: 숫자의 소수 값이 표시 됩니다 하나 및 다른 16 진수 값을 표시 합니다.In the call to the Format(String, Object) method in following example, the argument list has a single argument, but the format string includes two format items: one displays the decimal value of a number, and the other displays its hexadecimal value.

public class Example
{
   public static void Main()
   {
      short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
      Console.WriteLine("{0,10}  {1,10}\n", "Decimal", "Hex");
      foreach (short value in values)
      {
         string formatString = String.Format("{0,10:G}: {0,10:X}", value);
         Console.WriteLine(formatString);
      }   
   }
}
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF
Module Example
   Public Sub Main()
      Dim values() As Short = { Int16.MinValue, -27, 0, 1042, Int16.MaxValue }
      Console.WriteLine("{0,10}  {1,10}", "Decimal", "Hex")
      Console.WriteLine()
      For Each value As Short In values
         Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
         Console.WriteLine(formatString)
      Next        
   End Sub
End Module
' The example displays the following output:
'       Decimal         Hex
'    
'        -32768:       8000
'           -27:       FFE5
'             0:          0
'          1042:        412
'         32767:       7FFF

서식 지정 및 문화권Formatting and culture

일반적으로 인수 목록의 개체에서 반환 하는 현재 문화권의 규칙을 사용 하 여 해당 문자열 표현으로 변환 됩니다는 CultureInfo.CurrentCulture 속성입니다.Generally, objects in the argument list are converted to their string representations by using the conventions of the current culture, which is returned by the CultureInfo.CurrentCulture property. 오버 로드 중 하나를 호출 하 여이 동작을 제어할 수 있습니다 Format 포함 하는 한 provider 매개 변수입니다.You can control this behavior by calling one of the overloads of Format that includes a provider parameter. 합니다 provider 매개 변수는는 IFormatProvider 구현 형식을 조정 하는 데 사용 되는 사용자 지정 및 문화권별 형식 지정 정보를 제공 하는 프로세스입니다.The provider parameter is an IFormatProvider implementation that supplies custom and culture-specific formatting information that is used to moderate the formatting process.

합니다 IFormatProvider 인터페이스에는 단일 멤버인 GetFormat는 서식 지정 정보를 제공 하는 개체를 반환 하는 일을 담당 합니다.The IFormatProvider interface has a single member, GetFormat, which is responsible for returning the object that provides formatting information. .NET에는 3 개의 IFormatProvider culture 별 서식 지정을 제공 하는 구현 합니다..NET has three IFormatProvider implementations that provide culture-specific formatting:

사용자 지정 서식 지정 작업Custom formatting operations

오버 로드 중 하나를 호출할 수도 있습니다는 Format 있는 메서드를 provider 형식의 매개 변수 IFormatProvider 사용자 지정 서식 지정 작업을 수행 하 합니다.You can also call the any of the overloads of the Format method that have a provider parameter of type IFormatProvider to perform custom formatting operations. 예를 들어, 전화 번호 또는 id로 정수를 서식을 지정할 수 있습니다.For example, you could format an integer as an identification number or as a telephone number. 사용자 지정 형식 지정을 수행 하 여 provider 인수 둘 다 구현 해야 합니다는 IFormatProviderICustomFormatter 인터페이스입니다.To perform custom formatting, your provider argument must implement both the IFormatProvider and ICustomFormatter interfaces. 경우는 Format 메서드에 전달 됩니다는 ICustomFormatter 구현으로는 provider 인수를를 Format 메서드 호출 해당 IFormatProvider.GetFormat 구현 형식의 개체를 요청 하 고 ICustomFormatter합니다.When the Format method is passed an ICustomFormatter implementation as the provider argument, the Format method calls its IFormatProvider.GetFormat implementation and requests an object of type ICustomFormatter. 그런 다음 반환 된 호출 ICustomFormatter 개체의 Format 복합 문자열의 각 서식 항목 형식을 지정 메서드를 전달 합니다.It then calls the returned ICustomFormatter object's Format method to format each format item in the composite string passed to it.

사용자 지정 형식 지정 솔루션을 제공 하는 방법에 대 한 자세한 내용은 참조 하세요. 방법: 정의 및 사용 하 여 사용자 지정 숫자 서식 공급자ICustomFormatter입니다.For more information about providing custom formatting solutions, see How to: Define and Use Custom Numeric Format Providers and ICustomFormatter. 서식이 지정 된 사용자 지정 숫자 정수를 변환 하는 예제를 보려면 예제: 사용자 지정 서식 지정 작업합니다.For an example that converts integers to formatted custom numbers, see Example: A custom formatting operation. 부호 없는 바이트 로마 숫자 변환 하는 예제를 보려면 예제: 절편 공급자 및 로마 숫자 포맷터를입니다.For an example that converts unsigned bytes to Roman numerals, see Example: An intercept provider and Roman numeral formatter.

예: 사용자 지정 서식 지정 작업Example: A custom formatting operation

이 예제에서는 폼 x-xxxxx-xx에서 고객 계정 번호로 정수 값의 서식을 지정 하는 형식 공급자를 정의 합니다.This example defines a format provider that formats an integer value as a customer account number in the form x-xxxxx-xx.

using namespace System;

ref class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType) 
   {
      if (formatType == ICustomFormatter::typeid)        
         return this; 
      else 
         return nullptr; 
   }
   
   virtual String^ Format(String^ format, 
	               Object^ arg, 
	               IFormatProvider^ formatProvider) 
   {                       
      if (! this->Equals(formatProvider))
      {
         return nullptr;
      }
      else
      {
         if (String::IsNullOrEmpty(format)) 
            format = "G";
         
         String^ customerString = arg->ToString();
         if (customerString->Length < 8)
            customerString = customerString->PadLeft(8, '0');
         
         format = format->ToUpper();
         if (format == L"G") 
               return customerString->Substring(0, 1) + "-" +
                                     customerString->Substring(1, 5) + "-" +
                                     customerString->Substring(6);
         else if (format == L"S")                          
               return customerString->Substring(0, 1) + "/" +
                                     customerString->Substring(1, 5) + "/" +
                                     customerString->Substring(6);
         else if (format == L"P")
               return customerString->Substring(0, 1) + "." +
                                     customerString->Substring(1, 5) + "." +
                                     customerString->Substring(6);
         else
               throw gcnew FormatException( 
                         String::Format("The '{0}' format specifier is not supported.", format));
         }
    }   
};

void main()
{
   int acctNumber = 79203159;
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:G}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:S}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:P}", acctNumber));
   try {
      Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:X}", acctNumber));
   }
   catch (FormatException^ e) {
      Console::WriteLine(e->Message);
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
using System;

public class TestFormatter
{
   public static void Main()
   {
      int acctNumber = 79203159;
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:G}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:S}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:P}", acctNumber));
      try {
         Console.WriteLine(String.Format(new CustomerFormatter(), "{0:X}", acctNumber));
      }
      catch (FormatException e) {
         Console.WriteLine(e.Message);
      }
   }
}

public class CustomerFormatter : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType) 
   {
      if (formatType == typeof(ICustomFormatter))        
         return this; 
      else
         return null;
   }
   
   public string Format(string format, 
	                     object arg, 
	                     IFormatProvider formatProvider) 
   {                       
      if (! this.Equals(formatProvider))
      {
         return null;
      }
      else
      {
         if (String.IsNullOrEmpty(format)) 
            format = "G";
         
         string customerString = arg.ToString();
         if (customerString.Length < 8)
            customerString = customerString.PadLeft(8, '0');
         
         format = format.ToUpper();
         switch (format)
         {
            case "G":
               return customerString.Substring(0, 1) + "-" +
                                     customerString.Substring(1, 5) + "-" +
                                     customerString.Substring(6);
            case "S":                          
               return customerString.Substring(0, 1) + "/" +
                                     customerString.Substring(1, 5) + "/" +
                                     customerString.Substring(6);
            case "P":                          
               return customerString.Substring(0, 1) + "." +
                                     customerString.Substring(1, 5) + "." +
                                     customerString.Substring(6);
            default:
               throw new FormatException( 
                         String.Format("The '{0}' format specifier is not supported.", format));
         }
      }   
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
Module TestFormatter
   Public Sub Main()
      Dim acctNumber As Integer = 79203159
      Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
      Try
         Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
      Catch e As FormatException
         Console.WriteLine(e.Message)
      End Try   
   End Sub
End Module

Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(type As Type) As Object  _
                   Implements IFormatProvider.GetFormat
      If type Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, _
	                       arg As Object, _
	                       formatProvider As IFormatProvider) As String _
	                Implements ICustomFormatter.Format
      If Not Me.Equals(formatProvider) Then
         Return Nothing
      Else
         If String.IsNullOrEmpty(fmt) Then fmt = "G"
         
         Dim customerString As String = arg.ToString()
         if customerString.Length < 8 Then _
            customerString = customerString.PadLeft(8, "0"c)
         
         Select Case fmt
            Case "G"
               Return customerString.Substring(0, 1) & "-" & _
                                     customerString.Substring(1, 5) & "-" & _
                                     customerString.Substring(6)
            Case "S"                         
               Return customerString.Substring(0, 1) & "/" & _
                                     customerString.Substring(1, 5) & "/" & _
                                     customerString.Substring(6)
            Case "P"
               Return customerString.Substring(0, 1) & "." & _
                                     customerString.Substring(1, 5) & "." & _
                                     customerString.Substring(6)
            Case Else
               Throw New FormatException( _
                         String.Format("The '{0}' format specifier is not supported.", fmt))
         End Select                                                     
      End If   
   End Function
End Class
' The example displays the following output:
'       7-92031-59
'       7-92031-59
'       7/92031/59
'       7.92031.59
'       The 'X' format specifier is not supported.

예:는 절편 공급자 및 로마 숫자 포맷터Example: An intercept provider and Roman numeral formatter

구현 하는 사용자 지정 형식 공급자를 정의 하는이 예제는 ICustomFormatterIFormatProvider 두 작업을 수행 하는 인터페이스:This example defines a custom format provider that implements the ICustomFormatter and IFormatProvider interfaces to do two things:

  • 전달 된 매개 변수 표시 해당 ICustomFormatter.Format 구현 합니다.It displays the parameters passed to its ICustomFormatter.Format implementation. 매개 변수를 볼 수 있게 된 Format(IFormatProvider, String, Object[]) 메서드 형식을 지정 하려고 하는 각 개체에 대 한 사용자 지정 서식 지정 구현에 전달 됩니다.This enables us to see what parameters the Format(IFormatProvider, String, Object[]) method is passing to the custom formatting implementation for each object that it tries to format. 이 응용 프로그램을 디버깅할 때 유용할 수 있습니다.This can be useful when you're debugging your application.

  • 서식을 지정할 개체는 "R" 표준 서식 문자열을 사용 하 여 형식을 지정할 수 있는 부호 없는 바이트 값 이면 사용자 지정 포맷터 서식을 로마 숫자를 숫자 값을 지정 합니다.If the object to be formatted is an unsigned byte value that is to be formatted by using the "R" standard format string, the custom formatter formats the numeric value as a Roman numeral.

using namespace System;
using namespace System::Globalization;

ref class InterceptProvider : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType)
   {
      if (formatType == ICustomFormatter::typeid)   
         return this;
      else
         return nullptr;
   }
   
   virtual String^ Format(String^ format, Object^ obj, IFormatProvider^ provider) 
   {
      // Display information about method call.
      String^ formatString = format != nullptr ? format : "<null>";
      Console::WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, obj != nullptr ? obj : "<null>", formatString);
                        
      if (obj == nullptr) return String::Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj->GetType() == Byte::typeid && formatString->ToUpper()->Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String^ returnString = String::Empty;

         // Get the hundreds digit(s)
         result = Math::DivRem(value, 100, remainder);
         if (result > 0)  
            returnString = gcnew String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math::DivRem(value, 50, remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math::DivRem(value, 10, remainder);
         if (result > 0)
            returnString += gcnew String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math::DivRem(value, 5, remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += gcnew String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString->IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString->IndexOf("L"); 
            if ((xPos >= 0) & (xPos == pos - 1))
               returnString = returnString->Replace("LXXXX", "XC");
            else
               returnString = returnString->Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString->IndexOf("IIII");
         if (pos >= 0)
            if (returnString->IndexOf("V") >= 0)
               returnString = returnString->Replace("VIIII", "IX");
            else
               returnString = returnString->Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj->GetType() == IFormattable::typeid)
         return ((IFormattable^) obj)->ToString(format, CultureInfo::CurrentCulture);
      else
         return obj->ToString();
   }
};

void main()
{
   int n = 10;
   double value = 16.935;
   DateTime day = DateTime::Now;
   InterceptProvider^ provider = gcnew InterceptProvider();
   Console::WriteLine(String::Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
   Console::WriteLine(String::Format(provider, "{0}: {1:F}\n", "Today: ", 
                                    (DayOfWeek) DateTime::Now.DayOfWeek));
   Console::WriteLine(String::Format(provider, "{0:X}, {1}, {2}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
   Console::WriteLine(String::Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(String format, Object obj, IFormatProvider provider) 
   {
      // Display information about method call.
      string formatString = format ?? "<null>";
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider.GetType().Name, obj ?? "<null>", formatString);
                        
      if (obj == null) return String.Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj is Byte && formatString.ToUpper().Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String returnString = String.Empty;

         // Get the hundreds digit(s)
         result = Math.DivRem(value, 100, out remainder);
         if (result > 0)  
            returnString = new String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math.DivRem(value, 50, out remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math.DivRem(value, 10, out remainder);
         if (result > 0)
            returnString += new String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math.DivRem(value, 5, out remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += new String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString.IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString.IndexOf("L"); 
            if (xPos >= 0 & xPos == pos - 1)
               returnString = returnString.Replace("LXXXX", "XC");
            else
               returnString = returnString.Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString.IndexOf("IIII");
         if (pos >= 0)
            if (returnString.IndexOf("V") >= 0)
               returnString = returnString.Replace("VIIII", "IX");
            else
               returnString = returnString.Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj is IFormattable)
         return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
      else
         return obj.ToString();
   }
}

public class Example
{
   public static void Main()
   {
      int n = 10;
      double value = 16.935;
      DateTime day = DateTime.Now;
      InterceptProvider provider = new InterceptProvider();
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
      Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ", 
                                      (DayOfWeek) DateTime.Now.DayOfWeek));
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
   }
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
Imports System.Globalization

Public Class InterceptProvider : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(formatType As Type) As Object _
         Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, obj As Object, provider As IFormatProvider) As String _
         Implements ICustomFormatter.Format

      Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, If(obj IsNot Nothing, obj, "<null>"), formatString)

      If obj Is Nothing Then Return String.Empty
            
      ' If this is a byte and the "R" format string, format it with Roman numerals.
      If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
         Dim value As Byte = CByte(obj)
         Dim remainder As Integer
         Dim result As Integer
         Dim returnString As String = String.Empty

         ' Get the hundreds digit(s)
         result = Math.DivRem(value, 100, remainder)
         If result > 0 Then returnString = New String("C"c, result)
         value = CByte(remainder)
         ' Get the 50s digit
         result = Math.DivRem(value, 50, remainder)
         If result = 1 Then returnString += "L"
         value = CByte(remainder)
         ' Get the tens digit.
         result = Math.DivRem(value, 10, remainder)
         If result > 0 Then returnString += New String("X"c, result)
         value = CByte(remainder) 
         ' Get the fives digit.
         result = Math.DivRem(value, 5, remainder)
         If result > 0 Then returnString += "V"
         value = CByte(remainder)
         ' Add the ones digit.
         If remainder > 0 Then returnString += New String("I"c, remainder)
         
         ' Check whether we have too many X characters.
         Dim pos As Integer = returnString.IndexOf("XXXX")
         If pos >= 0 Then
            Dim xPos As Integer = returnString.IndexOf("L") 
            If xPos >= 0 And xPos = pos - 1 Then
               returnString = returnString.Replace("LXXXX", "XC")
            Else
               returnString = returnString.Replace("XXXX", "XL")   
            End If         
         End If
         ' Check whether we have too many I characters
         pos = returnString.IndexOf("IIII")
         If pos >= 0 Then
            If returnString.IndexOf("V") >= 0 Then
               returnString = returnString.Replace("VIIII", "IX")
            Else
               returnString = returnString.Replace("IIII", "IV")    
            End If
         End If
         Return returnString 
      End If   

      ' Use default for all other formatting.
      If obj Is GetType(IFormattable)
         Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
      Else
         Return obj.ToString()
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim n As Integer = 10
      Dim value As Double = 16.935
      Dim day As DateTime = Date.Now
      Dim provider As New InterceptProvider()
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today", 
                                      CType(Date.Now.DayOfWeek, DayOfWeek)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      CByte(2), CByte(12), CByte(199)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}", 
                                      CByte(2), CByte(12), CByte(199)))
   End Sub
End Module
' The example displays the following output:
'    Provider: InterceptProvider, Object: 10, Format String: N0
'    Provider: InterceptProvider, Object: 16.935, Format String: C2
'    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
'    10: $16.94 on 1/31/2013
'    
'    Provider: InterceptProvider, Object: Today: , Format String: <null>
'    Provider: InterceptProvider, Object: Thursday, Format String: F
'    Today: : Thursday
'    
'    Provider: InterceptProvider, Object: 2, Format String: X
'    Provider: InterceptProvider, Object: 12, Format String: <null>
'    Provider: InterceptProvider, Object: 199, Format String: <null>
'    2, 12, 199
'    
'    Provider: InterceptProvider, Object: 2, Format String: R
'    Provider: InterceptProvider, Object: 12, Format String: R
'    Provider: InterceptProvider, Object: 199, Format String: R
'    II, XII, CXCIX

String.Format q&aString.Format Q & A

왜 합니까 문자열 보간에 대 한 호출을 통해는 String.Format 메서드?Why do you recommend string interpolation over calls to the String.Format method?

문자열 보간 다음과 같습니다.String interpolation is:

  • 더 유연 합니다.More flexible. 사용할 수 있습니다 임의의 문자열 합성 서식 지정을 지 원하는 메서드를 호출 하지 않아도 됩니다.It can be used in any string without requiring a call to a method that supports composite formatting. 호출 해야 하는 고, 그렇지 합니다 Format 와 같은 복합 서식 지정을 지 원하는 다른 메서드나 메서드 Console.WriteLine 또는 StringBuilder.AppendFormat합니다.Otherwise, you have to call the Format method or another method that supports composite formatting, such as Console.WriteLine or StringBuilder.AppendFormat.

  • 더 쉽게 읽을 수 있습니다.More readable. 식을 문자열에 삽입 하려면 보간된 식에서 보다 인수 목록에 나타나므로 보간된 문자열은 코드를 읽기를 훨씬 간단 합니다.Because the expression to insert into a string appears in the interpolated expression rather than in a argument list, interpolated strings are far easier to code and to read. 큰 가독성을 위해 인해 보간된 문자열 뿐만 아니라 메서드 호출을 복합 형식, 바꿀 있지만 데도 사용할 수 있습니다 문자열 연결 연산에서 보다 간결 하 고 명확 하 게 코드를 생성 합니다.Because of their greater readability, interpolated strings can replace not only calls to composite format methods, but they can also be used in string concatenation operations to produce more concise, clearer code.

다음 두 코드 예제에서는 비교 문자열 연결 및 복합 형식 지정 메서드 호출을 통해 보간된 문자열의 우월성을 보여 줍니다.A comparison of the following two code examples illustrates the superiority of interpolated strings over string concatenation and calls to composite formatting methods. 다음 예제에서는 여러 문자열 연결 작업 사용 세부 정보 표시 및 읽기에 하드 코드를 생성합니다.The use of multiple string concatenation operations in the following example produces verbose and hard-to-read code.

using System;

public class Example
{
   public static void Main()
   {
      string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
      string output = names[0] + ", " + names[1] + ", " + names[2] + ", " + 
                      names[3] + ", " + names[4] + ", " + names[5] + ", " + 
                      names[6];  
    
      output += "\n";  
      var date = DateTime.Now;
      output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", 
                              date, date.DayOfWeek);
      Console.WriteLine(output);                           
   }
}
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


Module Example
   Public Sub Main()
      Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
      Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " + 
                   names(3) + ", " + names(4) + ", " + names(5) + ", " + 
                   names(6)  
    
      output += vbCrLf  
      Dim dat = DateTime.Now
      output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", 
                              dat, dat.DayOfWeek)
      Console.WriteLine(output)                           
   End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


다음 예제에서 보간된 문자열을 사용할 문자열 연결 문 및 호출 보다 훨씬 명확 하 게, 더 간결한 코드를 생성 하는 반면,는 Format 이전 예제의 메서드.In contrast, the use of interpolated strings in the following example produce much clearer, more concise code than the string concatenation statement and the call to the Format method in the previous example.

using System;

public class Example
{
   public static void Main()
   {
      string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
      string output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, " + 
                      $"{names[5]}, {names[6]}";  
    
      var date = DateTime.Now;
      output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
      Console.WriteLine(output);                           
   }
}
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


Module Example
   Public Sub Main()
      Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
      Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " + 
                   $"{names(5)}, {names(6)}"  
    
      Dim dat = DateTime.Now
      output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}." 
      Console.WriteLine(output)                           
   End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


형식 항목을 사용 하 여 사용할 수 있는 미리 정의 된 형식 문자열 목록을 찾기Where can I find a list of the predefined format strings that can be used with format items?

형식 항목을 대체 하는 결과 문자열의 맞춤을 제어 하는 방법How do I control the alignment of the result strings that replace format items?

형식 항목의 일반 구문은 다음과 같습니다.The general syntax of a format item is:

{index[,alignment][: formatString]}  

여기서 맞춤 필드 너비를 정의 하는 부호 있는 정수입니다.where alignment is a signed integer that defines the field width. 이 값이 음수 이면 필드의 텍스트를 왼쪽에 맞춥니다.If this value is negative, text in the field is left-aligned. 양수 이면 텍스트를 오른쪽에 맞춥니다.If it is positive, text is right-aligned.

소수 구분 기호 뒤의 자릿수를 제어 하는 방법How do I control the number of digits after the decimal separator?

모든 표준 숫자 서식 문자열 (정수로 사용 됨)는 "D", "G", "R"을 제외 하 고 및 "X"는 결과 문자열의 소수 자릿수를 정의 하는 전체 자릿수 지정자를 허용 합니다.All standard numeric format strings except "D" (which is used with integers only), "G", "R", and "X" allow a precision specifier that defines the number of decimal digits in the result string. 다음 예제에서는 결과 문자열의 소수 자릿수의 수를 제어 하려면 표준 숫자 서식 문자열을 사용 합니다.The following example uses standard numeric format strings to control the number of decimal digits in the result string.

using System;

public class Example
{
   public static void Main()
   {
      object[] values = { 1603, 1794.68235, 15436.14 };
      string result;
      foreach (var value in values) {
         result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n",
                                Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
         Console.WriteLine(result);
      }                           
   }
}
// The example displays output like the following:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %
Module Example
   Public Sub Main()
      Dim values() As Object = { 1603, 1794.68235, 15436.14 }
      Dim result As String
      For Each value In values
         result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}",
                                value, CDbl(value) / 10000)
         Console.WriteLine(result) 
         Console.WriteLine()
      Next                             
   End Sub
End Module
' The example displays the following output:
'       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
'    
'       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
'    
'      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

사용 중인 경우는 사용자 지정 숫자 서식 문자열, "0" 형식 지정자를 사용 하 여 다음 예와 같이 결과 문자열에서 소수 자릿수를 제어 합니다.If you're using a custom numeric format string, use the "0" format specifier to control the number of decimal digits in the result string, as the following example shows.

using System;

public class Example
{
   public static void Main()
   {
      decimal value = 16309.5436m;
      string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                                    value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//        16309.54360    16,309.54    16309.544
Module Example
   Public Sub Main()
      Dim value As Decimal = 16309.5436d
      Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                                           value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'    16309.54360    16,309.54    16309.544

정수 자릿수를 제어 하는 방법How do I control the number of integral digits?

기본적으로 서식 지정 작업만 0이 아닌 정수 자릿수를 표시 합니다.By default, formatting operations only display non-zero integral digits. 정수 형식을 지정 하는 경우 소수 자릿수를 제어 하는 전체 자릿수 지정자 "D"와 "X" 표준 서식 문자열을 사용할 수 있습니다.If you are formatting integers, you can use a precision specifier with the "D" and "X" standard format strings to control the number of digits.

using System;

public class Example
{
   public static void Main()
   {
      int value = 1326;
      string result = String.Format("{0,10:D6} {0,10:X8}", value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//     001326   0000052E
Module Example
   Public Sub Main()
      Dim value As Integer = 1326
      Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'       001326   0000052E

"0"을 사용 하 여 지정된 된 수의 정수 자릿수를 사용 하 여 결과 문자열을 생성 하는 정수 또는 부동 소수점 숫자 앞에 오는 0를 채울 수 있습니다 사용자 지정 숫자 서식 지정자다음 예제와 같이 합니다.You can pad an integer or floating-point number with leading zeros to produce a result string with a specified number of integral digits by using the "0" custom numeric format specifier, as the following example shows.

using System;

public class Example
{
   public static void Main()
   {
      int value = 16342;
      string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                                    value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0
Module Example
   Public Sub Main()
      Dim value As Integer = 16342
      Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                                           value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'           00016342       00016342.000    0,000,016,342.0

형식 목록에서 포함할 수 있는 항목 수는 있습니까?How many items can I include in the format list?

실용적인 제한은 없습니다.There is no practical limit. 두 번째 매개 변수를 Format(IFormatProvider, String, Object[]) 메서드는으로 태그가 지정 됩니다는 ParamArrayAttribute 특성을 구분 기호로 분리 된 목록 또는 형식 목록으로 개체 배열을 포함할 수 있습니다.The second parameter of the Format(IFormatProvider, String, Object[]) method is tagged with the ParamArrayAttribute attribute, which allows you to include either a delimited list or an object array as your format list.

리터럴 중괄호를 포함 하는 방법 ("{" 및 "}")는 결과 문자열에?How do I include literal braces ("{" and "}") in the result string?

예를 들어, 영향을 최소화 하는 다음 메서드 호출에서 throw 된 FormatException 예외?For example, how do you prevent the following method call from throwing a FormatException exception?

result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose);
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose)

항상 여는 중괄호와 닫는 중괄호의 단일 시작 또는 형식 항목의 끝으로 해석 됩니다.A single opening or closing brace is always interpreted as the beginning or end of a format item. 문자 그대로 해석 되도록 이스케이프 되어야 합니다.To be interpreted literally, it must be escaped. 다른 중괄호를 추가 하 여 중괄호를 이스케이프 ("{{" 및 "}}" 대신 "{0}" 및 "}"), 다음 메서드 호출 에서처럼에서:You escape a brace by adding another brace ("{{" and "}}" instead of "{" and "}"), as in the following method call:

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose);
Console.WriteLine(result);
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose)

그러나 이스케이프 된 중괄호는 쉽게 잘못 해석 된 합니다.However, even escaped braces are easily misinterpreted. 형식 목록에서 중괄호를 포함 하는 형식 항목을 사용 하 여 다음 예와 같이 결과 문자열에 삽입 하는 것이 좋습니다.We recommend that you include braces in the format list and use format items to insert them in the result string, as the following example shows.

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}");
Console.WriteLine(result);
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}")

String.Format 메서드 호출 내는 FormatException를 throw 하는 이유Why does my call to the String.Format method throw a FormatException?

예외는 가장 일반적인 원인은 아니지만 형식 항목의 인덱스 형식 목록에서 개체에 해당 하지 않습니다.The most common cause of the exception is that the index of a format item doesn't correspond to an object in the format list. 일반적으로이 형식 항목의 인덱스를 misnumbered 했습니다 또는 형식 목록에서 개체를 포함 하려면 잊어버린 나타냅니다.Usually this indicates that you've misnumbered the indexes of format items or you've forgotten to include an object in the format list. 문자는 이스케이프 되지 않은 왼쪽 또는 오른쪽 중괄호를 포함 하는 동안도 throw를 FormatException입니다.Attempting to include an unescaped left or right brace character also throws a FormatException. 경우에 따라 예외 결과인 오타가; 일반적인 실수를 잘못 입력 방법은 예를 들어, "[" (왼쪽된 대괄호) 대신 "{0}" (왼쪽된 중괄호).Occasionally, the exception is the result of a typo; for example, a typical mistake is to mistype "[" (the left bracket) instead of "{" (the left brace).

Format(System.IFormatProvider,System.String,System.Object[]) 메서드 매개 변수 배열을 지 원하는 경우 이유 코드 예외를 throw지 않습니다 배열을 사용 하는 경우?If the Format(System.IFormatProvider,System.String,System.Object[]) method supports parameter arrays, why does my code throw an exception when I use an array?

예를 들어, 다음 코드 throw를 FormatException 예외:For example, the following code throws a FormatException exception:

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      int[]  numbers = new int[4];
      int total = 0;
      for (int ctr = 0; ctr <= 2; ctr++) {
         int number = rnd.Next(1001);
         numbers[ctr] = number;
         total += number;
      }   
      numbers[3] = total;
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers);   
   }
}
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim numbers(3) As Integer
      Dim total As Integer = 0
      For ctr = 0 To 2
         Dim number As Integer = rnd.Next(1001)
         numbers(ctr) = number
         total += number
      Next
      numbers(3) = total
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers)   
   End Sub
End Module

이 컴파일러 오버 로드 확인에 문제가 있는 경우This is a problem of compiler overload resolution. 호출 하므로 정수 배열을 단일 인수로 처리 컴파일러 정수 배열을 개체 배열을으로 변환할 수 없는 때문에 Format(String, Object) 메서드.Because the compiler cannot convert an array of integers to an object array, it treats the integer array as a single argument, so it calls the Format(String, Object) method. 4 개의 형식 항목이 있지만 형식 목록에서 항목을 단일 있기 때문에 예외가 발생 합니다.The exception is thrown because there are four format items but only a single item in the format list.

호출 하기 전에 사용자가 직접 변환을 수행 해야 하는 Visual Basic 또는 C# 모두 정수 배열을 개체 배열로 변환할 수, 있으므로 Format(String, Object[]) 메서드.Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the Format(String, Object[]) method. 다음 예제에는 하나의 구현을 제공합니다.The following example provides one implementation.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      int[]  numbers = new int[4];
      int total = 0;
      for (int ctr = 0; ctr <= 2; ctr++) {
         int number = rnd.Next(1001);
         numbers[ctr] = number;
         total += number;
      }   
      numbers[3] = total;
      object[] values = new object[numbers.Length];
      numbers.CopyTo(values, 0);
      Console.WriteLine("{0} + {1} + {2} = {3}", values);   
   }
}
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim numbers(3) As Integer
      Dim total As Integer = 0
      For ctr = 0 To 2
         Dim number As Integer = rnd.Next(1001)
         numbers(ctr) = number
         total += number
      Next
      numbers(3) = total
      Dim values(numbers.Length - 1) As Object
      numbers.CopyTo(values, 0) 
      Console.WriteLine("{0} + {1} + {2} = {3}", values)   
   End Sub
End Module

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 세 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representation of three specified objects. 매개 변수에서 문화권별 형식 지정 정보를 제공합니다. An parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1, object arg2);
static member Format : IFormatProvider * string * obj * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

매개 변수

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

문화권별 서식 지정 정보를 제공하는 개체입니다. An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

서식을 지정할 첫 번째 개체입니다. The first object to format.

arg1
Object Object Object Object

서식을 지정할 두 번째 개체입니다. The second object to format.

arg2
Object Object Object Object

서식을 지정할 세 번째 개체입니다. The third object to format.

Returns

형식 항목이 format, arg0arg1의 문자열 표현으로 바뀌는 arg2의 복사본입니다. A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Exceptions

format이 잘못되었습니다. format is invalid. 또는 -or- 형식 항목의 인덱스가 0보다 작거나, 2보다 큽니다. The index of a format item is less than zero, or greater than two.

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

이 메서드를 사용 합니다 복합 서식 지정 기능 세 개의 식을 해당 문자열 표현으로 변환 하 고 이러한 표현이 문자열에 포함 합니다.This method uses the composite formatting feature to convert three expressions to their string representations and to embed those representations in a string. 변환 수행, 메서드가 문화권 구분 서식 지정 또는 사용자 지정 포맷터를 사용 합니다.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. 메서드가 변환 하는 각 Object 인수를 호출 하 여 해당 문자열 표현에 해당 ToString(IFormatProvider) 메서드 서식 항목 형식 문자열을 해당 를호출하여포함개체의해당하는경우또는ToString(String,IFormatProvider) 메서드.The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. 이러한 메서드는 존재 하지 않거나, 호출 개체의 매개 변수가 없는 ToString 메서드.If these methods don't exist, it calls the object's parameterless ToString method.

그러나 String.Format 메서드를 호출할 때 호출할 특정 오버로드에 집중할 필요가 없습니다.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 대신 문화권 구분 또는 사용자 지정 서식을 제공하는 개체와 하나 이상의 서식 항목이 포함된 복합 형식 문자열을 사용하여 메서드를 호출할 수 있습니다.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. 첫 번째 인덱스는 0으로 시작하는 숫자 인덱스를 각 서식 항목에 할당합니다.You assign each format item a numeric index; the first index starts at 0. 초기 문자열 이외에도 메서드 호출에는 인덱스 값만큼 많은 추가 인수가 있어야 합니다.In addition to the initial string, your method call should have as many additional arguments as it has index values. 예를 들어 서식 항목에 0과 1의 인덱스가 있는 문자열에는 2개의 인수가 있어야 하며, 0에서 5의 인덱스가 있는 문자열에는 6개의 인수가 있어야 합니다.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 그러면 언어 컴파일러가 메서드 호출을 String.Format 메서드의 특정 오버로드로 확인합니다.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

String.Format 메서드 사용에 대한 자세한 설명서는 String.Format 메서드 시작어느 메서드를 호출해야 합니까?를 참조하세요.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 세 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representation of three specified objects.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (string format, object arg0, object arg1, object arg2);
static member Format : string * obj * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

매개 변수

arg0
Object Object Object Object

서식을 지정할 첫 번째 개체입니다. The first object to format.

arg1
Object Object Object Object

서식을 지정할 두 번째 개체입니다. The second object to format.

arg2
Object Object Object Object

서식을 지정할 세 번째 개체입니다. The third object to format.

Returns

형식 항목이 format, arg0arg1의 문자열 표현으로 바뀌는 arg2의 복사본입니다. A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Exceptions

format이 잘못되었습니다. format is invalid. 또는 -or- 형식 항목의 인덱스가 0보다 작거나, 2보다 큽니다. The index of a format item is less than zero, or greater than two.

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

이 메서드를 사용 합니다 복합 서식 지정 기능 세 가지 식의 값을 해당 문자열 표현으로 변환 하 고 문자열에 이러한 표현이 포함 합니다.This method uses the composite formatting feature to convert the value of three expressions to their string representations and to embed those representations in a string.

그러나 String.Format 메서드를 호출할 때 호출할 특정 오버로드에 집중할 필요가 없습니다.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 대신 하나 이상의 서식 항목이 포함된 복합 형식 문자열을 사용하여 메서드를 호출할 수 있습니다.Instead, you can call the method with a composite format string that includes one or more format items. 첫 번째 인덱스는 0으로 시작하는 숫자 인덱스를 각 서식 항목에 할당합니다.You assign each format item a numeric index; the first index starts at 0. 초기 문자열 이외에도 메서드 호출에는 인덱스 값만큼 많은 추가 인수가 있어야 합니다.In addition to the initial string, your method call should have as many additional arguments as it has index values. 예를 들어 서식 항목에 0과 1의 인덱스가 있는 문자열에는 2개의 인수가 있어야 하며, 0에서 5의 인덱스가 있는 문자열에는 6개의 인수가 있어야 합니다.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 그러면 언어 컴파일러가 메서드 호출을 String.Format 메서드의 특정 오버로드로 확인합니다.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

String.Format 메서드 사용에 대한 자세한 설명서는 String.Format 메서드 시작어느 메서드를 호출해야 합니까?를 참조하세요.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

예: 세 개의 인수를 서식 지정Example: Formatting three arguments

이 예제에서는 합니다 Format(String, Object, Object, Object) 메서드는 부울 결과 보여 주는 문자열을 만들려면 And 두 정수 값을 사용 하 여 작업 합니다.This example uses the Format(String, Object, Object, Object) method to create a string that illustrates the result of a Boolean And operation with two integer values. 두 가지 방법으로 각 항목 형식이 있으므로 형식 문자열에 6 개의 형식 항목이 포함 되지만 메서드 매개 변수 목록에서 세 개의 항목이 note 합니다.Note that the format string includes six format items, but the method has only three items in its parameter list, because each item is formatted in two different ways.

using namespace System;

void main()
{
   String^ formatString = "    {0,10} ({0,8:X8})\n" + 
                           "And {1,10} ({1,8:X8})\n" + 
                           "  = {2,10} ({2,8:X8})";
   int value1 = 16932;
   int value2 = 15421;
   String^ result = String::Format(formatString, 
                                   value1, value2, value1 & value2);
   Console::WriteLine(result);
}
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
using System;

public class Example
{
   public static void Main()
   {
      string formatString = "    {0,10} ({0,8:X8})\n" + 
                            "And {1,10} ({1,8:X8})\n" + 
                            "  = {2,10} ({2,8:X8})";
      int value1 = 16932;
      int value2 = 15421;
      string result = String.Format(formatString, 
                                    value1, value2, value1 & value2);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
Public Module Example
   Public Sub Main()
      Dim formatString As String = "    {0,10} ({0,8:X8})" + vbCrLf +  _
                                   "And {1,10} ({1,8:X8})" + vbCrLf + _
                                   "  = {2,10} ({2,8:X8})"
      Dim value1 As Integer = 16932
      Dim value2 As Integer = 15421
      Dim result As String = String.Format(formatString, _
                                           value1, value2, value1 And value2)
      Console.WriteLine(result)                          
   End Sub
End Module
' The example displays the following output:
'                16932 (00004224)
'       And      15421 (00003C3D)
'         =         36 (00000024)
See Also

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 두 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representation of two specified objects. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다. A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1);
static member Format : IFormatProvider * string * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As String

매개 변수

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

문화권별 서식 지정 정보를 제공하는 개체입니다. An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

서식을 지정할 첫 번째 개체입니다. The first object to format.

arg1
Object Object Object Object

서식을 지정할 두 번째 개체입니다. The second object to format.

Returns

서식 지정 항목이 formatarg0의 문자열 표현으로 바뀌는 arg1의 복사본입니다. A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Exceptions

format이 잘못되었습니다. format is invalid. 또는 -or- 형식 항목의 인덱스가 0 또는 1입니다. The index of a format item is not zero or one.

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

이 메서드를 사용 합니다 복합 서식 지정 기능 두 식을 해당 문자열 표현으로 변환 하 고 이러한 표현이 문자열에 포함 합니다.This method uses the composite formatting feature to convert two expressions to their string representations and to embed those representations in a string. 변환 수행, 메서드가 문화권 구분 서식 지정 또는 사용자 지정 포맷터를 사용 합니다.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. 메서드가 변환 하는 각 Object 인수를 호출 하 여 해당 문자열 표현에 해당 ToString(IFormatProvider) 메서드 서식 항목 형식 문자열을 해당 를호출하여포함개체의해당하는경우또는ToString(String,IFormatProvider) 메서드.The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. 이러한 메서드는 존재 하지 않거나, 호출 개체의 매개 변수가 없는 ToString 메서드.If these methods don't exist, it calls the object's parameterless ToString method.

그러나 String.Format 메서드를 호출할 때 호출할 특정 오버로드에 집중할 필요가 없습니다.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 대신 문화권 구분 또는 사용자 지정 서식을 제공하는 개체와 하나 이상의 서식 항목이 포함된 복합 형식 문자열을 사용하여 메서드를 호출할 수 있습니다.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. 첫 번째 인덱스는 0으로 시작하는 숫자 인덱스를 각 서식 항목에 할당합니다.You assign each format item a numeric index; the first index starts at 0. 초기 문자열 이외에도 메서드 호출에는 인덱스 값만큼 많은 추가 인수가 있어야 합니다.In addition to the initial string, your method call should have as many additional arguments as it has index values. 예를 들어 서식 항목에 0과 1의 인덱스가 있는 문자열에는 2개의 인수가 있어야 하며, 0에서 5의 인덱스가 있는 문자열에는 6개의 인수가 있어야 합니다.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 그러면 언어 컴파일러가 메서드 호출을 String.Format 메서드의 특정 오버로드로 확인합니다.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

String.Format 메서드 사용에 대한 자세한 설명서는 String.Format 메서드 시작어느 메서드를 호출해야 합니까?를 참조하세요.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 두 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representation of two specified objects.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (string format, object arg0, object arg1);
static member Format : string * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object) As String

매개 변수

arg0
Object Object Object Object

서식을 지정할 첫 번째 개체입니다. The first object to format.

arg1
Object Object Object Object

서식을 지정할 두 번째 개체입니다. The second object to format.

Returns

서식 지정 항목이 formatarg0의 문자열 표현으로 바뀌는 arg1의 복사본입니다. A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Exceptions

format이 잘못되었습니다. format is invalid. 또는 -or- 형식 항목의 인덱스가 0 또는 1입니다. The index of a format item is not zero or one.

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

이 메서드를 사용 합니다 복합 서식 지정 기능 두 식의 값을 해당 문자열 표현으로 변환 하 고 이러한 표현이 문자열에 포함 합니다.This method uses the composite formatting feature to convert the value of two expressions to their string representations and to embed those representations in a string.

그러나 String.Format 메서드를 호출할 때 호출할 특정 오버로드에 집중할 필요가 없습니다.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 대신 하나 이상의 서식 항목이 포함된 복합 형식 문자열을 사용하여 메서드를 호출할 수 있습니다.Instead, you can call the method with a composite format string that includes one or more format items. 첫 번째 인덱스는 0으로 시작하는 숫자 인덱스를 각 서식 항목에 할당합니다.You assign each format item a numeric index; the first index starts at 0. 초기 문자열 이외에도 메서드 호출에는 인덱스 값만큼 많은 추가 인수가 있어야 합니다.In addition to the initial string, your method call should have as many additional arguments as it has index values. 예를 들어 서식 항목에 0과 1의 인덱스가 있는 문자열에는 2개의 인수가 있어야 하며, 0에서 5의 인덱스가 있는 문자열에는 6개의 인수가 있어야 합니다.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 그러면 언어 컴파일러가 메서드 호출을 String.Format 메서드의 특정 오버로드로 확인합니다.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

String.Format 메서드 사용에 대한 자세한 설명서는 String.Format 메서드 시작어느 메서드를 호출해야 합니까?를 참조하세요.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

예: 두 개의 인수를 서식 지정Example: Formatting two arguments

이 예제에서는 합니다 Format(String, Object, Object) 제네릭에 저장 하는 시간 및 온도 데이터를 표시 하는 방법 Dictionary<TKey,TValue> 개체입니다.This example uses the Format(String, Object, Object) method to display time and temperature data stored in a generic Dictionary<TKey,TValue> object. 형식 문자열에 세 개의 형식 항목이 있더라도 다음 두 개의 형식을 지정할 개체를 참고 합니다.Note that the format string has three format items, although there are only two objects to format. (날짜 및 시간 값) 목록에서 첫 번째 개체를 사용 하는 두 형식 항목 이므로: 첫 번째 형식 항목 표시 하는 시간 및 두 번째 날짜를 표시 합니다.This is because the first object in the list (a date and time value) is used by two format items: The first format item displays the time, and the second displays the date.

using namespace System;
using namespace System::Collections::Generic;

void main()
{
   Dictionary<DateTime, Double>^ temperatureInfo = gcnew Dictionary<DateTime, Double>(); 
   temperatureInfo->Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46);
   temperatureInfo->Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81);
      
   Console::WriteLine("Temperature Information:\n");
   String^ output;   
   for each (KeyValuePair<DateTime, Double>^ item in temperatureInfo)
   {
      output = String::Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}�F", 
                              item->Key, item->Value);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5�F
//       Temperature at 10:00 AM on 12/1/2010:  36.8�F
using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>(); 
      temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
      temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);
      
      Console.WriteLine("Temperature Information:\n");
      string output;   
      foreach (var item in temperatureInfo)
      {
         output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", 
                                item.Key, item.Value);
         Console.WriteLine(output);
      }
   }
}
// The example displays output like the following:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5°F
//       Temperature at 10:00 AM on 12/1/2010:  36.8°F
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim temperatureInfo As New Dictionary(Of Date, Double) 
      temperatureInfo.Add(#6/1/2010 2:00PM#, 87.46)
      temperatureInfo.Add(#12/1/2010 10:00AM#, 36.81)
      
      Console.WriteLine("Temperature Information:")
      Console.WriteLine()
      Dim output As String   
      For Each item In temperatureInfo
         output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", _
                                item.Key, item.Value)
         Console.WriteLine(output)
      Next
   End Sub
End Module
' The example displays the following output:
'       Temperature Information:
'       
'       Temperature at  2:00 PM on  6/1/2010:  87.5°F
'       Temperature at 10:00 AM on 12/1/2010:  36.8°F
See Also

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

문자열의 형식 항목을 지정된 배열에 있는 해당 개체의 문자열 표현으로 바꿉니다. Replaces the format items in a string with the string representations of corresponding objects in a specified array. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다. A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (IFormatProvider provider, string format, params object[] args);
static member Format : IFormatProvider * string * obj[] -> string
Public Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As String

매개 변수

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

문화권별 서식 지정 정보를 제공하는 개체입니다. An object that supplies culture-specific formatting information.

args
Object[]

형식을 지정할 개체를 0개 이상 포함하는 개체 배열입니다. An object array that contains zero or more objects to format.

Returns

형식 항목을 format에 있는 해당 개체의 문자열 표현으로 바꾼 args의 복사본입니다. A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Exceptions

format 또는 argsnull인 경우 format or args is null.

format이 잘못되었습니다. format is invalid. 또는 -or- 형식 항목의 인덱스가 0보다 작거나 args 배열의 길이보다 크거나 같습니다. The index of a format item is less than zero, or greater than or equal to the length of the args array.

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

이 메서드를 사용 합니다 복합 서식 지정 기능 4 개 이상의 식을 해당 문자열 표현으로 변환 하 고 이러한 표현이 문자열에 포함 합니다.This method uses the composite formatting feature to convert four or more expressions to their string representations and to embed those representations in a string. 변환 수행, 메서드가 문화권 구분 서식 지정 또는 사용자 지정 포맷터를 사용 합니다.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. 메서드가 변환 하는 각 Object 인수를 호출 하 여 해당 문자열 표현에 해당 ToString(IFormatProvider) 메서드 서식 항목 형식 문자열을 해당 를호출하여포함개체의해당하는경우또는ToString(String,IFormatProvider) 메서드.The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. 이러한 메서드는 존재 하지 않거나, 호출 개체의 매개 변수가 없는 ToString 메서드.If these methods don't exist, it calls the object's parameterless ToString method.

그러나 String.Format 메서드를 호출할 때 호출할 특정 오버로드에 집중할 필요가 없습니다.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 대신 문화권 구분 또는 사용자 지정 서식을 제공하는 개체와 하나 이상의 서식 항목이 포함된 복합 형식 문자열을 사용하여 메서드를 호출할 수 있습니다.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. 첫 번째 인덱스는 0으로 시작하는 숫자 인덱스를 각 서식 항목에 할당합니다.You assign each format item a numeric index; the first index starts at 0. 초기 문자열 이외에도 메서드 호출에는 인덱스 값만큼 많은 추가 인수가 있어야 합니다.In addition to the initial string, your method call should have as many additional arguments as it has index values. 예를 들어 서식 항목에 0과 1의 인덱스가 있는 문자열에는 2개의 인수가 있어야 하며, 0에서 5의 인덱스가 있는 문자열에는 6개의 인수가 있어야 합니다.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 그러면 언어 컴파일러가 메서드 호출을 String.Format 메서드의 특정 오버로드로 확인합니다.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

String.Format 메서드 사용에 대한 자세한 설명서는 String.Format 메서드 시작어느 메서드를 호출해야 합니까?를 참조하세요.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

예: 문화권 구분 서식 지정Example: Culture-sensitive formatting

이 예제에서는 Format(IFormatProvider, String, Object[]) 몇 가지 다른 문화권을 사용 하 여 일부 날짜 및 시간 값 및 숫자 값의 문자열 표현을 표시 하는 방법입니다.This example uses the Format(IFormatProvider, String, Object[]) method to display the string representation of some date and time values and numeric values by using several different cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "de-DE", "es-ES" };
      
      DateTime dateToDisplay = new DateTime(2009, 9, 1, 18, 32, 0);
      double value = 9164.32;

      Console.WriteLine("Culture     Date                                Value\n");
      foreach (string cultureName in cultureNames)
      {
         CultureInfo culture = new CultureInfo(cultureName);
         string output = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", 
                                       culture.Name, dateToDisplay, value);
         Console.WriteLine(output);
      }    
   }
}
// The example displays the following output:
//    Culture     Date                                Value
//    
//    en-US       Tuesday, September 01, 2009         9,164.32
//    fr-FR       mardi 1 septembre 2009              9 164,32
//    de-DE       Dienstag, 1. September 2009         9.164,32
//    es-ES       martes, 01 de septiembre de 2009    9.164,32
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "de-DE", "es-ES" }
      
      Dim dateToDisplay As Date = #9/1/2009 6:32PM#
      Dim value As Double = 9164.32

      Console.WriteLine("Culture     Date                                Value")
      Console.WriteLine()      
      For Each cultureName As String In cultureNames
         Dim culture As New CultureInfo(cultureName)
         Dim output As String = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", _
                                              culture.Name, dateToDisplay, value)
         Console.WriteLine(output)
      Next    
   End Sub
End Module
' The example displays the following output:
'       Culture     Date                                Value
'       
'       en-US       Tuesday, September 01, 2009         9,164.32
'       fr-FR       mardi 1 septembre 2009              9 164,32
'       de-DE       Dienstag, 1. September 2009         9.164,32
'       es-ES       martes, 01 de septiembre de 2009    9.164,32
See Also

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object)

지정된 문자열에 있는 하나의 형식 항목 또는 여러 개의 형식 항목을 해당하는 개체의 문자열 표현으로 바꿉니다. Replaces the format item or items in a specified string with the string representation of the corresponding object. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다. A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0);
public static string Format (IFormatProvider provider, string format, object arg0);
static member Format : IFormatProvider * string * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object) As String

매개 변수

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

문화권별 서식 지정 정보를 제공하는 개체입니다. An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

형식을 지정할 개체입니다. The object to format.

Returns

하나의 형식 항목 또는 여러 개의 형식 항목이 format의 문자열 표현으로 바뀌는 arg0의 복사본입니다. A copy of format in which the format item or items have been replaced by the string representation of arg0.

Exceptions

format이 잘못되었습니다. format is invalid. 또는 -or- 서식 항목의 인덱스가 0이 아닙니다. The index of a format item is not zero.

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

이 메서드를 사용 합니다 복합 서식 지정 기능 값 식의 문자열 표현으로 변환 하 고 문자열에서 표현을 포함 합니다.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string. 변환 수행, 메서드가 문화권 구분 서식 지정 또는 사용자 지정 포맷터를 사용 합니다.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. 메서드 변환 arg0 를 호출 하 여 해당 문자열 표현에 해당 ToString(IFormatProvider) 메서드 또는 서식 항목 형식 문자열을 호출 하 여 포함 개체의 해당 하는 경우 해당 ToString ( String, IFormatProvider) 메서드.The method converts arg0 to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. 이러한 메서드는 존재 하지 않거나, 호출 개체의 매개 변수가 없는 ToString 메서드.If these methods don't exist, it calls the object's parameterless ToString method.

그러나 String.Format 메서드를 호출할 때 호출할 특정 오버로드에 집중할 필요가 없습니다.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 대신 문화권 구분 또는 사용자 지정 서식을 제공하는 개체와 하나 이상의 서식 항목이 포함된 복합 형식 문자열을 사용하여 메서드를 호출할 수 있습니다.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. 첫 번째 인덱스는 0으로 시작하는 숫자 인덱스를 각 서식 항목에 할당합니다.You assign each format item a numeric index; the first index starts at 0. 초기 문자열 이외에도 메서드 호출에는 인덱스 값만큼 많은 추가 인수가 있어야 합니다.In addition to the initial string, your method call should have as many additional arguments as it has index values. 예를 들어 서식 항목에 0과 1의 인덱스가 있는 문자열에는 2개의 인수가 있어야 하며, 0에서 5의 인덱스가 있는 문자열에는 6개의 인수가 있어야 합니다.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 그러면 언어 컴파일러가 메서드 호출을 String.Format 메서드의 특정 오버로드로 확인합니다.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

String.Format 메서드 사용에 대한 자세한 설명서는 String.Format 메서드 시작어느 메서드를 호출해야 합니까?를 참조하세요.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

지정된 문자열의 형식 항목을 지정된 배열에 있는 해당 개체의 문자열 표현으로 바꿉니다. Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

public:
 static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (string format, params object[] args);
static member Format : string * obj[] -> string
Public Shared Function Format (format As String, ParamArray args As Object()) As String

매개 변수

args
Object[]

형식을 지정할 개체를 0개 이상 포함하는 개체 배열입니다. An object array that contains zero or more objects to format.

Returns

형식 항목을 format에 있는 해당 개체의 문자열 표현으로 바꾼 args의 복사본입니다. A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Exceptions

format 또는 argsnull인 경우 format or args is null.

format이 잘못되었습니다. format is invalid. 또는 -or- 형식 항목의 인덱스가 0보다 작거나 args 배열의 길이보다 크거나 같습니다. The index of a format item is less than zero, or greater than or equal to the length of the args array.

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

이 메서드를 사용 합니다 복합 서식 지정 기능 4 개 이상의 식의 값을 해당 문자열 표현으로 변환 하 고 문자열에 이러한 표현이 포함 합니다.This method uses the composite formatting feature to convert the value of four or more expressions to their string representations and to embed those representations in a string. 하므로 합니다 args 매개 변수를 사용 하 여으로 System.ParamArrayAttribute 특성을 전달할 수 있습니다 개체 메서드 또는 개별 인수로 Object 배열 합니다.Since the args parameter is marked with the System.ParamArrayAttribute attribute, you can pass the objects to the method as individual arguments or as an Object array.

그러나 String.Format 메서드를 호출할 때 호출할 특정 오버로드에 집중할 필요가 없습니다.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 대신 하나 이상의 서식 항목이 포함된 복합 형식 문자열을 사용하여 메서드를 호출할 수 있습니다.Instead, you can call the method with a composite format string that includes one or more format items. 첫 번째 인덱스는 0으로 시작하는 숫자 인덱스를 각 서식 항목에 할당합니다.You assign each format item a numeric index; the first index starts at 0. 초기 문자열 이외에도 메서드 호출에는 인덱스 값만큼 많은 추가 인수가 있어야 합니다.In addition to the initial string, your method call should have as many additional arguments as it has index values. 예를 들어 서식 항목에 0과 1의 인덱스가 있는 문자열에는 2개의 인수가 있어야 하며, 0에서 5의 인덱스가 있는 문자열에는 6개의 인수가 있어야 합니다.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 그러면 언어 컴파일러가 메서드 호출을 String.Format 메서드의 특정 오버로드로 확인합니다.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

String.Format 메서드 사용에 대한 자세한 설명서는 String.Format 메서드 시작어느 메서드를 호출해야 합니까?를 참조하세요.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

예: 세 개 이상의 인수를 서식 지정Example: Formatting more than three arguments

이 예제에서는 특정 날짜에서 최고 / 최저 온도 데이터를 포함 하는 문자열을 만듭니다.This example creates a string that contains data on the high and low temperature on a particular date. 복합 형식 문자열에 C# 예제에서 5 개의 형식 항목이 및 Visual Basic 예제에서 6 개 있습니다.The composite format string has five format items in the C# example and six in the Visual Basic example. 해당 값의 문자열 표현 너비를 정의 하는 형식 항목의 두 및 첫 번째 형식 항목인 표준 날짜 및 시간 서식 문자열도 포함 합니다.Two of the format items define the width of their corresponding value's string representation, and the first format item also includes a standard date and time format string.

using namespace System;

void main()
{
   DateTime date1 = DateTime(2009, 7, 1);
   TimeSpan hiTime = TimeSpan(14, 17, 32);
   Decimal hiTemp = (Decimal) 62.1; 
   TimeSpan loTime = TimeSpan(3, 16, 10);
   Decimal loTemp = (Decimal)54.8; 

   String^ result1 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    date1, hiTime, hiTemp, loTime, loTemp);
   Console::WriteLine(result1);
   Console::WriteLine();
           
   String^ result2 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    gcnew array<Object^> { date1, hiTime, hiTemp, loTime, loTemp });
   Console::WriteLine(result2);
}
// The example displays the following output:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
using System;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 7, 1);
      TimeSpan hiTime = new TimeSpan(14, 17, 32);
      decimal hiTemp = 62.1m; 
      TimeSpan loTime = new TimeSpan(3, 16, 10);
      decimal loTemp = 54.8m; 

      string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                     date1, hiTime, hiTemp, loTime, loTemp);
      Console.WriteLine(result1);
      Console.WriteLine();
           
      string result2 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                     new object[] { date1, hiTime, hiTemp, loTime, loTemp });
      Console.WriteLine(result2);
   }
}
// The example displays output like the following:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
Module Example
   Public Sub Main()
      Dim date1 As Date = #7/1/2009#
      Dim hiTime As New TimeSpan(14, 17, 32)
      Dim hiTemp As Decimal = 62.1d 
      Dim loTime As New TimeSpan(3, 16, 10)
      Dim loTemp As Decimal = 54.8d 

      Dim result1 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
                                           date1, hiTime, hiTemp, loTime, loTemp, vbCrLf)
      Console.WriteLine(result1)
      Console.WriteLine()
           
      Dim result2 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
                                            New Object() { date1, hiTime, hiTemp, loTime, loTemp, vbCrLf })
      Console.WriteLine(result2)                                            
   End Sub
End Module
' The example displays the following output:
'       Temperature on 7/1/2009:
'          14:17:32: 62.1 degrees (hi)
'          03:16:10: 54.8 degrees (lo)
'
'       Temperature on 7/1/2009:
'          14:17:32: 62.1 degrees (hi)
'          03:16:10: 54.8 degrees (lo)

배열 형식을 지정할 개체를 전달할 수도 있습니다 아니라 인수 목록입니다.You can also pass the objects to be formatted as an array rather than a an argument list.

using namespace System;

ref class CityInfo
{
public:
   CityInfo(String^ name, int population, Decimal area, int year)
   {
      this->Name = name;
      this->Population = population;
      this->Area = area;
      this->Year = year;
   }
   
   String^ Name; 
   int Population;
   Decimal Area;
   int Year;
};

ref class Example
{
public:
   static void ShowPopulationData(CityInfo^ city)
   {
      array<Object^>^ args = gcnew array<Object^> { city->Name, city->Year, city->Population, city->Area };
      String^ result = String::Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console::WriteLine(result); 
   }
};

void main()
{
   CityInfo^ nyc2010 = gcnew CityInfo("New York", 8175133, (Decimal) 302.64, 2010);
   Example::ShowPopulationData(nyc2010);
   CityInfo^ sea2010 = gcnew CityInfo("Seattle", 608660, (Decimal) 83.94, 2010);      
   Example::ShowPopulationData(sea2010); 
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
using System;

public class CityInfo
{
   public CityInfo(String name, int population, Decimal area, int year)
   {
      this.Name = name;
      this.Population = population;
      this.Area = area;
      this.Year = year;
   }
   
   public readonly String Name; 
   public readonly int Population;
   public readonly Decimal Area;
   public readonly int Year;
}

public class Example
{
   public static void Main()
   {
      CityInfo nyc2010 = new CityInfo("New York", 8175133, 302.64m, 2010);
      ShowPopulationData(nyc2010);
      CityInfo sea2010 = new CityInfo("Seattle", 608660, 83.94m, 2010);      
      ShowPopulationData(sea2010); 
   }

   private static void ShowPopulationData(CityInfo city)
   {
      object[] args = { city.Name, city.Year, city.Population, city.Area };
      String result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console.WriteLine(result); 
   }
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
Public Class CityInfo
   Public Sub New(name As String, population As Integer, area As Decimal, year As Integer)
      Me.Name = name
      Me.Population = population
      Me.Area = area
      Me.Year = year
   End Sub
   
   Public ReadOnly Name As String
   Public ReadOnly Population As Integer
   Public ReadOnly Area As Decimal
   Public ReadOnly Year As Integer
End Class

Module Example
   Public Sub Main()
      Dim nyc2010 As New CityInfo("New York", 8175133, 302.64d, 2010)
      ShowPopulationData(nyc2010)
      Dim sea2010 As New CityInfo("Seattle", 608660, 83.94d, 2010)      
      ShowPopulationData(sea2010) 
   End Sub
   
   Private Sub ShowPopulationData(city As CityInfo)
      Dim args() As Object = { city.Name, city.Year, city.Population, city.Area }
      Dim result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
      Console.WriteLine(result) 
   End Sub
End Module
' The example displays the following output:
'       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
'       Seattle in 2010: Population 608,660, Area 83.9 sq. feet   
See Also

Format(String, Object) Format(String, Object) Format(String, Object) Format(String, Object)

문자열에 있는 하나 이상의 형식 항목을 지정된 개체의 문자열 표현으로 바꿉니다. Replaces one or more format items in a string with the string representation of a specified object.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0);
public static string Format (string format, object arg0);
static member Format : string * obj -> string
Public Shared Function Format (format As String, arg0 As Object) As String

매개 변수

arg0
Object Object Object Object

형식을 지정할 개체입니다. The object to format.

Returns

서식 지정 항목이 format의 문자열 표현으로 바뀌는 arg0의 복사본입니다. A copy of format in which any format items are replaced by the string representation of arg0.

Exceptions

format의 서식 항목이 올바르지 않습니다. The format item in format is invalid. 또는 -or- 서식 항목의 인덱스가 0이 아닙니다. The index of a format item is not zero.

Remarks

중요

String.Format 메서드를 호출하거나 복합 형식 문자열을 사용하는 대신, 언어가 지원하는 경우 보간된 문자열을 사용할 수 있습니다.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 보간된 문자열은 보간된 식이 포함된 문자열입니다.An interpolated string is a string that contains interpolated expressions. 각 보간된 표현식은 표현식의 값으로 해석되고 문자열이 할당될 때 결과 문자열에 포함됩니다.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 자세한 내용은 문자열 보간(C# 참조)문자열 보간(Visual Basic 참조)을 참조하세요.For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

이 메서드를 사용 합니다 복합 서식 지정 기능 값 식의 문자열 표현으로 변환 하 고 문자열에서 표현을 포함 합니다.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string.

그러나 String.Format 메서드를 호출할 때 호출할 특정 오버로드에 집중할 필요가 없습니다.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 대신 하나 이상의 서식 항목이 포함된 복합 형식 문자열을 사용하여 메서드를 호출할 수 있습니다.Instead, you can call the method with a composite format string that includes one or more format items. 첫 번째 인덱스는 0으로 시작하는 숫자 인덱스를 각 서식 항목에 할당합니다.You assign each format item a numeric index; the first index starts at 0. 초기 문자열 이외에도 메서드 호출에는 인덱스 값만큼 많은 추가 인수가 있어야 합니다.In addition to the initial string, your method call should have as many additional arguments as it has index values. 예를 들어 서식 항목에 0과 1의 인덱스가 있는 문자열에는 2개의 인수가 있어야 하며, 0에서 5의 인덱스가 있는 문자열에는 6개의 인수가 있어야 합니다.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 그러면 언어 컴파일러가 메서드 호출을 String.Format 메서드의 특정 오버로드로 확인합니다.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

String.Format 메서드 사용에 대한 자세한 설명서는 String.Format 메서드 시작어느 메서드를 호출해야 합니까?를 참조하세요.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

예: 단일 인수를 서식 지정Example: Formatting a single argument

다음 예제에서는 Format(String, Object) 문자열 중 개인의 기간을 포함 하는 방법입니다.The following example uses the Format(String, Object) method to embed an individual's age in the middle of a string.

using namespace System;

void main()
{
   DateTime birthdate = DateTime(1993, 7, 28);
   array<DateTime>^ dates = gcnew array<DateTime> { DateTime(1993, 8, 16), 
                                                    DateTime(1994, 7, 28), 
                                                    DateTime(2000, 10, 16), 
                                                    DateTime(2003, 7, 27), 
                                                    DateTime(2007, 5, 27) };

   for each (DateTime dateValue in dates)
   {
      TimeSpan interval = dateValue - birthdate;
      // Get the approximate number of years, without accounting for leap years.
      int years = ((int)interval.TotalDays) / 365;
      // See if adding the number of years exceeds dateValue.
      String^ output;
      if (birthdate.AddYears(years) <= dateValue) {
         output = String::Format("You are now {0} years old.", years);
         Console::WriteLine(output);
      }   
      else {
         output = String::Format("You are now {0} years old.", years - 1);
         Console::WriteLine(output);
      }      
   }
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
using System;

public class Example
{
   public static void Main()
   {
      DateTime birthdate = new DateTime(1993, 7, 28);
      DateTime[] dates = { new DateTime(1993, 8, 16), 
                           new DateTime(1994, 7, 28), 
                           new DateTime(2000, 10, 16), 
                           new DateTime(2003, 7, 27), 
                           new DateTime(2007, 5, 27) };

      foreach (DateTime dateValue in dates)
      {
         TimeSpan interval = dateValue - birthdate;
         // Get the approximate number of years, without accounting for leap years.
         int years = ((int) interval.TotalDays) / 365;
         // See if adding the number of years exceeds dateValue.
         string output;
         if (birthdate.AddYears(years) <= dateValue) {
            output = String.Format("You are now {0} years old.", years);
            Console.WriteLine(output);
         }   
         else {
            output = String.Format("You are now {0} years old.", years - 1);
            Console.WriteLine(output);
         }      
      }
   }
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
Module Example
   Public Sub Main()
      Dim birthdate As Date = #7/28/1993#
      Dim dates() As Date = { #9/16/1993#, #7/28/1994#, #10/16/2000#, _
                              #7/27/2003#, #5/27/2007# }
      For Each dateValue As Date In dates
         Dim interval As TimeSpan = dateValue - birthdate
         ' Get the approximate number of years, without accounting for leap years.
         Dim years As Integer = CInt(interval.TotalDays) \ 365
         ' See if adding the number of years exceeds dateValue.
         Dim output As String
         If birthdate.AddYears(years) <= dateValue Then
            output = String.Format("You are now {0} years old.", years)
            Console.WriteLine(output)
         Else
            output = String.Format("You are now {0} years old.", years - 1)
            Console.WriteLine(output)   
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       You are now 0 years old.
'       You are now 1 years old.
'       You are now 7 years old.
'       You are now 9 years old.
'       You are now 13 years old.
See Also

Applies to