Single.ToString 메서드

정의

네임스페이스:: System

어셈블리:: mscorlib.dll, System.Runtime.dll

어셈블리:: netstandard.dll, System.Runtime.dll

어셈블리:: System.Runtime.dll

어셈블리:: mscorlib.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.

오버로드

Name	Description
ToString()	이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.
ToString(IFormatProvider)	지정된 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.
ToString(String)	지정된 형식을 사용하여 이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.
ToString(String, IFormatProvider)	지정된 형식 및 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.

ToString()

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.

public:
 override System::String ^ ToString();

public override string ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

반품

String

이 인스턴스 값의 문자열 표현입니다.

예제

다음 예제에서는 기본 Single.ToString 메서드를 사용하여 여러 Single 값의 문자열 표현을 표시합니다.

float number;

number = 1.6E20F;
// Displays 1.6E+20.
Console.WriteLine(number.ToString());

number = 1.6E2F;
// Displays 160.
Console.WriteLine(number.ToString());

number = -3.541F;
// Displays -3.541.
Console.WriteLine(number.ToString());

number = -1502345222199E-07F;
// Displays -150234.5222199.
Console.WriteLine(number.ToString());

number = -15023452221990199574E-09F;
// Displays -15023452221.9902.
Console.WriteLine(number.ToString());

number = .60344F;
// Displays 0.60344.
Console.WriteLine(number.ToString());

number = .000000001F;
// Displays 1E-09.
Console.WriteLine(number.ToString());

let number = 1.6E20F
// Displays 1.6E+20.
printfn $"{number.ToString()}"

let number = 1.6E2F
// Displays 160.
printfn $"{number.ToString()}"

let number = -3.541F
// Displays -3.541.
printfn $"{number.ToString()}"

let number = -1502345222199E-07F
// Displays -150234.5222199.
printfn $"{number.ToString()}"

let number = -15023452221990199574E-09F
// Displays -15023452221.9902.
printfn $"{number.ToString()}"

let number = 0.60344F
// Displays 0.60344.
printfn $"{number.ToString()}"

let number = 0.000000001F
// Displays 1E-09.
printfn $"{number.ToString()}"

Dim number As Single

number = 1.6E20
' Displays 1.6E+20.      
Console.WriteLine(number.ToString())

number = 1.6E2
' Displays 160.
Console.WriteLine(number.ToString())

number = -3.541
' Displays -3.541.
Console.WriteLine(number.ToString())

number = -1502345222199E-07
' Displays -150234.5222199.
Console.WriteLine(number.ToString())

number = -15023452221990199574E-09
' Displays -15023452221.9902.
Console.WriteLine(number.ToString())

number = .60344
' Displays 0.60344.
Console.WriteLine(number.ToString())

number = .000000001
' Displays 1E-09.
Console.WriteLine(number.ToString())

다음 코드 예제에서는 메서드와 함께 메서드를 Parse(String) 사용하는 방법을 ToString() 보여 줍니다.

bool done = false;
string inp;
do
{
    Console.Write("Enter a real number: ");
    inp = Console.ReadLine();
    try
    {
        s = Single.Parse(inp);
        Console.WriteLine("You entered {0}.", s.ToString());
        done = true;
    }
    catch (FormatException)
    {
        Console.WriteLine("You did not enter a number.");
    }
    catch (Exception e)
    {
        Console.WriteLine("An exception occurred while parsing your response: {0}", e.ToString());
    }
} while (!done);

let mutable finished = false
while not finished do
    printf "Enter a real number: "
    let inp = stdin.ReadLine()
    try
        let s = Single.Parse inp
        printfn $"You entered {s}."
        finished <- true
    with 
    | :? FormatException ->
        printfn "You did not enter a number."
    | e ->
        printfn "An exception occurred while parsing your response: {e}"

Dim Done As Boolean = False
Dim Inp As String
Do

    Console.Write("Enter a real number: ")
    Inp = Console.ReadLine()
    Try
        S = Single.Parse(Inp)
        Console.WriteLine("You entered " + S.ToString() + ".")
        Done = True
    Catch E As FormatException
        Console.WriteLine("You did not enter a number.")
    Catch E As Exception
        Console.WriteLine("An exception occurred while parsing your response: " + E.ToString())
    End Try
