Teilen über


Single.ToString Methode

Definition

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.

Überlädt

ToString()

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.

ToString(IFormatProvider)

Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

ToString(String)

Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.

ToString(String, IFormatProvider)

Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

ToString()

Quelle:
Single.cs
Quelle:
Single.cs
Quelle:
Single.cs

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.

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

Gibt zurück

Die Zeichenfolgendarstellung des Werts dieser Instanz.

Beispiele

Im folgenden Beispiel wird die Standardmethode Single.ToString verwendet, um die Zeichenfolgendarstellungen einer Reihe von Single Werten anzuzeigen.

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

Im folgenden Codebeispiel wird die Verwendung der Parse(String) -Methode zusammen mit der ToString() -Methode veranschaulicht.

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

Hinweise

Die ToString() -Methode formatiert einen Single Wert im Standardformat ("G" oder allgemein) der aktuellen Kultur. Wenn Sie ein anderes Format oder eine andere Kultur angeben möchten, verwenden Sie die anderen Überladungen der ToString -Methode wie folgt:

So verwenden Sie das Format Für Kultur Verwenden der Überladung
Standardformat ("G") Eine bestimmte Kultur ToString(IFormatProvider)
Ein bestimmtes Format Standardkultur (aktuell) ToString(String)
Ein bestimmtes Format Eine bestimmte Kultur ToString(String, IFormatProvider)

Der Rückgabewert kann , NegativeInfinitySymbol, NaNSymboloder eine Zeichenfolge der Form seinPositiveInfinitySymbol:

[sign]integral-digits[.[ Bruchstellen]][e[Zeichen]exponentielle Ziffern]

Optionale Elemente werden in eckigen Klammern ([ und ]) eingerahmt. Elemente, die den Begriff "Ziffern" enthalten, bestehen aus einer Reihe numerischer Zeichen im Bereich von 0 bis 9. In der folgenden Tabelle sind die einzelnen Elemente aufgeführt:

Element Beschreibung
sign Ein negatives oder positives Zeichensymbol.
Ganzzahlige Ziffern Eine Reihe von Ziffern, die den integralen Teil der Zahl angeben. Ganzzahlige Ziffern können fehlen, wenn Bruchstellen vorhanden sind.
'.' Ein kulturspezifisches Dezimaltrennzeichen.
Bruchstellen Eine Reihe von Ziffern, die den Bruchteil der Zahl angeben.
'e' Ein Kleinbuchstaben "e", das die exponentielle (wissenschaftliche) Notation angibt.
exponentielle Ziffern Eine Reihe von Ziffern, die einen Exponenten angeben.

Einige Beispiele für den Rückgabewert sind "100", "-123.456.789", "123.45e+6", "500", "3.1416", "600", "-0.123" und "-Infinity".

.NET bietet umfassende Formatierungsunterstützung, die in den folgenden Formatierungsthemen ausführlicher beschrieben wird:

Weitere Informationen

Gilt für:

ToString(IFormatProvider)

Quelle:
Single.cs
Quelle:
Single.cs
Quelle:
Single.cs

Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

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

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

Gibt zurück

Die Zeichenfolgendarstellung des Werts dieser Instanz entsprechend den Angaben von provider.

Implementiert

Beispiele

Im folgenden Beispiel wird die Zeichenfolgendarstellung von zwei Single Werten mithilfe CultureInfo von Objekten angezeigt, die mehrere verschiedene Kulturen darstellen.

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

Hinweise

Die ToString(IFormatProvider) -Methode formatiert einen Single Wert im Standardformat ("G" oder allgemein) einer angegebenen Kultur. Wenn Sie ein anderes Format oder die aktuelle Kultur angeben möchten, verwenden Sie die anderen Überladungen der ToString -Methode wie folgt:

So verwenden Sie das Format Für Kultur Verwenden der Überladung
Standardformat ("G") Standardkultur (aktuell) ToString()
Ein bestimmtes Format Standardkultur (aktuell) ToString(String)
Ein bestimmtes Format Eine bestimmte Kultur ToString(String, IFormatProvider)

Der Rückgabewert kann , NegativeInfinitySymbol, NaNSymboloder eine Zeichenfolge der Form seinPositiveInfinitySymbol:

[sign]integral-digits[.[ Bruchstellen]][e[Zeichen]exponentielle Ziffern]

