Udostępnij za pośrednictwem


Single.ToString Metoda

Definicja

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu.

Przeciążenia

ToString()

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu.

ToString(IFormatProvider)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanych danych formatowania specyficznych dla kultury.

ToString(String)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu.

ToString(String, IFormatProvider)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu i informacji specyficznych dla kultury.

ToString()

Źródło:
Single.cs
Źródło:
Single.cs
Źródło:
Single.cs

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu.

public:
 override System::String ^ ToString();
public override string ToString ();
override this.ToString : unit -> string
Public Overrides Function ToString () As String

Zwraca

Ciąg reprezentujący wartość tego wystąpienia.

Przykłady

W poniższym przykładzie użyto metody domyślnej Single.ToString , aby wyświetlić reprezentacje ciągów wielu Single wartości.

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

Poniższy przykład kodu ilustruje użycie Parse(String) metody wraz z ToString() metodą .

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 );
      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 );
   }
}
while (  !done );
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

Uwagi

Metoda ToString() formatuje Single wartość w domyślnym formacie ("G" lub ogólnym) bieżącej kultury. Jeśli chcesz określić inny format lub kulturę, użyj innych przeciążeń ToString metody w następujący sposób:

Aby użyć formatu Dla kultury Używanie przeciążenia
Domyślny format ("G") Określona kultura ToString(IFormatProvider)
Określony format Domyślna (bieżąca) kultura ToString(String)
Określony format Określona kultura ToString(String, IFormatProvider)

Zwracaną wartością może być PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbollub ciąg formularza:

[znak]cyfry-całkowite[.[cyfry-ułamkowe]][e[znak]cyfry-wykładnicze]

Elementy opcjonalne są obramowane nawiasami kwadratowymi ([ i ]). Elementy, które zawierają „cyfry”, składają się z serii cyfr od 0 do 9. W poniższej tabeli wymieniono każdy element:

Element Opis
sign Znak ujemny lub symbol znaku dodatniego.
cyfry-całkowite Ciąg cyfr określający część całkowitą liczby. Cyfry całkowite mogą być nieobecne w przypadku cyfr ułamkowych.
'.' Symbol dziesiętny specyficzny dla kultury.
cyfry-ułamkowe Ciąg cyfr określający część ułamkową liczby.
"e" Mała litera „e”, wskazująca zapis wykładniczy (naukowy).
cyfry-wykładnicze Ciąg cyfr określające wykładnik potęgi.

Oto kilka przykładów zwracanej wartości: „100”, „-123,456,789”, „123.45e + 6”, „500”, „3.1416”, „600”, „-0.123” i „-nieskończoność”.

Platforma .NET zapewnia rozbudowaną obsługę formatowania, która została szczegółowo opisana w następujących tematach formatowania:

Zobacz też

Dotyczy

ToString(IFormatProvider)

Źródło:
Single.cs
Źródło:
Single.cs
Źródło:
Single.cs

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanych danych formatowania specyficznych dla kultury.

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

Parametry

provider
IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

Zwraca

Ciąg reprezentacja wartości tego wystąpienia określona przez provider.

Implementuje

Przykłady

Poniższy przykład przedstawia reprezentację ciągu dwóch Single wartości przy użyciu CultureInfo obiektów reprezentujących kilka różnych kultur.

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

Uwagi

Metoda ToString(IFormatProvider) formatuje Single wartość w domyślnym formacie ("G" lub ogólnym) określonej kultury. Jeśli chcesz określić inny format lub bieżącą kulturę, użyj innych przeciążeń ToString metody w następujący sposób:

Aby użyć formatu Dla kultury Używanie przeciążenia
Domyślny format ("G") Domyślna (bieżąca) kultura ToString()
Określony format Domyślna (bieżąca) kultura ToString(String)
Określony format Określona kultura ToString(String, IFormatProvider)

Zwracaną wartością może być PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbollub ciąg formularza:

[znak]cyfry-całkowite[.[cyfry-ułamkowe]][e[znak]cyfry-wykładnicze]

