Single.ToString Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření.

Přetížení

ToString()	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření.
ToString(IFormatProvider)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určených informací o formátování specifických pro jazykovou verzi.
ToString(String)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu.
ToString(String, IFormatProvider)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu a informací o formátování specifických pro jazykovou verzi.

ToString()

Zdroj:: Single.cs

Zdroj:: Single.cs

Zdroj:: Single.cs

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření.

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

public override string ToString ();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Návraty

String

Řetězcová reprezentace hodnoty této instance.

Příklady

Následující příklad používá výchozí Single.ToString metodu k zobrazení řetězcových reprezentací počtu Single hodnot.

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

Následující příklad kódu znázorňuje použití Parse(String) metody spolu s metodou 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 );
      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

Poznámky

Metoda ToString() formátuje Single hodnotu ve výchozím ("G" nebo obecném) formátu aktuální jazykové verze. Pokud chcete zadat jiný formát nebo jazykovou verzi, použijte další přetížení ToString metody následujícím způsobem:

Použití formátu	Pro jazykovou verzi	Použití přetížení
Výchozí formát ("G")	Konkrétní jazyková verze	ToString(IFormatProvider)
Konkrétní formát	Výchozí (aktuální) jazyková verze	ToString(String)
Konkrétní formát	Konkrétní jazyková verze	ToString(String, IFormatProvider)

Vrácená hodnota může být PositiveInfinitySymbol, NegativeInfinitySymbol NaNSymbol, nebo řetězec formuláře:

[znaménko]číslice-základu[.[desetinné-číslice]][e[znaménko]číslice-exponentu]

Volitelné prvky jsou uvedeny v hranatých závorkách ( [ a ] ). Prvky, které obsahují číslice se skládají z řady číselných znaků od 0 do 9. V následující tabulce jsou uvedeny jednotlivé prvky:

Element	Popis
sign	Symbol záporného znaménka nebo symbol kladného znaménka.
číslice-základu	Řada číslic určující základní část čísla. Číslice základu nemusí být uvedeny, pokud jsou uvedeny desetinné číslice.
'.'	Symbol desetinné čárky specifický pro jazykovou verzi.
desetinné-číslice	Řada číslic určující zlomkovou část čísla.
"e"	Malé písmeno e označující exponenciální zápis (vědecký).
číslice-exponentu	Řada číslic určující exponent.

Příklady vrácených hodnot: "100", "-123,456,789", "123.45e + 6", "500", "3.1416", "600", "-0.123" a "-nekonečno".

.NET poskytuje rozsáhlou podporu formátování, která je podrobněji popsána v následujících tématech formátování:

Další informace o specifikátorech číselného formátu najdete v tématech Řetězce standardního číselného formátu a Vlastní řetězce číselného formátu.
Další informace o formátování najdete v tématu Typy formátování.

Viz také

Platí pro

ToString(IFormatProvider)

Zdroj:: Single.cs

Zdroj:: Single.cs

Zdroj:: Single.cs

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určených informací o formátování specifických pro jazykovou verzi.

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

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi.

Návraty

String

Řetězcová reprezentace hodnoty této instance, jak je určena nástrojem provider.

Implementuje

ToString(IFormatProvider)

Příklady

Následující příklad zobrazuje řetězcovou reprezentaci dvou Single hodnot pomocí CultureInfo objektů, které představují několik různých jazykových verzí.

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

Poznámky

Metoda ToString(IFormatProvider) formátuje Single hodnotu ve výchozím ("G" nebo obecném) formátu zadané jazykové verze. Pokud chcete zadat jiný formát nebo aktuální jazykovou verzi, použijte další přetížení ToString metody následujícím způsobem:

Použití formátu	Pro jazykovou verzi	Použití přetížení
Výchozí formát ("G")	Výchozí (aktuální) jazyková verze	ToString()
Konkrétní formát	Výchozí (aktuální) jazyková verze	ToString(String)
Konkrétní formát	Konkrétní jazyková verze	ToString(String, IFormatProvider)

Vrácená hodnota může být PositiveInfinitySymbol, NegativeInfinitySymbol NaNSymbol, nebo řetězec formuláře:

[znaménko]číslice-základu[.[desetinné-číslice]][e[znaménko]číslice-exponentu]