Loop While Not Done

설명

메서드는 ToString() 현재 문화권 Single 의 기본("G" 또는 일반) 형식으로 값의 형식을 지정합니다. 다른 형식이나 문화권을 지정하려면 다음과 같이 메서드의 ToString 다른 오버로드를 사용합니다.

형식을 사용하려면	문화권의 경우	오버로드 사용
기본("G") 형식	특정 문화권	ToString(IFormatProvider)
특정 형식	기본(현재) 문화권	ToString(String)
특정 형식	특정 문화권	ToString(String, IFormatProvider)

반환 값은 폼의 문자열일 수 있습니다PositiveInfinitySymbol NegativeInfinitySymbol NaNSymbol.

[sign]정수 자릿수[.[ fractional-digits]][e[sign]exponential-digits]

선택적 요소는 대괄호([ 및 ])로 프레임됩니다. "digits"라는 용어를 포함하는 요소는 0에서 9까지의 일련의 숫자 문자로 구성됩니다. 다음 표에서는 각 요소를 나열합니다.

요소	Description
서명	음수 기호 또는 양수 기호입니다.
정수 자릿수	숫자의 정수 부분을 지정하는 일련의 숫자입니다. 소수 자릿수가 있는 경우 정수 자릿수가 없을 수 있습니다.
'.'	문화권별 소수점 기호입니다.
fractional-digits	숫자의 소수 부분을 지정하는 일련의 숫자입니다.
'e'	지수(과학적) 표기법을 나타내는 소문자 'e'입니다.
exponential-digits	지수를 지정하는 일련의 숫자입니다.

반환 값의 예로는 "100", "-123,456,789", "123.45e+6", "500", "3.1416", "600", "-0.123" 및 "-Infinity"가 있습니다.

.NET은 다음 서식 지정 항목에서 자세히 설명하는 광범위한 서식 지정 지원을 제공합니다.

숫자 형식 지정자에 대한 자세한 내용은 표준 숫자 형식 문자열 및 사용자 지정 숫자 형식 문자열을 참조하세요.
서식 지정에 대한 자세한 내용은 형식 서식을 참조하세요.

추가 정보

적용 대상

ToString(IFormatProvider)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

지정된 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.

public:
 virtual System::String ^ ToString(IFormatProvider ^ provider);

public:
 System::String ^ ToString(IFormatProvider ^ provider);

public string ToString(IFormatProvider provider);

public string ToString(IFormatProvider? provider);

override this.ToString : IFormatProvider -> string

Public Function ToString (provider As IFormatProvider) As String

매개 변수

provider: IFormatProvider

문화권별 서식 정보를 제공하는 개체입니다.

반품

String

에 지정된 provider대로 이 인스턴스 값의 문자열 표현입니다.

구현

ToString(IFormatProvider)

예제

다음 예제에서는 여러 다른 문화권을 나타내는 개체를 사용 하 여 Single 두 CultureInfo 값의 문자열 표현을 표시 합니다.

float value;

value = -16325.62015F;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));

value = 16034.125E21F;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
// This example displays the following output to the console:
//       -16325.62015
//       -16325.62015
//       -16325,62015
//       1.6034125E+25
//       1.6034125E+25
//       1,6034125E+25

let value = -16325.62015F
// Display value using the invariant culture.
printfn $"{value.ToString CultureInfo.InvariantCulture}"
// Display value using the en-GB culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "en-GB")}"""
// Display value using the de-DE culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "de-DE")}"""

let value = 16034.125E21F
// Display value using the invariant culture.
printfn $"{value.ToString CultureInfo.InvariantCulture}"
// Display value using the en-GB culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "en-GB")}"""
// Display value using the de-DE culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "de-DE")}"""
// This example displays the following output to the console:
//       -16325.62015
//       -16325.62015
//       -16325,62015
//       1.6034125E+25
//       1.6034125E+25
//       1,6034125E+25

Dim value As Single 

value = -16325.62015
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))

value = 16034.125E21
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))
' This example displays the following output to the console:
'       -16325.62015
'       -16325.62015
'       -16325,62015
'       1.6034125E+25
'       1.6034125E+25
'       1,6034125E+25