Elementy opcjonalne są obramowane nawiasami kwadratowymi ([ i ]). Elementy zawierające termin "cyfry" składają się z serii znaków liczbowych od 0 do 9. W poniższej tabeli wymieniono każdy element.

Element Opis
znak Znak ujemny lub symbol znaku dodatniego.
cyfry-całkowite Ciąg cyfr określający część całkowitą liczby. Cyfry całkowite mogą być nieobecne w przypadku cyfr ułamkowych.
'.' Symbol dziesiętny specyficzny dla kultury.
cyfry-ułamkowe Ciąg cyfr określający część ułamkową liczby.
"e" Mała litera „e”, wskazująca zapis wykładniczy (naukowy).
cyfry-wykładnicze Ciąg cyfr określające wykładnik potęgi.

Oto kilka przykładów zwracanej wartości: „100”, „-123,456,789”, „123.45e + 6”, „500”, „3.1416”, „600”, „-0.123” i „-nieskończoność”.

Platforma .NET zapewnia rozbudowaną obsługę formatowania, która została szczegółowo opisana w następujących tematach formatowania:

Parametr provider jest implementacją IFormatProvider , której GetFormat metoda zwraca NumberFormatInfo obiekt. provider Zazwyczaj jest to CultureInfo obiekt lub NumberFormatInfo obiekt. Parametr provider dostarcza informacje specyficzne dla kultury używane w formatowaniu. Jeśli provider parametr ma nullwartość , zwracana wartość jest formatowana przy użyciu NumberFormatInfo danych dla bieżącej kultury.

Aby przekonwertować wartość na reprezentację Single ciągu przy użyciu określonej kultury i określonego ciągu formatu, wywołaj metodę Single.ToString(String, IFormatProvider) .

Zobacz też

Dotyczy

ToString(String)

Źródło:
Single.cs
Źródło:
Single.cs
Źródło:
Single.cs

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu.

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

Parametry

format
String

Ciąg formatu liczbowego.

Zwraca

Reprezentacja ciągu wartości tego wystąpienia określona przez formatparametr .

Wyjątki

Nazwa format jest niepoprawna.

Przykłady

W poniższym przykładzie zdefiniowano wartość liczbową i formatuje ją jako wartość waluty przy użyciu standardowego ciągu formatu liczbowego "C" oraz jako wartość liczbową do trzech miejsc dziesiętnych przy użyciu standardowego ciągu formatu liczbowego "N". Ciągi wyników są formatowane przy użyciu konwencji kultury en-US. Aby uzyskać więcej informacji na temat ciągów formatu liczbowego, zobacz Ciągi formatu liczbowego w warstwie Standardowa i Niestandardowe ciągi formatu liczbowego.

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

Poniższy przykład przedstawia kilka Single wartości przy użyciu każdego z obsługiwanych standardowych specyfikatorów formatu liczbowego wraz z dwoma niestandardowymi ciągami formatu liczbowego. Jeden z tych ciągów formatu niestandardowego ilustruje sposób uzupełniania Single wartości zerami wiodącymi. W celu przeliczenia wartości liczbowych na ciągi w przykładzie użyto konwencji formatowania kultury 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

Uwagi

Metoda ToString(String) formatuje Single wartość w określonym formacie przy użyciu konwencji bieżącej kultury. Jeśli chcesz użyć domyślnego formatu ("G" lub ogólnego) lub określić inną kulturę, użyj innych przeciążeń ToString metody w następujący sposób:

Aby użyć formatu Dla kultury Używanie przeciążenia
Domyślny format ("G") Domyślna (bieżąca) kultura ToString()
Domyślny format ("G") Określona kultura ToString(IFormatProvider)
Określony format Określona kultura ToString(String, IFormatProvider)

Zwracaną wartością może być PositiveInfinitySymbol, , NegativeInfinitySymbolNaNSymbollub ciąg reprezentujący wartość bieżącego wystąpienia, zgodnie z wartością format.

Parametr format może być dowolnym prawidłowym standardowym specyfikatorem formatu liczbowego z wyjątkiem D i X, a także dowolnej kombinacji niestandardowych specyfikatorów formatu liczbowego. Jeśli format jest null lub pusty ciąg, zwracana wartość jest sformatowana za pomocą ogólnego specyfikatora formatu liczbowego ("G").