Optionale Elemente werden in eckigen Klammern ([ und ]) eingerahmt. Elemente, die den Begriff "Ziffern" enthalten, bestehen aus einer Reihe von numerischen Zeichen im Bereich von 0 bis 9. In der folgenden Tabelle sind die einzelnen Elemente aufgeführt.

Element Beschreibung
Signieren Ein negatives oder positives Zeichensymbol.
Ganzzahlige Ziffern Eine Reihe von Ziffern, die den integralen Teil der Zahl angeben. Ganzzahlige Ziffern können fehlen, wenn Bruchstellen vorhanden sind.
'.' Ein kulturspezifisches Dezimaltrennzeichen.
Bruchstellen Eine Reihe von Ziffern, die den Bruchteil der Zahl angeben.
'e' Ein Kleinbuchstaben "e", das die exponentielle (wissenschaftliche) Notation angibt.
exponentielle Ziffern Eine Reihe von Ziffern, die einen Exponenten angeben.

Einige Beispiele für den Rückgabewert sind "100", "-123.456.789", "123.45e+6", "500", "3.1416", "600", "-0.123" und "-Infinity".

.NET bietet umfassende Formatierungsunterstützung, die in den folgenden Formatierungsthemen ausführlicher beschrieben wird:

Der provider Parameter ist eine IFormatProvider Implementierung, deren GetFormat Methode ein NumberFormatInfo -Objekt zurückgibt. provider In der Regel ist ein CultureInfo -Objekt oder ein NumberFormatInfo -Objekt. Der provider Parameter stellt kulturspezifische Informationen bereit, die bei der Formatierung verwendet werden. Wenn provider ist null, wird der Rückgabewert mithilfe der NumberFormatInfo Daten für die aktuelle Kultur formatiert.

Um einen Single Wert mithilfe einer angegebenen Kultur und einer bestimmten Formatzeichenfolge in seine Zeichenfolge zu konvertieren, rufen Sie die -Methode auf Single.ToString(String, IFormatProvider) .

Weitere Informationen

Gilt für:

ToString(String)

Quelle:
Single.cs
Quelle:
Single.cs
Quelle:
Single.cs

Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.

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

Parameter

format
String

Eine numerische Formatierungszeichenfolge.

Gibt zurück

Die Zeichenfolgendarstellung des Werts dieser Instanz entsprechend den Angaben von format.

Ausnahmen

format ist ungültig.

Beispiele

Im folgenden Beispiel wird ein numerischer Wert definiert und als Währungswert mithilfe der standardmäßigen numerischen Formatzeichenfolge "C" und als numerischer Wert an drei Dezimalstellen formatiert, indem die standardmäßige numerische Formatzeichenfolge "N" verwendet wird. Die Ergebniszeichenfolgen werden mithilfe der Konventionen der en-US-Kultur formatiert. Weitere Informationen zu numerischen Formatzeichenfolgen finden Sie unter Standardmäßige numerische Formatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.

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

Im folgenden Beispiel werden mehrere Single Werte mithilfe der unterstützten numerischen Standardformatbezeichner zusammen mit zwei benutzerdefinierten numerischen Formatzeichenfolgen angezeigt. Eine dieser benutzerdefinierten Formatzeichenfolgen veranschaulicht, wie sie einen Single Wert mit führenden Nullen auffüllen. Beim Konvertieren der numerischen Werte in Zeichenfolgen verwendet das Beispiel die Formatierungskonventionen der en-US-Kultur.

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

Hinweise

Die ToString(String) -Methode formatiert einen Single Wert in einem angegebenen Format unter Verwendung der Konventionen der aktuellen Kultur. Wenn Sie das Standardformat ("G" oder allgemein) verwenden oder eine andere Kultur angeben möchten, verwenden Sie die anderen Überladungen der ToString -Methode wie folgt:

So verwenden Sie das Format Für Kultur Verwenden der Überladung
Standardformat ("G") Standardkultur (aktuell) ToString()
Standardformat ("G") Eine bestimmte Kultur ToString(IFormatProvider)
Ein bestimmtes Format Eine bestimmte Kultur ToString(String, IFormatProvider)

Der Rückgabewert kann , NegativeInfinitySymbol, NaNSymboloder die Zeichenfolgendarstellung des Werts des aktuellen instance seinPositiveInfinitySymbol, wie durch formatangegeben.