설명

메서드는 ToString(IFormatProvider) 지정된 문화권 Single 의 기본("G" 또는 일반) 형식으로 값의 형식을 지정합니다. 다른 형식 또는 현재 문화권을 지정하려면 다음과 같이 메서드의 ToString 다른 오버로드를 사용합니다.

형식을 사용하려면	문화권의 경우	오버로드 사용
기본("G") 형식	기본(현재) 문화권	ToString()
특정 형식	기본(현재) 문화권	ToString(String)
특정 형식	특정 문화권	ToString(String, IFormatProvider)

반환 값은 폼의 문자열일 수 있습니다PositiveInfinitySymbol NegativeInfinitySymbol NaNSymbol.

[sign]정수 자릿수[.[ fractional-digits]][e[sign]exponential-digits]

요소	Description
sign	음수 기호 또는 양수 기호입니다.
정수 자릿수	숫자의 정수 부분을 지정하는 일련의 숫자입니다. 소수 자릿수가 있는 경우 정수 자릿수가 없을 수 있습니다.
'.'	문화권별 소수점 기호입니다.
fractional-digits	숫자의 소수 부분을 지정하는 일련의 숫자입니다.
'e'	지수(과학적) 표기법을 나타내는 소문자 'e'입니다.
exponential-digits	지수를 지정하는 일련의 숫자입니다.

반환 값의 예로는 "100", "-123,456,789", "123.45e+6", "500", "3.1416", "600", "-0.123" 및 "-Infinity"가 있습니다.

.NET은 다음 서식 지정 항목에서 자세히 설명하는 광범위한 서식 지정 지원을 제공합니다.

숫자 형식 지정자에 대한 자세한 내용은 표준 숫자 형식 문자열 및 사용자 지정 숫자 형식 문자열을 참조하세요.
서식 지정에 대한 자세한 내용은 형식 서식을 참조하세요.

provider 매개 변수는 메서드가 IFormatProvider 개체를 GetFormat 반환하는 구현입니다NumberFormatInfo. 일반적으로 providerCultureInfo 개체 또는 개체입니다 NumberFormatInfo . 매개 변수는 provider 서식 지정에 사용되는 문화권별 정보를 제공합니다. 이 provider경우 null 반환 값은 현재 문화권에 NumberFormatInfo 대한 데이터를 사용하여 형식이 지정됩니다.

지정된 문화권 및 특정 형식 문자열을 사용하여 값을 문자열 표현으로 변환 Single 하려면 메서드를 호출합니다 Single.ToString(String, IFormatProvider) .

추가 정보

적용 대상

ToString(String)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

지정된 형식을 사용하여 이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.

public:
 System::String ^ ToString(System::String ^ format);

public string ToString(string format);

public string ToString(string? format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

매개 변수

format: String

숫자 형식 문자열입니다.

반품

String

에 지정된 format대로 이 인스턴스 값의 문자열 표현입니다.

예외

FormatException

format 가 잘못되었습니다.

예제

다음 예제에서는 숫자 값을 정의하고 "C" 표준 숫자 형식 문자열을 사용하여 통화 값으로 서식을 지정하고 "N" 표준 숫자 형식 문자열을 사용하여 소수 자릿수 3자리에 숫자 값으로 형식을 지정합니다. 결과 문자열은 en-US 문화권의 규칙을 사용하여 형식이 지정됩니다. 숫자 서식 문자열에 대한 자세한 내용은 표준 숫자 형식 문자열 및 사용자 지정 숫자 형식 문자열을 참조하세요.

using System;

public class Example
{
   public static void Main()
   {
      Double number = 1764.3789;
      
      // Format as a currency value.
      Console.WriteLine(number.ToString("C"));
      
      // Format as a numeric value with 3 decimal places.
      Console.WriteLine(number.ToString("N3"));
   }
}
// The example displays the following output:
//       $1,764.38
//       1,764.379

let number = 1764.3789

// Format as a currency value.
printfn $"""{number.ToString "C"}"""

// Format as a numeric value with 3 decimal places.
printfn $"""{number.ToString "N3"}"""
// The example displays the following output:
//       $1,764.38
//       1,764.379

Module Example
   Public Sub Main()
      Dim number As Single = 1764.3789
      
      ' Format as a currency value.
      Console.WriteLine(number.ToString("C"))
      
      ' Format as a numeric value with 3 decimal places.
      Console.WriteLine(number.ToString("N3"))
   End Sub
End Module
' The example displays the following output:
'       $1,764.38
'       1,764.379

다음 예제에서는 두 개의 사용자 지정 숫자 형식 문자열과 함께 지원되는 각 표준 숫자 형식 지정자를 사용하여 여러 Single 값을 표시합니다. 이러한 사용자 지정 형식 문자열 중 하나는 앞에 오는 0으로 값을 패딩하는 Single 방법을 보여 줍니다. 숫자 값을 문자열로 변환할 때 예제에서는 en-US 문화권의 서식 지정 규칙을 사용합니다.

float[] numbers= { 1054.32179F, -195489100.8377F, 1.0437E21F, 
                   -1.0573e-05F };
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P", 
                        "R", "#,000.000", "0.###E-000",
                        "000,000,000,000.00###" };

foreach (float number in numbers)
{
   Console.WriteLine("Formatting of {0}:", number);
   foreach (string specifier in specifiers)
      Console.WriteLine("   {0,5}: {1}", 
                        specifier, number.ToString(specifier));

   Console.WriteLine();
}
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//              C: $1,054.32
//              E: 1.054322E+003
//              e: 1.054322e+003
//              F: 1054.32
//              G: 1054.32179
//              N: 1,054.32
//              P: 105,432.18 %
//              R: 1054.32179
//          #,000.000: 1,054.322
//          0.###E-000: 1.054E003
//          000,000,000,000.00###: 000,000,001,054.322
//       
//       Formatting of -195489100.8377:
//              C: ($195,489,100.84)
//              E: -1.954891E+008
//              e: -1.954891e+008
//              F: -195489100.84
//              G: -195489100.8377
//              N: -195,489,100.84
//              P: -19,548,910,083.77 %
//              R: -195489100.8377
//          #,000.000: -195,489,100.838
//          0.###E-000: -1.955E008
//          000,000,000,000.00###: -000,195,489,100.00
//       
//       Formatting of 1.0437E+21:
//              C: $1,043,700,000,000,000,000,000.00
//              E: 1.043700E+021
//              e: 1.043700e+021
//              F: 1043700000000000000000.00
//              G: 1.0437E+21
//              N: 1,043,700,000,000,000,000,000.00
//              P: 104,370,000,000,000,000,000,000.00 %
//              R: 1.0437E+21
//          #,000.000: 1,043,700,000,000,000,000,000.000
//          0.###E-000: 1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//       
//       Formatting of -1.0573E-05:
//              C: $0.00
//              E: -1.057300E-005
//              e: -1.057300e-005
//              F: 0.00
//              G: -1.0573E-05
//              N: 0.00
//              P: 0.00 %
//              R: -1.0573E-05
//          #,000.000: 000.000
//          0.###E-000: -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001

let numbers = 
    [| 1054.32179F; -195489100.8377F; 1.0437E21F; -1.0573e-05F |]
let specifiers = 
    [| "C"; "E"; "e"; "F"; "G"; "N"; "P" 
       "R"; "#,000.000"; "0.###E-000"
       "000,000,000,000.00###" |]

for number in numbers do
    printfn $"Formatting of {number}:"
    for specifier in specifiers do
        printfn $"   {specifier,5}: {number.ToString specifier}" 
    printfn ""
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//              C: $1,054.32
//              E: 1.054322E+003
//              e: 1.054322e+003
//              F: 1054.32
//              G: 1054.32179
//              N: 1,054.32
//              P: 105,432.18 %
//              R: 1054.32179
//          #,000.000: 1,054.322
//          0.###E-000: 1.054E003
//          000,000,000,000.00###: 000,000,001,054.322
//       
//       Formatting of -195489100.8377:
//              C: ($195,489,100.84)
//              E: -1.954891E+008
//              e: -1.954891e+008
//              F: -195489100.84
//              G: -195489100.8377
//              N: -195,489,100.84
//              P: -19,548,910,083.77 %
//              R: -195489100.8377
//          #,000.000: -195,489,100.838
//          0.###E-000: -1.955E008
//          000,000,000,000.00###: -000,195,489,100.00
//       
//       Formatting of 1.0437E+21:
//              C: $1,043,700,000,000,000,000,000.00
//              E: 1.043700E+021
//              e: 1.043700e+021
//              F: 1043700000000000000000.00
//              G: 1.0437E+21
//              N: 1,043,700,000,000,000,000,000.00
//              P: 104,370,000,000,000,000,000,000.00 %
//              R: 1.0437E+21
//          #,000.000: 1,043,700,000,000,000,000,000.000
//          0.###E-000: 1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//       
//       Formatting of -1.0573E-05:
//              C: $0.00
//              E: -1.057300E-005
//              e: -1.057300e-005
//              F: 0.00
//              G: -1.0573E-05
//              N: 0.00
//              P: 0.00 %
//              R: -1.0573E-05
//          #,000.000: 000.000
//          0.###E-000: -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001

Dim numbers() As Single = {1054.32179, -195489100.8377, 1.0437E21, _
                           -1.0573e-05}
Dim specifiers() As String = { "C", "E", "e", "F", "G", "N", "P", _
                               "R", "#,000.000", "0.###E-000", _
                               "000,000,000,000.00###"}
For Each number As Single In numbers
   Console.WriteLine("Formatting of {0}:", number)
   For Each specifier As String In specifiers
      Console.WriteLine("   {0,5}: {1}", _
                        specifier, number.ToString(specifier))
   Next
   Console.WriteLine()
Next
' The example displays the following output to the console:
'       Formatting of 1054.32179:
'              C: $1,054.32
'              E: 1.054322E+003
'              e: 1.054322e+003
'              F: 1054.32
'              G: 1054.32179
'              N: 1,054.32
'              P: 105,432.18 %
'              R: 1054.32179
'          #,000.000: 1,054.322
'          0.###E-000: 1.054E003
'          000,000,000,000.00###: 000,000,001,054.322      
'       
'       Formatting of -195489100.8377:
'              C: ($195,489,100.84)
'              E: -1.954891E+008
'              e: -1.954891e+008
'              F: -195489100.84
'              G: -195489100.8377
'              N: -195,489,100.84
'              P: -19,548,910,083.77 %
'              R: -195489100.8377
'          #,000.000: -195,489,100.838
'          0.###E-000: -1.955E008
'          000,000,000,000.00###: -000,195,489,100.00
'       
'       Formatting of 1.0437E+21:
'              C: $1,043,700,000,000,000,000,000.00
'              E: 1.043700E+021
'              e: 1.043700e+021
'              F: 1043700000000000000000.00
'              G: 1.0437E+21
'              N: 1,043,700,000,000,000,000,000.00
'              P: 104,370,000,000,000,000,000,000.00 %
'              R: 1.0437E+21
'          #,000.000: 1,043,700,000,000,000,000,000.000
'          0.###E-000: 1.044E021
'          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
'       
'       Formatting of -1.0573E-05:
'              C: $0.00
'              E: -1.057300E-005
'              e: -1.057300e-005
'              F: 0.00
'              G: -1.0573E-05
'              N: 0.00
'              P: 0.00 %
'              R: -1.0573E-05
'          #,000.000: 000.000
'          0.###E-000: -1.057E-005
'          000,000,000,000.00###: -000,000,000,000.00001

설명

메서드는 ToString(String) 현재 문화권 Single 의 규칙을 사용하여 지정된 형식의 값 형식을 지정합니다. 기본("G" 또는 일반) 형식을 사용하거나 다른 문화권을 지정하려면 다음과 같이 메서드의 ToString 다른 오버로드를 사용합니다.

형식을 사용하려면	문화권의 경우	오버로드 사용
기본("G") 형식	기본(현재) 문화권	ToString()
기본("G") 형식	특정 문화권	ToString(IFormatProvider)
특정 형식	특정 문화권	ToString(String, IFormatProvider)

반환 값은 지정한 대로 현재 인스턴스 값의 문자열 표현, 또는 문자열 표현일 PositiveInfinitySymbol NegativeInfinitySymbol NaNSymbolformat수 있습니다.

매개 변수는 format 사용자 지정 숫자 형식 지정자의 조합뿐만 아니라 D 및 X를 제외한 모든 유효한 표준 숫자 형식 지정자일 수 있습니다. 형식이거나 null 빈 문자열인 경우 반환 값은 일반 숫자 형식 지정자("G")로 서식이 지정됩니다.

.NET은 다음 서식 지정 항목에서 자세히 설명하는 광범위한 서식 지정 지원을 제공합니다.

숫자 형식 지정자에 대한 자세한 내용은 표준 숫자 형식 문자열 및 사용자 지정 숫자 형식 문자열을 참조하세요.
서식 지정에 대한 자세한 내용은 형식 서식을 참조하세요.

기본적으로 반환 값은 7자리의 전체 자릿수만 포함하지만 내부적으로는 최대 9자리 자릿수가 유지됩니다. 이 인스턴스의 값이 7자리보다 큰 경우 예상 숫자 대신 반환하거나 ToString(String) 반환 PositiveInfinitySymbol 합니다NegativeInfinitySymbol. 정밀도가 더 필요한 경우 항상 9자리의 전체 자릿수를 반환하는 "G9" 형식 사양을 지정하거나, 숫자가 해당 전체 자릿수로 표시될 수 있으면 7자리를 반환하고, 최대 정밀도로만 표시될 수 있는 경우 9자리를 반환하는 "R"을 지정 format 합니다.

추가 정보

적용 대상

ToString(String, IFormatProvider)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

지정된 형식 및 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.

public:
 virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ provider);

public string ToString(string format, IFormatProvider provider);

public string ToString(string? format, IFormatProvider? provider);

override this.ToString : string * IFormatProvider -> string

Public Function ToString (format As String, provider As IFormatProvider) As String

매개 변수

format: String

숫자 형식 문자열입니다.

provider: IFormatProvider

문화권별 서식 정보를 제공하는 개체입니다.

반품

String

에 지정된 format 대로 이 인스턴스 값의 문자열 표현입니다 provider.

구현

ToString(String, IFormatProvider)

예제

다음 예제에서는 여러 다른 문화권에 대해 지원되는 각 표준 숫자 형식 지정자를 사용하여 값을 표시 Single 합니다.

float value = 16325.62901F;
string specifier;
CultureInfo culture;

// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo.CreateSpecificCulture("eu-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture));
// Displays:    16325.62901

specifier = "C";
culture = CultureInfo.CreateSpecificCulture("en-US");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    £16,325.63

specifier = "E04";
culture = CultureInfo.CreateSpecificCulture("sv-SE");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004   
 culture = CultureInfo.CreateSpecificCulture("en-NZ");
 Console.WriteLine(value.ToString(specifier, culture));
// Displays:    1.6326E+004   

specifier = "F";
culture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325.63