Platforma .NET zapewnia rozbudowaną obsługę formatowania, która została opisana bardziej szczegółowo w następujących tematach formatowania:

Domyślnie zwracana wartość zawiera tylko 7 cyfr dokładności, chociaż maksymalnie 9 cyfr jest utrzymywanych wewnętrznie. Jeśli wartość tego wystąpienia ma więcej niż 7 cyfr, ToString(String) zwraca PositiveInfinitySymbol wartość lub NegativeInfinitySymbol zamiast oczekiwanej liczby. Jeśli potrzebujesz większej precyzji, określ format specyfikację formatu "G9", która zawsze zwraca 9 cyfr dokładności lub "R", która zwraca 7 cyfr, jeśli liczba może być reprezentowana z tej dokładności lub 9 cyfr, jeśli liczba może być reprezentowana tylko z maksymalną dokładnością.

Zobacz też

Dotyczy

ToString(String, IFormatProvider)

Źródło:
Single.cs
Źródło:
Single.cs
Źródło:
Single.cs

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu i informacji specyficznych dla kultury.

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

Parametry

format
String

Ciąg formatu liczbowego.

provider
IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

Zwraca

Ciąg reprezentacja wartości tego wystąpienia określona przez format i provider.

Implementuje

Przykłady

Poniższy przykład przedstawia Single wartość przy użyciu każdego z obsługiwanych standardowych specyfikatorów formatu liczbowego dla kilku różnych kultur.

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 %

Uwagi

Metoda ToString(String, IFormatProvider) formatuje Single wartość w określonym formacie określonej kultury. Jeśli chcesz użyć domyślnych ustawień formatu lub kultury, użyj innych przeciążeń ToString metody w następujący sposób:

Aby użyć formatu Dla kultury Używanie przeciążenia
Domyślny format ("G") Domyślna (bieżąca) kultura ToString()
Domyślny format ("G") Określona kultura ToString(IFormatProvider)
Określony format Domyślna (bieżąca) kultura ToString(String)

Zwracaną wartością może być PositiveInfinitySymbol, , NegativeInfinitySymbolNaNSymbollub ciąg reprezentujący wartość bieżącego wystąpienia, zgodnie z wartością format.

Parametr format może być dowolnym prawidłowym standardowym specyfikatorem formatu liczbowego z wyjątkiem D i X, a także dowolnej kombinacji niestandardowych specyfikatorów formatu liczbowego. Jeśli format jest lub null pusty ciąg, wartość zwracana dla tego wystąpienia jest sformatowana za pomocą ogólnego specyfikatora formatu liczbowego ("G").

Platforma .NET zapewnia rozbudowaną obsługę formatowania, która została opisana bardziej szczegółowo w następujących tematach formatowania:

Parametr provider jest implementacją IFormatProvider , której GetFormat metoda zwraca NumberFormatInfo obiekt. provider Zazwyczaj jest obiektem CultureInfo lub obiektemNumberFormatInfo. Parametr provider dostarcza informacje specyficzne dla kultury używane w formatowaniu. Jeśli provider jest to null, wartość zwracana jest sformatowana za pomocą NumberFormatInfo obiektu dla bieżącej kultury.

Domyślnie zwracana wartość zawiera tylko 7 cyfr dokładności, chociaż maksymalnie 9 cyfr jest utrzymywanych wewnętrznie. Jeśli wartość tego wystąpienia ma więcej niż 7 cyfr, ToString zwraca PositiveInfinitySymbol wartość lub NegativeInfinitySymbol zamiast oczekiwanej liczby. Jeśli potrzebujesz większej precyzji, określ format specyfikację formatu "G9", która zawsze zwraca 9 cyfr dokładności lub "R", która zwraca 7 cyfr, jeśli liczba może być reprezentowana z tej dokładności lub 9 cyfr, jeśli liczba może być reprezentowana tylko z maksymalną dokładnością.

Zobacz też

Dotyczy