Der format Parameter kann ein beliebiger gültiger numerischer Standardformatbezeichner mit Ausnahme von D und X sowie eine beliebige Kombination von benutzerdefinierten numerischen Formatbezeichnern sein. Wenn format oder eine leere Zeichenfolge ist null , wird der Rückgabewert mit dem allgemeinen numerischen Formatbezeichner ("G") formatiert.

.NET bietet umfassende Formatierungsunterstützung, die in den folgenden Formatierungsthemen ausführlicher beschrieben wird:

Standardmäßig enthält der Rückgabewert nur 7 Ziffern der Genauigkeit, obwohl maximal 9 Ziffern intern verwaltet werden. Wenn der Wert dieses instance größer als 7 Ziffern hat, ToString(String) wird oder NegativeInfinitySymbol anstelle der erwarteten Zahl zurückgegebenPositiveInfinitySymbol. Wenn Sie eine höhere Genauigkeit benötigen, geben Sie format mit der Formatspezifikation "G9" an, die immer 9 Ziffern der Genauigkeit zurückgibt, oder "R", das 7 Ziffern zurückgibt, wenn die Zahl mit dieser Genauigkeit dargestellt werden kann, oder 9 Ziffern, wenn die Zahl nur mit maximaler Genauigkeit dargestellt werden kann.

Weitere Informationen

Gilt für:

ToString(String, IFormatProvider)

Quelle:
Single.cs
Quelle:
Single.cs
Quelle:
Single.cs

Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

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

Parameter

format
String

Eine numerische Formatierungszeichenfolge.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

Gibt zurück

Die Zeichenfolgendarstellung des Werts dieser Instanz entsprechend den Angaben von format und provider.

Implementiert

Beispiele

Im folgenden Beispiel wird ein Single Wert mit jedem der unterstützten numerischen Standardformatbezeichner für verschiedene Kulturen angezeigt.

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 %

Hinweise

Die ToString(String, IFormatProvider) -Methode formatiert einen Single Wert in einem angegebenen Format einer angegebenen Kultur. Wenn Sie die Standardformat- oder Kultureinstellungen verwenden möchten, verwenden Sie die anderen Überladungen der ToString -Methode wie folgt:

So verwenden Sie das Format Für Kultur Verwenden der Überladung
Standardformat ("G") Standardkultur (aktuell) ToString()
Standardformat ("G") Eine bestimmte Kultur ToString(IFormatProvider)
Ein bestimmtes Format Standardkultur (aktuell) ToString(String)

Der Rückgabewert kann , NegativeInfinitySymbol, NaNSymboloder die Zeichenfolgendarstellung des Werts des aktuellen instance seinPositiveInfinitySymbol, wie durch formatangegeben.

Der format Parameter kann ein beliebiger gültiger numerischer Standardformatbezeichner mit Ausnahme von D und X sowie eine beliebige Kombination von benutzerdefinierten numerischen Formatbezeichnern sein. Wenn format oder eine leere Zeichenfolge istnull, wird der Rückgabewert für diese instance mit dem allgemeinen numerischen Formatbezeichner ("G") formatiert.

.NET bietet umfassende Formatierungsunterstützung, die in den folgenden Formatierungsthemen ausführlicher beschrieben wird:

Der provider Parameter ist eine IFormatProvider Implementierung, deren GetFormat Methode ein NumberFormatInfo -Objekt zurückgibt. provider In der Regel ist ein CultureInfo -Objekt oder ein NumberFormatInfo -Objekt. Der provider Parameter stellt kulturspezifische Informationen bereit, die bei der Formatierung verwendet werden. Wenn provider ist null, wird der Rückgabewert mit dem NumberFormatInfo -Objekt für die aktuelle Kultur formatiert.

Standardmäßig enthält der Rückgabewert nur 7 Ziffern der Genauigkeit, obwohl maximal 9 Ziffern intern verwaltet werden. Wenn der Wert dieses instance größer als 7 Ziffern hat, ToString wird oder NegativeInfinitySymbol anstelle der erwarteten Zahl zurückgegebenPositiveInfinitySymbol. Wenn Sie eine höhere Genauigkeit benötigen, geben Sie format mit der Formatspezifikation "G9" an, die immer 9 Ziffern der Genauigkeit zurückgibt, oder "R", das 7 Ziffern zurückgibt, wenn die Zahl mit dieser Genauigkeit dargestellt werden kann, oder 9 Ziffern, wenn die Zahl nur mit maximaler Genauigkeit dargestellt werden kann.

Weitere Informationen

Gilt für: