Single.ToString Metod

Definition

Namnområde:: System

Sammansättningar:: mscorlib.dll, System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation.

Överlagringar

Name	Description
ToString(String, IFormatProvider)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet och den kulturspecifika formatinformationen.
ToString(String)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet.
ToString(IFormatProvider)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med den angivna kulturspecifika formatinformationen.
ToString()	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation.

ToString(String, IFormatProvider)

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet och den kulturspecifika formatinformationen.

public:
 virtual System::String ^ ToString(System::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

Parametrar

format: String

En numerisk formatsträng.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

Returer

String

Strängrepresentationen av värdet för den här instansen som anges av format och provider.

Implementeringar

ToString(String, IFormatProvider)

Exempel

I följande exempel visas ett värde med var och en Single av de standardnumreriska standardformatsspecificerarna för flera olika kulturer.

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 %

Kommentarer

Metoden ToString(String, IFormatProvider) formaterar ett Single värde i ett angivet format för en angiven kultur. Om du vill använda standardformat- eller kulturinställningar använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Standardformat ("G")	Standardkultur (aktuell)	ToString()
Standardformat ("G")	En specifik kultur	ToString(IFormatProvider)
Ett specifikt format	Standardkultur (aktuell)	ToString(String)

Returvärdet kan vara PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymboleller strängrepresentationen av värdet för den aktuella instansen, enligt vad som anges av format.

Parametern format kan vara valfritt giltigt numeriskt standardformatsspecificerare förutom D och X, samt valfri kombination av anpassade numeriska formatspecificerare. Om format är null eller en tom sträng formateras returvärdet för den här instansen med den allmänna numeriska formatspecificeraren ("G").

.NET ger omfattande formateringsstöd, vilket beskrivs mer detaljerat i följande formateringsämnen:

Mer information om numeriska formatspecificerare finns i Standard numeriska formatsträngar och anpassade numeriska formatsträngar.
Mer information om formatering finns i Formateringstyper.

Parametern provider är en IFormatProvider implementering vars GetFormat metod returnerar ett NumberFormatInfo objekt. provider Vanligtvis är ett CultureInfo objekt eller ett NumberFormatInfo objekt. Parametern provider tillhandahåller kulturspecifik information som används i formateringen. Om provider är nullformateras returvärdet med NumberFormatInfo objektet för den aktuella kulturen.

Som standard innehåller returvärdet endast 7 siffror med precision, men högst 9 siffror bibehålls internt. Om värdet för den här instansen har större än 7 siffror returnerar ToString PositiveInfinitySymbol eller NegativeInfinitySymbol i stället för det förväntade talet. Om du behöver mer precision anger format du med formatspecifikationen "G9", som alltid returnerar 9 siffror med precision, eller "R", som returnerar 7 siffror om talet kan representeras med den precisionen eller 9 siffror om talet bara kan representeras med maximal precision.

Se även

Gäller för

ToString(String)

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet.

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

public string ToString(string format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

Parametrar

format: String

En numerisk formatsträng.

Returer

String

Strängrepresentationen av värdet för den här instansen som anges av format.

Undantag

FormatException

format är ogiltigt.

Exempel

I följande exempel definieras ett numeriskt värde och det formateras som ett valutavärde med hjälp av standardsträngen "C" för numeriskt format och som ett numeriskt värde till tre decimaler med hjälp av standardsträngen för numeriskt format "N". Resultatsträngarna formateras med hjälp av konventionerna i en-US kultur. Mer information om numeriska formatsträngar finns i Standard numeriska formatsträngar och Anpassade numeriska formatsträngar.

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

I följande exempel visas flera Single värden med var och en av de standardnumreriska standardformatsspecificerarna tillsammans med två anpassade numeriska formatsträngar. En av dessa anpassade formatsträngar visar hur du fyller ett Single värde med inledande nollor. När du konverterar de numeriska värdena till strängar använder exemplet formateringskonventionerna i 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

Kommentarer

Metoden ToString(String) formaterar ett Single värde i ett angivet format med hjälp av konventionerna i den aktuella kulturen. Om du vill använda standardformatet ("G" eller allmänt) eller ange en annan kultur använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Standardformat ("G")	Standardkultur (aktuell)	ToString()
Standardformat ("G")	En specifik kultur	ToString(IFormatProvider)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

Returvärdet kan vara PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymboleller strängrepresentationen av värdet för den aktuella instansen, enligt vad som anges av format.

Parametern format kan vara valfritt giltigt numeriskt standardformatsspecificerare förutom D och X, samt valfri kombination av anpassade numeriska formatspecificerare. Om formatet är null eller en tom sträng formateras returvärdet med den allmänna numeriska formatspecificeraren ("G").

.NET ger omfattande formateringsstöd, vilket beskrivs mer detaljerat i följande formateringsämnen:

Mer information om numeriska formatspecificerare finns i Standard numeriska formatsträngar och anpassade numeriska formatsträngar.
Mer information om formatering finns i Formateringstyper.

Som standard innehåller returvärdet endast 7 siffror med precision, men högst 9 siffror bibehålls internt. Om värdet för den här instansen har större än 7 siffror returnerar ToString(String)PositiveInfinitySymbol eller NegativeInfinitySymbol i stället för det förväntade talet. Om du behöver mer precision anger format du med formatspecifikationen "G9", som alltid returnerar 9 siffror med precision, eller "R", som returnerar 7 siffror om talet kan representeras med den precisionen eller 9 siffror om talet bara kan representeras med maximal precision.

Se även

Gäller för

ToString(IFormatProvider)

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med den angivna kulturspecifika formatinformationen.

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

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

public string ToString(IFormatProvider provider);

override this.ToString : IFormatProvider -> string

Public Function ToString (provider As IFormatProvider) As String

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

Returer

String

Strängrepresentationen av värdet för den här instansen som anges av provider.

Implementeringar

ToString(IFormatProvider)

Exempel

I följande exempel visas strängrepresentationen av två Single värden med hjälp av CultureInfo objekt som representerar flera olika kulturer.

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

Kommentarer

Metoden ToString(IFormatProvider) formaterar ett Single värde i standardformatet ("G" eller allmänt) för en angiven kultur. Om du vill ange ett annat format eller den aktuella kulturen använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Standardformat ("G")	Standardkultur (aktuell)	ToString()
Ett specifikt format	Standardkultur (aktuell)	ToString(String)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

Returvärdet kan vara PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymboleller en sträng i formuläret:

[sign]integral-digits[.[ fractional-digits]][e[sign]exponential-digits]

Valfria element är inramade inom hakparenteser ([ och ]). Element som innehåller termen "siffror" består av en serie numeriska tecken från 0 till 9. I följande tabell visas varje element.

Element	Description
sign	Ett negativt tecken eller ett positivt tecken.
integral-digits	En serie siffror som anger den integrerade delen av talet. Integral-digits kan saknas om det finns bråktalssiffror.
'.'	Ett kulturspecifikt decimaltecken.
fractional-digits	En serie siffror som anger bråkdelen av talet.
"e"	Ett gemener som anger exponentiell (vetenskaplig) notation.
exponentiella siffror	En serie siffror som anger en exponent.

Några exempel på returvärdet är "100", "-123,456,789", "123.45e+6", "500", "3.1416", "600", "-0.123" och "-Infinity".

.NET ger omfattande formateringsstöd, vilket beskrivs mer detaljerat i följande formateringsämnen:

Mer information om numeriska formatspecificerare finns i Standard numeriska formatsträngar och anpassade numeriska formatsträngar.
Mer information om formatering finns i Formateringstyper.

Parametern provider är en IFormatProvider implementering vars GetFormat metod returnerar ett NumberFormatInfo objekt. provider Vanligtvis är ett CultureInfo objekt eller ett NumberFormatInfo objekt. Parametern provider tillhandahåller kulturspecifik information som används i formateringen. Om provider är nullformateras returvärdet med hjälp av NumberFormatInfo data för den aktuella kulturen.

Om du vill konvertera ett Single värde till dess strängrepresentation med hjälp av en angiven kultur och en specifik formatsträng anropar Single.ToString(String, IFormatProvider) du metoden.

Se även

Gäller för

ToString()

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation.

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

public override string ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Returer

String

Strängrepresentationen av värdet för den här instansen.

Exempel

I följande exempel används standardmetoden Single.ToString för att visa strängrepresentationer av ett antal Single värden.

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

I följande kodexempel visas hur metoden används Parse(String) tillsammans med ToString() metoden.

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

Kommentarer

Metoden ToString() formaterar ett Single värde i standardformatet ("G" eller allmänt) för den aktuella kulturen. Om du vill ange ett annat format eller en annan kultur använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Standardformat ("G")	En specifik kultur	ToString(IFormatProvider)
Ett specifikt format	Standardkultur (aktuell)	ToString(String)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

Returvärdet kan vara PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymboleller en sträng i formuläret:

[sign]integral-digits[.[ fractional-digits]][e[sign]exponential-digits]

Valfria element är inramade inom hakparenteser ([ och ]). Element som innehåller termen "siffror" består av en serie numeriska tecken från 0 till 9. I följande tabell visas varje element:

Element	Description
signera	Ett negativt tecken eller ett positivt tecken.
integral-digits	En serie siffror som anger den integrerade delen av talet. Integral-digits kan saknas om det finns bråktalssiffror.
'.'	Ett kulturspecifikt decimaltecken.
fractional-digits	En serie siffror som anger bråkdelen av talet.
"e"	Ett gemener som anger exponentiell (vetenskaplig) notation.
exponentiella siffror	En serie siffror som anger en exponent.

Några exempel på returvärdet är "100", "-123,456,789", "123.45e+6", "500", "3.1416", "600", "-0.123" och "-Infinity".

.NET ger omfattande formateringsstöd, vilket beskrivs mer detaljerat i följande formateringsämnen:

Mer information om numeriska formatspecificerare finns i Standard numeriska formatsträngar och anpassade numeriska formatsträngar.
Mer information om formatering finns i Formateringstyper.

Se även

Gäller för

Feedback

Var den här sidan till hjälp?