specifier = "N";
culture = CultureInfo.CreateSpecificCulture("es-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16 325,63

specifier = "P";
culture = CultureInfo.InvariantCulture;
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG");
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.256 %

let value = 16325.62901F

// Use standard numeric format specifiers.
let specifier = "G"
let culture = CultureInfo.CreateSpecificCulture "eu-ES"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325,62901
printfn $"{value.ToString(specifier, CultureInfo.InvariantCulture)}"
// Displays:    16325.62901

let specifier = "C"
let culture = CultureInfo.CreateSpecificCulture "en-US"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    $16,325.63
let culture = CultureInfo.CreateSpecificCulture "en-GB"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    £16,325.63

let specifier = "E04"
let culture = CultureInfo.CreateSpecificCulture "sv-SE"
printfn $"{value.ToString(specifier, culture)}"
// Displays: 1,6326E+004   
let culture = CultureInfo.CreateSpecificCulture "en-NZ"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    1.6326E+004   

let specifier = "F"
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325,63
let culture = CultureInfo.CreateSpecificCulture "en-CA"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325.63

let specifier = "N"
let culture = CultureInfo.CreateSpecificCulture "es-ES"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16.325,63
let culture = CultureInfo.CreateSpecificCulture "fr-CA"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16 325,63

let specifier = "P"
let culture = CultureInfo.InvariantCulture
printfn $"{(value / 10000f).ToString(specifier, culture)}"
// Displays:    163.26 %
let culture = CultureInfo.CreateSpecificCulture "ar-EG"
printfn $"{(value / 10000f).ToString(specifier, culture)}"
// Displays:    163.256 %

Dim value As Single = 16325.62901
Dim specifier As String
Dim culture As CultureInfo

' Use standard numeric format specifiers.
specifier = "G"
culture = CultureInfo.CreateSpecificCulture("eu-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture))
' Displays:    16325.62901

specifier = "C"
culture = CultureInfo.CreateSpecificCulture("en-US")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    £16,325.63

specifier = "E04"
culture = CultureInfo.CreateSpecificCulture("sv-SE")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 1,6326E+004   
 culture = CultureInfo.CreateSpecificCulture("en-NZ")
 Console.WriteLine(value.ToString(specifier, culture))
' Displays:    1.6326E+004   

specifier = "F"
culture = CultureInfo.CreateSpecificCulture("fr-FR")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325.63

specifier = "N"
culture = CultureInfo.CreateSpecificCulture("es-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16 325,63

specifier = "P"
culture = CultureInfo.InvariantCulture
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays:    163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG")
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays:    163.256 %

설명

메서드는 ToString(String, IFormatProvider) 지정된 문화권 Single 의 지정된 형식으로 값의 서식을 지정합니다. 기본 형식 또는 문화권 설정을 사용하려면 다음과 같이 메서드의 ToString 다른 오버로드를 사용합니다.

형식을 사용하려면	문화권의 경우	오버로드 사용
기본("G") 형식	기본(현재) 문화권	ToString()
기본("G") 형식	특정 문화권	ToString(IFormatProvider)
특정 형식	기본(현재) 문화권	ToString(String)

반환 값은 지정한 대로 현재 인스턴스 값의 문자열 표현, 또는 문자열 표현일 PositiveInfinitySymbol NegativeInfinitySymbol NaNSymbolformat수 있습니다.

매개 변수는 format 사용자 지정 숫자 형식 지정자의 조합뿐만 아니라 D 및 X를 제외한 모든 유효한 표준 숫자 형식 지정자일 수 있습니다. 문자열이거나 format 빈 문자열인 경우 null 이 인스턴스의 반환 값은 일반 숫자 형식 지정자("G")로 서식이 지정됩니다.

.NET은 다음 서식 지정 항목에서 자세히 설명하는 광범위한 서식 지정 지원을 제공합니다.

숫자 형식 지정자에 대한 자세한 내용은 표준 숫자 형식 문자열 및 사용자 지정 숫자 형식 문자열을 참조하세요.
서식 지정에 대한 자세한 내용은 형식 서식을 참조하세요.

provider 매개 변수는 메서드가 IFormatProvider 개체를 GetFormat 반환하는 구현입니다NumberFormatInfo. 일반적으로 providerCultureInfo 개체 또는 개체입니다 NumberFormatInfo . 매개 변수는 provider 서식 지정에 사용되는 문화권별 정보를 제공합니다. 이 provider경우 null 반환 값은 현재 문화권에 대한 개체로 NumberFormatInfo 서식이 지정됩니다.

기본적으로 반환 값은 7자리의 전체 자릿수만 포함하지만 내부적으로는 최대 9자리 자릿수가 유지됩니다. 이 인스턴스의 값이 7자리보다 큰 경우 예상 숫자 대신 반환하거나 ToString 반환 PositiveInfinitySymbol 합니다NegativeInfinitySymbol. 정밀도가 더 필요한 경우 항상 9자리의 전체 자릿수를 반환하는 "G9" 형식 사양을 지정하거나, 숫자가 해당 전체 자릿수로 표시될 수 있으면 7자리를 반환하고, 최대 정밀도로만 표시될 수 있는 경우 9자리를 반환하는 "R"을 지정 format 합니다.

추가 정보

적용 대상

피드백

이 페이지가 도움이 되었나요?