Volitelné prvky jsou uvedeny v hranatých závorkách ( [ a ] ). Prvky obsahující termín "číslice" se skládají z řady číselných znaků v rozsahu od 0 do 9. V následující tabulce jsou uvedeny jednotlivé prvky.

Element	Popis
znak	Symbol záporného znaménka nebo symbol kladného znaménka.
číslice-základu	Řada číslic určující základní část čísla. Číslice základu nemusí být uvedeny, pokud jsou uvedeny desetinné číslice.
'.'	Symbol desetinné čárky specifický pro jazykovou verzi.
desetinné-číslice	Řada číslic určující zlomkovou část čísla.
"e"	Malé písmeno e označující exponenciální zápis (vědecký).
číslice-exponentu	Řada číslic určující exponent.

Příklady vrácených hodnot: "100", "-123,456,789", "123.45e + 6", "500", "3.1416", "600", "-0.123" a "-nekonečno".

.NET poskytuje rozsáhlou podporu formátování, která je podrobněji popsána v následujících tématech formátování:

Další informace o specifikátorech číselného formátu najdete v tématech Řetězce standardního číselného formátu a Vlastní řetězce číselného formátu.
Další informace o formátování najdete v tématu Typy formátování.

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt. Obvykle provider se jedná o CultureInfo objekt nebo NumberFormatInfo objekt. Parametr provider poskytuje informace specifické pro jazykovou verzi používané při formátování. Pokud provider je null, je vrácená hodnota naformátovaná pomocí NumberFormatInfo dat pro aktuální jazykovou verzi.

Chcete-li převést Single hodnotu na její řetězcovou reprezentaci pomocí zadané jazykové verze a konkrétní formátovací řetězec, zavolejte metodu Single.ToString(String, IFormatProvider) .

Viz také

Platí pro

ToString(String)

Zdroj:: Single.cs

Zdroj:: Single.cs

Zdroj:: Single.cs

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu.

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

Řetězec číselného formátu.

Návraty

String

Řetězcová reprezentace hodnoty této instance, jak je určena nástrojem format.

Výjimky

FormatException

Formát format je neplatný.

Příklady

Následující příklad definuje číselnou hodnotu a formátuje ji jako hodnotu měny pomocí řetězce standardního číselného formátu "C" a jako číselnou hodnotu na tři desetinná místa pomocí řetězce standardního číselného formátu "N". Výsledné řetězce jsou formátovány pomocí konvencí jazykové verze en-US. Další informace o řetězcích číselného formátu najdete v tématech Řetězce standardního číselného formátu a Řetězce vlastního číselného formátu.

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

Následující příklad zobrazuje několik Single hodnot používajících každý z podporovaných specifikátorů standardního číselného formátu společně se dvěma vlastními řetězci číselného formátu. Jeden z těchto řetězců vlastního formátu ukazuje, jak vysunout Single hodnotu s počátečními nulami. Při převodu číselných hodnot na řetězce používá tento příklad konvence formátování jazykové verze 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

Poznámky

Metoda ToString(String) formátuje Single hodnotu v zadaném formátu pomocí konvencí aktuální jazykové verze. Pokud chcete použít výchozí formát ("G" nebo obecný) nebo zadat jinou jazykovou verzi, použijte další přetížení ToString metody následujícím způsobem:

Použití formátu	Pro jazykovou verzi	Použití přetížení
Výchozí formát ("G")	Výchozí (aktuální) jazyková verze	ToString()
Výchozí formát ("G")	Konkrétní jazyková verze	ToString(IFormatProvider)
Konkrétní formát	Konkrétní jazyková verze	ToString(String, IFormatProvider)

Vrácená hodnota může být PositiveInfinitySymbol, NegativeInfinitySymbol NaNSymbol, nebo řetězcová reprezentace hodnoty aktuální instance, jak je uvedeno v parametru format.

Parametr format může být libovolný platný specifikátor číselného formátu s výjimkou D a X a také libovolnou kombinaci specifikátorů vlastního číselného formátu. Pokud je null formát nebo prázdný řetězec, je vrácená hodnota naformátovaná pomocí obecného specifikátoru číselného formátu ("G").

.NET poskytuje rozsáhlou podporu formátování, která je podrobněji popsána v následujících tématech formátování:

Další informace o specifikátorech číselného formátu najdete v tématech Řetězce standardního číselného formátu a Vlastní řetězce číselného formátu.
Další informace o formátování najdete v tématu Typy formátování.

Ve výchozím nastavení obsahuje návratová hodnota pouze 7 číslic s přesností, i když je interně zachováno maximálně 9 číslic. Pokud je hodnota této instance větší než 7 číslic, ToString(String) vrátí PositiveInfinitySymbol nebo NegativeInfinitySymbol místo očekávaného čísla. Pokud požadujete větší přesnost, zadejte format pomocí specifikace formátu "G9", která vždy vrátí 9 číslic s přesností, nebo "R", která vrátí 7 číslic, pokud lze číslo reprezentovat s danou přesností, nebo 9 číslic, pokud číslo může být reprezentováno pouze s maximální přesností.

Viz také

Platí pro

ToString(String, IFormatProvider)

Zdroj:: Single.cs

Zdroj:: Single.cs

Zdroj:: Single.cs

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu a informací o formátování specifických pro jazykovou verzi.

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

Řetězec číselného formátu.

provider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi.

Návraty

String

Řetězcová reprezentace hodnoty této instance podle a formatprovider.

Implementuje

ToString(String, IFormatProvider)

Příklady

Následující příklad zobrazí Single hodnotu používající každý z podporovaných specifikátorů standardního číselného formátu pro několik různých jazykových verzí.

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 %

Poznámky

Metoda ToString(String, IFormatProvider) formátuje Single hodnotu v zadaném formátu zadané jazykové verze. Pokud chcete použít výchozí nastavení formátu nebo jazykové verze, použijte další přetížení ToString metody následujícím způsobem:

Použití formátu	Pro jazykovou verzi	Použití přetížení
Výchozí formát ("G")	Výchozí (aktuální) jazyková verze	ToString()
Výchozí formát ("G")	Konkrétní jazyková verze	ToString(IFormatProvider)
Konkrétní formát	Výchozí (aktuální) jazyková verze	ToString(String)

Vrácená hodnota může být PositiveInfinitySymbol, NegativeInfinitySymbol NaNSymbol, nebo řetězcová reprezentace hodnoty aktuální instance, jak je uvedeno v parametru format.

Parametr format může být libovolný platný specifikátor číselného formátu s výjimkou D a X a také libovolnou kombinaci specifikátorů vlastního číselného formátu. Pokud format je null nebo prázdný řetězec, je návratová hodnota pro tuto instanci naformátovaná pomocí obecného specifikátoru číselného formátu ("G").

.NET poskytuje rozsáhlou podporu formátování, která je podrobněji popsána v následujících tématech formátování:

Další informace o specifikátorech číselného formátu najdete v tématech Řetězce standardního číselného formátu a Vlastní řetězce číselného formátu.
Další informace o formátování najdete v tématu Typy formátování.

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt. Obvykle provider se jedná o CultureInfo objekt nebo NumberFormatInfo objekt. Parametr provider poskytuje informace specifické pro jazykovou verzi používané při formátování. Pokud provider je null, je vrácená hodnota naformátovaná objektem NumberFormatInfo pro aktuální jazykovou verzi.

Ve výchozím nastavení obsahuje návratová hodnota pouze 7 číslic s přesností, i když je interně zachováno maximálně 9 číslic. Pokud je hodnota této instance větší než 7 číslic, ToString vrátí PositiveInfinitySymbol nebo NegativeInfinitySymbol místo očekávaného čísla. Pokud požadujete větší přesnost, zadejte format pomocí specifikace formátu "G9", která vždy vrátí 9 číslic s přesností, nebo "R", která vrátí 7 číslic, pokud lze číslo reprezentovat s danou přesností, nebo 9 číslic, pokud číslo může být reprezentováno pouze s maximální přesností.

Viz také

Platí pro

Sdílet prostřednictvím

Single.ToString Metoda

Definice

Přetížení

ToString()

Návraty

Příklady

Poznámky

Viz také

Platí pro

ToString(IFormatProvider)

Parametry

Návraty

Implementuje

Příklady

Poznámky

Viz také

Platí pro

ToString(String)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

ToString(String, IFormatProvider)

Parametry

Návraty

Implementuje

Příklady

Poznámky

Viz také

Platí pro

Další materiály