Dela via

Numeriska standardformatsträngar

Standardsträngar i numeriskt format används för att formatera vanliga numeriska typer. En numerisk standardformatsträng har formatet [format specifier][precision specifier], där:

  • Formatspecificeraren är ett enda alfabetiskt tecken som anger typ av talformat, till exempel valuta eller procent. Alla numeriska formatsträngar som innehåller mer än ett alfabetiskt tecken, inklusive blanksteg, tolkas som en anpassad numerisk formatsträng. Mer information finns i Anpassade numeriska formatsträngar.

  • Precisionsspecificerare är ett valfritt heltal som påverkar antalet siffror i den resulterande strängen. I .NET 7 och senare versioner är det maximala precisionsvärdet 999 999 999. I .NET 6 är Int32.MaxValuedet maximala precisionsvärdet . I tidigare .NET-versioner kan precisionen variera från 0 till 99. Precisionsspecificeraren styr antalet siffror i strängrepresentationen av ett tal. Det avrundar inte själva talet. Om du vill utföra en avrundningsåtgärd använder du Math.Ceilingmetoden , Math.Flooreller Math.Round .

    När precisionsspecificeraren styr antalet bråksiffror i resultatsträngen återspeglar resultatsträngen ett tal som avrundas till ett representerande resultat närmast det oändligt exakta resultatet. Om det finns två lika nära representerande resultat:

    • På .NET Framework och .NET Core upp till .NET Core 2.0 väljer körningen resultatet med den minst signifikanta siffran (dvs. med ).MidpointRounding.AwayFromZero
    • På .NET Core 2.1 och senare väljer körningen resultatet med en ännu minst signifikant siffra (dvs. med ).MidpointRounding.ToEven

    Anmärkning

    Precisionsspecificeraren avgör antalet siffror i resultatsträngen. Om du vill fylla på en resultatsträng med inledande eller avslutande blanksteg använder du funktionen för sammansatt formatering och definierar en breddkomponent i formatobjektet.

Numeriska standardformatsträngar stöds av:

Tips

Du kan ladda ned formateringsverktyget, ett .NET Core Windows Forms-program som gör att du kan använda formatsträngar för numeriska värden eller datum- och tidsvärden och visa resultatsträngen. Källkoden är tillgänglig för C# och Visual Basic.

Standardformatsspecificerare

I följande tabell beskrivs de numeriska standardformatsspecificerarna och exempelutdata som produceras av varje formatspecificerare. Mer information om hur du använder numeriska standardformatsträngar finns i avsnittet Anteckningar och avsnittet Kodexempel för en omfattande bild av hur de används.

Resultatet av en formaterad sträng för en viss kultur kan skilja sig från följande exempel. Operativsysteminställningar, användarinställningar, miljövariabler och den .NET-version som du använder kan påverka formatet. Till exempel försöker .NET, från och med .NET 5, att förena kulturella format mellan plattformar. Mer information finns i .NET-globalisering och ICU.

Formatsspecifikator Namn Beskrivning Exempel
"B" eller "b" Binär Resultat: En binär sträng.

Stöds av: Endast integraltyper (.NET 8+).

Precisionsspecificerare: Antal siffror i resultatsträngen.

Mer information: Den binära ("B") formatspecificeraren.		 42 ("B")
-> 101010

255 ("B16")
-> 0000000011111111
"C" eller "c" Valuta Resultat: Ett valutavärde.

Stöds av: Alla numeriska typer.

Precisionsspecificerare: Antal decimalsiffror.

Standardprecisionsspecificerare: Definierad av NumberFormatInfo.CurrencyDecimalDigits.

Mer information: Valutaformatsspecificeraren ("C").		 123.456 ("C", en-US)
-> \$123.46

123,456 ("C", fr-FR)
-> 123,46 €

123.456 ("C", ja-JP)
-> ¥123

-123.456 ("C3", en-US)
-> (\$123.456)

-123.456 ("C3", fr-FR)
-> -123,456 €

-123.456 ("C3", ja-JP)
-> -¥123.456
"D" eller "d" Decimal Resultat: Heltalssiffror med valfritt negativt tecken.

Stöds av: Endast integraltyper.

Precisionsspecificerare: Minsta antal siffror.

Standardprecisionsspecificerare: Minsta antal siffror som krävs.

Mer information: Decimalformatsspecificeraren("D").		 1234 ("D")
-> 1234

-1234 ("D6")
-> 001234
"E" eller "e" Exponentiell (vetenskaplig) Resultat: Exponentiell notation.

Stöds av: Alla numeriska typer.

Precisionsspecificerare: Antal decimalsiffror.

Standardprecisionsspecificerare: 6.

Mer information: Exponentiell ("E") formatspecificerare.		 1052.0329112756 ("E", en-US)
-> 1.052033E+003

1052.0329112756 ("e", fr-FR)
-> 1 052033e+003

-1052.0329112756 ("E2", en-US)
-> -1.05e+003

-1052.0329112756 ("E2", fr-FR)
-> -1,05E+003
"F" eller "f" Fast punkt Resultat: Integral- och decimalsiffror med valfritt negativt tecken.

Stöds av: Alla numeriska typer.

Precisionsspecificerare: Antal decimalsiffror.

Standardprecisionsspecificerare: Definierad av NumberFormatInfo.NumberDecimalDigits.

Mer information: Formatspecificeraren för Fixed-Point ("F").		 1234.567 ("F", en-US)
-> 1234,57

1234,567 ("F", de-DE)
-> 1234,57

1234 ("F1", en-US)
-> 1234,0

1234 ("F1", de-DE)
-> 1234,0

-1234,56 ("F4", en-US)
-> -1234.5600

-1234,56 ("F4", de-DE)
-> -1234,5600
"G" eller "g" Allmänt Resultat: Den mer kompakta av antingen fast punkt eller vetenskaplig notation.

Stöds av: Alla numeriska typer.

Precisionsspecificerare: Antal signifikanta siffror.

Standardprecisionsspecificerare: Beror på numerisk typ.

Mer information: Formatspecificeraren allmänt ("G").		 -123.456 ("G", en-US)
-> -123.456

-123.456 ("G", sv-SE)
-> -123 456

123.4546 ("G4", en-US)
-> 123,5

123.4546 ("G4", sv-SE)
-> 123,5

-1.234567890e-25 ("G", en-US)
-> -1.23456789E-25

-1.234567890e-25 ("G", sv-SE)
-> -1,23456789E-25
"N" eller "n" Nummer Resultat: Integral- och decimalsiffror, gruppavgränsare och en decimalavgränsare med valfritt negativt tecken.

Stöds av: Alla numeriska typer.

Precisionsspecificerare: Önskat antal decimaler.

Standardprecisionsspecificerare: Definierad av NumberFormatInfo.NumberDecimalDigits.

Mer information: Den numeriska ("N") formatspecificeraren.		 1234,567 ("N", en-US)
-> 1 234,57

1234.567 ("N", ru-RU)
-> 1 234 57

1234 ("N1", en-US)
-> 1 234,0

1234 ("N1", ru-RU)
-> 1 234,0

-1234,56 ("N3", en-US)
-> -1 234,560

-1234,56 ("N3", ru-RU)
-> -1 234 560
"P" eller "p" Procent Resultat: Tal multiplicerat med 100 och visas med en procentsymbol.

Stöds av: Alla numeriska typer.

Precisionsspecificerare: Önskat antal decimaler.

Standardprecisionsspecificerare: Definierad av NumberFormatInfo.PercentDecimalDigits.

Mer information: Procentformatsspecificeraren ("P").		 1 ("P", en-US)
-> 100,00 %

1 ("P", fr-FR)
-> 100,00 %

-0,39678 ("P1", en-US)
-> -39,7 %

-0,39678 ("P1", fr-FR)
-> -39,7 %
"R" eller "r" Tur Resultat: En sträng som kan tur och retur till ett identiskt tal.

Stöds av: Single, Doubleoch BigInteger.

Obs! Rekommenderas endast för BigInteger typen. För Double typer använder du "G17"; för Single typer använder du "G9".
Precisionsspecificerare: Ignorerad.

Mer information: Formatspecificeraren round-trip ("R").		 123456789.12345678 ("R")
-> 123456789.12345678

-1234567890.12345678 ("R")
-> -1234567890.1234567
"X" eller "x" Hexadecimal Resultat: En hexadecimal sträng.

Stöds av: Endast integraltyper.

Precisionsspecificerare: Antal siffror i resultatsträngen.

Mer information: Hexadecimalt ("X") formatspecificerare.		 255 ("X")
-> FF

-1 ("x")
-> ff

255 ("x4")
-> 00ff

-1 ("X4")
-> 00FF
Alla andra enskilda tecken Okänd specificerare Resultat: Utlöser en FormatException vid körning.

Använda numeriska standardformatsträngar

Anmärkning

C#-exemplen i den här artikeln körs i Try.NET infogad kodlöpare och lekplats. Välj knappen Kör för att köra ett exempel i ett interaktivt fönster. När du har kört koden kan du ändra den och köra den ändrade koden genom att välja Kör igen. Den ändrade koden körs antingen i det interaktiva fönstret eller, om kompilering misslyckas, visar det interaktiva fönstret alla felmeddelanden för C#-kompilatorn.

En numerisk standardformatsträng kan användas för att definiera formateringen av ett numeriskt värde på något av följande sätt:

  • Den kan skickas till TryFormat metoden eller en överlagring av metoden ToString som har en format parameter. I följande exempel formateras ett numeriskt värde som en valutasträng i den aktuella kulturen (i det här fallet en-US kultur).

    decimal value = 123.456m;
Console.WriteLine(value.ToString("C2"));
// Displays $123.46

    Dim value As Decimal = 123.456d
Console.WriteLine(value.ToString("C2"))
' Displays $123.46

  • Det kan anges som formatString argumentet i ett formatobjekt som används med metoder som String.Format, Console.WriteLineoch StringBuilder.AppendFormat. Mer information finns i Sammansatt formatering. I följande exempel används ett formatobjekt för att infoga ett valutavärde i en sträng.

    decimal value = 123.456m;
Console.WriteLine($"Your account balance is {value:C2}.");
// Displays "Your account balance is $123.46."

    Dim value As Decimal = 123.456d
Console.WriteLine("Your account balance is {0:C2}.", value)
' Displays "Your account balance is $123.46."

    Du kan också ange ett alignment argument för att ange bredden på det numeriska fältet och om dess värde är höger- eller vänsterjusterat. I följande exempel vänsterjusterar ett valutavärde i ett fält med 28 tecken och högerjusterar ett valutavärde i ett fält med 14 tecken.

    decimal[] amounts = { 16305.32m, 18794.16m };
Console.WriteLine("   Beginning Balance           Ending Balance");
Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
// Displays:
//        Beginning Balance           Ending Balance
//        $16,305.32                      $18,794.16

    Dim amounts() As Decimal = {16305.32d, 18794.16d}
Console.WriteLine("   Beginning Balance           Ending Balance")
Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
' Displays:
'        Beginning Balance           Ending Balance
'        $16,305.32                      $18,794.16

  • Den kan anges som formatString argument i ett interpolerat uttrycksobjekt i en interpolerad sträng. Mer information finns i artikeln Stränginterpolation i C#-referensen eller artikeln Interpolerade strängar i Visual Basic-referensen.

Följande avsnitt innehåller detaljerad information om var och en av de numeriska standardformatsträngarna.

Binär formatspecificerare (B)

Formatspecificeraren för binärt ("B") konverterar ett tal till en sträng med binära siffror. Det här formatet stöds endast för integraltyper och endast på .NET 8+.

Precisionsspecificeraren anger det minsta antalet siffror som önskas i den resulterande strängen. Om det behövs, vadderas talet med nollor till vänster för att generera antalet siffror som anges av precisionsspecificeraren.

Resultatsträngen påverkas inte av formateringsinformationen för det aktuella NumberFormatInfo objektet.

Valutaformatsspecificerare (C)

Formatspecificeraren "C" (eller valuta) konverterar ett tal till en sträng som representerar ett valutabelopp. Precisionsspecificeraren anger önskat antal decimaler i resultatsträngen. Om precisionsspecificeraren utelämnas definieras standardprecisionen NumberFormatInfo.CurrencyDecimalDigits av egenskapen.

Om värdet som ska formateras har fler än det angivna eller standardantalet decimaler avrundas bråkvärdet i resultatsträngen. Om värdet till höger om antalet angivna decimaler är 5 eller större avrundas den sista siffran i resultatsträngen bort från noll.

Resultatsträngen påverkas av formateringsinformationen för det aktuella NumberFormatInfo objektet. I följande tabell visas de NumberFormatInfo egenskaper som styr formateringen för den returnerade strängen.

NumberFormatInfo-egenskap Beskrivning
CurrencyPositivePattern Definierar placeringen av valutasymbolen för positiva värden.
CurrencyNegativePattern Definierar placeringen av valutasymbolen för negativa värden och anger om det negativa tecknet representeras av parenteser eller NegativeSign egenskapen.
NegativeSign Definierar det negativa tecken som används om CurrencyNegativePattern anger att parenteser inte används.
CurrencySymbol Definierar valutasymbolen.
CurrencyDecimalDigits Definierar standardantalet decimalsiffror i ett valutavärde. Det här värdet kan åsidosättas med hjälp av precisionsspecificeraren.
CurrencyDecimalSeparator Definierar strängen som separerar integral- och decimalsiffror.
CurrencyGroupSeparator Definierar strängen som separerar grupper med heltal.
CurrencyGroupSizes Definierar antalet heltalssiffror som visas i en grupp.

I följande exempel formateras ett Double värde med valutaformatsspecificeraren:

double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3",
                  CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       12.345,679 kr

Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
'       $12,345.68
'       $12,345.679
'       kr 12.345,679

Decimalformatsspecificerare (D)

Formatspecificeraren "D" (eller decimal) konverterar ett tal till en sträng med decimalsiffror (0–9), prefixet med ett minustecken om talet är negativt. Det här formatet stöds endast för integraltyper.

Precisionsspecificeraren anger det minsta antalet siffror som önskas i den resulterande strängen. Om det behövs, vadderas talet med nollor till vänster för att generera antalet siffror som anges av precisionsspecificeraren. Om ingen precisionsspecificerare anges är standardvärdet det minsta värde som krävs för att representera heltalet utan inledande nollor.

Resultatsträngen påverkas av formateringsinformationen för det aktuella NumberFormatInfo objektet. Som följande tabell visar påverkar en enskild egenskap formateringen av resultatsträngen.

NumberFormatInfo-egenskap Beskrivning
NegativeSign Definierar strängen som anger att ett tal är negativt.

I följande exempel formateras ett Int32 värde med decimalformatsspecificeraren.

int value;

value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345

Dim value As Integer

value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345   
Console.WriteLine(value.ToString("D8"))
' Displays 00012345

value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345

Exponentiell formatspecificerare (E)

Exponentiellt format ("E") konverterar ett tal till en sträng i formuläret "-d.ddd... E+ddd" eller "-d.ddd... e+ddd", där varje "d" anger en siffra (0–9). Strängen börjar med ett minustecken om talet är negativt. Exakt en siffra föregår alltid decimaltecknet.

Precisionsspecificeraren anger det önskade antalet siffror efter decimaltecknet. Om precisionsspecificeraren utelämnas är standardvärdet sex siffror efter att decimaltecknet har använts.

Fallet med formatspecificeraren anger om exponenten ska prefixas med "E" eller "e". Exponenten består alltid av ett plus- eller minustecken och minst tre siffror. Exponenten är vadderad med nollor för att uppfylla detta minimum, om det behövs.

Resultatsträngen påverkas av formateringsinformationen för det aktuella NumberFormatInfo objektet. I följande tabell visas de NumberFormatInfo egenskaper som styr formateringen för den returnerade strängen.

NumberFormatInfo-egenskap Beskrivning
NegativeSign Definierar strängen som anger att ett tal är negativt för både koefficienten och exponenten.
NumberDecimalSeparator Definierar strängen som skiljer integralsiffran från decimaltal i koefficienten.
PositiveSign Definierar strängen som anger att en exponent är positiv.

I följande exempel formateras ett Double värde med exponentiell formatspecificerare:

double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004

Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004

Console.WriteLine(value.ToString("E", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004

Formatspecificerare med fast punkt (F)

Formatspecificeraren för fast punkt ("F") konverterar ett tal till en sträng i formuläret "-ddd.ddd..." där varje "d" anger en siffra (0–9). Strängen börjar med ett minustecken om talet är negativt.

Precisionsspecificeraren anger önskat antal decimaler. Om precisionsspecificeraren utelämnas tillhandahåller den aktuella NumberFormatInfo.NumberDecimalDigits egenskapen den numeriska precisionen.

Resultatsträngen påverkas av formateringsinformationen för det aktuella NumberFormatInfo objektet. I följande tabell visas egenskaperna för objektet NumberFormatInfo som styr formateringen av resultatsträngen.

NumberFormatInfo-egenskap Beskrivning
NegativeSign Definierar strängen som anger att ett tal är negativt.
NumberDecimalSeparator Definierar strängen som separerar heltalssiffror från decimaltal.
NumberDecimalDigits Definierar standardantalet decimalsiffror. Det här värdet kan åsidosättas med hjälp av precisionsspecificeraren.

I följande exempel formateras ett Double och ett Int32 värde med fast punktformatsspecificeraren:

int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F",
                  CultureInfo.InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3",
                  CultureInfo.InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));
// Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199

Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000

Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934

doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))
' Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199

Allmän formatspecificerare (G)

Det allmänna formatet ("G") konverterar ett tal till den mer kompakta av antingen fast punkt eller vetenskaplig notation, beroende på typen av tal och om en precisionsspecificerare finns. Precisionsspecificeraren definierar det maximala antalet signifikanta siffror som kan visas i resultatsträngen. Om precisionsspecificeraren utelämnas eller noll, avgör typen av talet standardprecisionen, som anges i följande tabell.

Numerisk typ Standardprecision
Byte eller SByte 3 siffror
Int16 eller UInt16 5 siffror
Int32 eller UInt32 10 siffror
Int64 19 siffror
UInt64 20 siffror
BigInteger Obegränsat (samma som "R")
Half Minsta rund-trippable antal siffror för att representera talet
Single Minsta rund-trippable antal siffror som representerar talet (i .NET Framework är G7 standard)
Double Minsta rund-trippable antal siffror som representerar talet (i .NET Framework är G15 standard)
Decimal Minsta rund-trippable antal siffror för att representera talet

Notation med fast punkt används om exponenten som skulle bli resultatet av att uttrycka talet i vetenskaplig notation är större än -5 och mindre än precisionsspecificeraren. annars används vetenskaplig notation. Resultatet innehåller en decimalpunkt om det behövs och avslutande nollor efter att decimaltecknet utelämnats. Om precisionsspecificeraren finns och antalet signifikanta siffror i resultatet överskrider den angivna precisionen tas de avslutande siffrorna bort genom avrundning.

Men om talet är en Decimal och precisionsspecificeraren utelämnas används alltid notation med fast punkt och avslutande nollor bevaras.

Om vetenskaplig notation används prefixet exponenten i resultatet med "E" om formatspecificeraren är "G" eller "e" om formatspecificeraren är "g". Exponenten innehåller minst två siffror. Detta skiljer sig från formatet för vetenskaplig notation som produceras av exponentformatsspecificeraren, som innehåller minst tre siffror i exponenten.

När det används med ett Double värde säkerställer formatspecificeraren "G17" att det ursprungliga Double värdet har rundresor. Detta beror på att Double är ett IEEE 754-2008-kompatibelt dubbelprecisionsnummer (binary64) flyttal som ger upp till 17 signifikanta siffror med precision. I .NET Framework rekommenderar vi att det används i stället för R-formatspecificeraren, eftersom I vissa fall misslyckas "R" med dubbel precision.

När det används med ett Single värde säkerställer formatspecificeraren "G9" att det ursprungliga Single värdet lyckas med tur och retur. Detta beror på att Single är ett IEEE 754-2008-kompatibelt flyttalsnummer med enkel precision (binary32) som ger upp till nio signifikanta precisionssiffror. Av prestandaskäl rekommenderar vi att det används i stället för R-formatspecificeraren.

Resultatsträngen påverkas av formateringsinformationen för det aktuella NumberFormatInfo objektet. I följande tabell visas de NumberFormatInfo egenskaper som styr formateringen av resultatsträngen.

NumberFormatInfo-egenskap Beskrivning
NegativeSign Definierar strängen som anger att ett tal är negativt.
NumberDecimalSeparator Definierar strängen som separerar heltalssiffror från decimaltal.
PositiveSign Definierar strängen som anger att en exponent är positiv.

I följande exempel formateras olika flyttalsvärden med den allmänna formatspecificeraren:

double number;

number = 12345.6789;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416

Dim number As Double

number = 12345.6789
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays  12345.6789
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture))
' Displays 12345.68 

number = .0000023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 2.3E-06       
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 2,3E-06

number = .0023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 0.0023

number = 1234
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture))
' Displays 1.2E+03

number = Math.Pi
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture))
' Displays 3.1416

Numerisk formatspecificerare (N)

Det numeriska formatet ("N") konverterar ett tal till en sträng i formuläret "-d,ddd,ddd.ddd...", där "-" anger en negativ talsymbol om det behövs, "d" anger en siffra (0-9), "," anger en gruppavgränsare och "." anger en decimalpunktssymbol. Precisionsspecificeraren anger det önskade antalet siffror efter decimaltecknet. Om precisionsspecificeraren utelämnas definieras antalet decimaler av den aktuella NumberFormatInfo.NumberDecimalDigits egenskapen.

Resultatsträngen påverkas av formateringsinformationen för det aktuella NumberFormatInfo objektet. I följande tabell visas de NumberFormatInfo egenskaper som styr formateringen av resultatsträngen.

NumberFormatInfo-egenskap Beskrivning
NegativeSign Definierar strängen som anger att ett tal är negativt.
NumberNegativePattern Definierar formatet för negativa värden och anger om det negativa tecknet representeras av parenteser eller NegativeSign egenskapen.
NumberGroupSizes Definierar antalet heltalssiffror som visas mellan gruppavgränsare.
NumberGroupSeparator Definierar strängen som separerar grupper med heltal.
NumberDecimalSeparator Definierar strängen som separerar integral- och decimalsiffror.
NumberDecimalDigits Definierar standardantalet decimalsiffror. Det här värdet kan åsidosättas med hjälp av en precisionsspecificerare.

I följande exempel formateras olika flyttalsvärden med talformatsspecificeraren:

double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1",
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0

Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0

Procentformatsspecificerare (P)

Formatspecificeraren percent ("P") multiplicerar ett tal med 100 och konverterar det till en sträng som representerar en procentandel. Precisionsspecificeraren anger önskat antal decimaler. Om precisionsspecificeraren utelämnas används den numeriska standardprecision som tillhandahålls av den aktuella PercentDecimalDigits egenskapen.

I följande tabell visas de NumberFormatInfo egenskaper som styr formateringen för den returnerade strängen.

NumberFormatInfo-egenskap Beskrivning
PercentPositivePattern Definierar placeringen av procentsymbolen för positiva värden.
PercentNegativePattern Definierar placeringen av procentsymbolen och den negativa symbolen för negativa värden.
NegativeSign Definierar strängen som anger att ett tal är negativt.
PercentSymbol Definierar procentsymbolen.
PercentDecimalDigits Definierar standardantalet decimalsiffror i ett procentvärde. Det här värdet kan åsidosättas med hjälp av precisionsspecificeraren.
PercentDecimalSeparator Definierar strängen som separerar integral- och decimalsiffror.
PercentGroupSeparator Definierar strängen som separerar grupper med heltal.
PercentGroupSizes Definierar antalet heltalssiffror som visas i en grupp.

I följande exempel formateras flyttalsvärden med procentformatsspecificeraren:

double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P",
                  CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %

Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
                  CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %

Formatspecificerare för tur och retur (R)

Formatspecificeraren för rundresa ("R") försöker se till att ett numeriskt värde som konverteras till en sträng parsas tillbaka till samma numeriska värde. Det här formatet stöds endast för typerna Half, Single, Doubleoch BigInteger .

I .NET Framework och i .NET Core-versioner som är tidigare än 3.0 misslyckas R-formatspecificeraren i vissa fall att runda av Double värden. För både Double och Single -värden ger "R"-formatspecificeraren relativt dåliga prestanda. I stället rekommenderar vi att du använder formatspecificeraren "G17" för Double värden och "G9" -formatsspecificeraren för att slutföra tur och retur-värden Single .

När ett BigInteger värde formateras med den här specificeraren innehåller dess strängrepresentation alla viktiga siffror i BigInteger värdet.

Även om du kan inkludera en precisionsspecificerare ignoreras den. Tur och retur ges företräde framför precision när du använder den här specificeraren. Resultatsträngen påverkas av formateringsinformationen för det aktuella NumberFormatInfo objektet. I följande tabell visas de NumberFormatInfo egenskaper som styr formateringen av resultatsträngen.

NumberFormatInfo-egenskap Beskrivning
NegativeSign Definierar strängen som anger att ett tal är negativt.
NumberDecimalSeparator Definierar strängen som separerar heltalssiffror från decimaltal.
PositiveSign Definierar strängen som anger att en exponent är positiv.

I följande exempel formateras ett BigInteger värde med returformatsspecificeraren.

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}
// The example displays the following output:
//      85070591730234615847396907784232501249

Imports System.Numerics

Module Example
    Public Sub Main()
        Dim value = BigInteger.Pow(Int64.MaxValue, 2)
        Console.WriteLine(value.ToString("R"))
    End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249

Viktigt!

I vissa fall Double kan värden som är formaterade med "R"-standardsträngen i numeriskt format inte köras tur och retur om de /platform:x64 kompileras med eller /platform:anycpu växlar och körs på 64-bitarssystem. Mer information finns i följande stycke.

Om du vill undvika problemet Double med värden som är formaterade med "R"-standardsträngen i numeriskt format som inte lyckas avrundas om de /platform:x64 kompileras med eller /platform:anycpu växlar och körs på 64-bitarssystem, kan du formatera Double värden med hjälp av standardsträngen för numeriskt format i G17. I följande exempel används formatsträngen "R" med ett Double värde som inte lyckas med tur och retur och använder även formatsträngen "G17" för att rundresa det ursprungliga värdet:

Console.WriteLine("Attempting to round-trip a Double with 'R':");
double initialValue = 0.6822871999174;
string valueString = initialValue.ToString("R",
                                           CultureInfo.InvariantCulture);
double roundTripped = double.Parse(valueString,
                                   CultureInfo.InvariantCulture);
Console.WriteLine($"{initialValue:R} = {roundTripped:R}: {initialValue.Equals(roundTripped)}\n");

Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
                                             CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
                                     CultureInfo.InvariantCulture);
Console.WriteLine($"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals(roundTripped17)}\n");
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       .NET Framework:
//       0.6822871999174 = 0.68228719991740006: False
//       .NET:
//       0.6822871999174 = 0.6822871999174: True
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True

Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("Attempting to round-trip a Double with 'R':")
        Dim initialValue As Double = 0.6822871999174
        Dim valueString As String = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture)
        Dim roundTripped As Double = Double.Parse(valueString,
                                                  CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped, initialValue.Equals(roundTripped))
        Console.WriteLine()

        Console.WriteLine("Attempting to round-trip a Double with 'G17':")
        Dim valueString17 As String = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture)
        Dim roundTripped17 As Double = double.Parse(valueString17,
                                              CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped17, initialValue.Equals(roundTripped17))
    End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
'       Attempting to round-trip a Double with 'R':
'       .NET Framework:
'       0.6822871999174 = 0.68228719991740006: False
'       .NET:
'       0.6822871999174 = 0.6822871999174: True
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Hexadecimal formatspecificerare (X)

Formatspecificeraren hexadecimalt ("X") konverterar ett tal till en sträng med hexadecimala siffror. Fallet med formatspecificeraren anger om versaler eller gemener ska användas för hexadecimala siffror som är större än 9. Använd till exempel "X" för att producera "ABCDEF" och "x" för att producera "abcdef". Det här formatet stöds endast för integraltyper.

Precisionsspecificeraren anger det minsta antalet siffror som önskas i den resulterande strängen. Om det behövs, vadderas talet med nollor till vänster för att generera antalet siffror som anges av precisionsspecificeraren.

Resultatsträngen påverkas inte av formateringsinformationen för det aktuella NumberFormatInfo objektet.

I följande exempel formateras värden med hexadecimal formatspecificeraren Int32 .

int value;

value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15

Dim value As Integer

value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E

value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15

Noteringar

Det här avsnittet innehåller ytterligare information om hur du använder numeriska standardformatsträngar.

Inställningar för Kontrollpanelen

Inställningarna i objektet Nationella alternativ och Språkalternativ på Kontrollpanelen påverkar resultatsträngen som skapas av en formateringsåtgärd. Dessa inställningar används för att initiera objektet NumberFormatInfo som är associerat med den aktuella kulturen, vilket ger värden som används för att styra formateringen. Datorer som använder olika inställningar genererar olika resultatsträngar.

Om CultureInfo(String) konstruktorn dessutom används för att instansiera ett nytt CultureInfo objekt som representerar samma kultur som den aktuella systemkulturen, tillämpas alla anpassningar som har upprättats av objektet Regionala alternativ och Språkalternativ på Kontrollpanelen på det nya CultureInfo objektet. Du kan använda CultureInfo(String, Boolean) konstruktorn för att skapa ett CultureInfo objekt som inte återspeglar ett systems anpassningar.

NumberFormatInfo-egenskaper

Formateringen påverkas av egenskaperna för det aktuella NumberFormatInfo objektet, som tillhandahålls implicit av den aktuella kulturen eller uttryckligen av parametern IFormatProvider för metoden som anropar formatering. Ange ett NumberFormatInfo eller CultureInfo -objekt för parametern.

Anmärkning

Information om hur du anpassar mönster eller strängar som används för att formatera numeriska värden finns i klassavsnittet NumberFormatInfo .

Numeriska typer av integraler och flyttalser

Vissa beskrivningar av numeriska standardformatsspecificerare refererar till numeriska typer av integraler eller flyttalstyper. De integrerade numeriska typerna är Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64och BigInteger. De numeriska flyttalstyperna är Decimal, Half, Singleoch Double.

Flyttalsinfiniteter och NaN

Oavsett formatsträngen, om värdet för en , eller flyttalstyp är positiv oändlighet, negativ oändlighet eller inte ett tal (NaN), är den formaterade strängen värdet för respektive Half, Singleeller Double egenskap som anges av det aktuella PositiveInfinitySymbol objektet.NegativeInfinitySymbolNaNSymbolNumberFormatInfo

Kodexempel

I följande exempel formateras en integral och ett numeriskt flyttalsvärde med hjälp av en-US kultur och alla numeriska standardformatsspecificerare. Det här exemplet använder två specifika numeriska typer (Double och Int32), men skulle ge liknande resultat för någon av de andra numeriska bastyperna (Byte, , SByteInt16, Int32, Int64, UInt16UInt32, , UInt64, BigInteger, Decimal, Halfoch Single).

// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");

// Output floating point values
double floating = 10761.937554;
Console.WriteLine($"C: {floating.ToString("C", ci)}");           // Displays "C: $10,761.94"
Console.WriteLine($"E: {floating.ToString("E03", ci)}");         // Displays "E: 1.076E+004"
Console.WriteLine($"F: {floating.ToString("F04", ci)}");         // Displays "F: 10761.9376"
Console.WriteLine($"G: {floating.ToString("G", ci)}");           // Displays "G: 10761.937554"
Console.WriteLine($"N: {floating.ToString("N03", ci)}");         // Displays "N: 10,761.938"
Console.WriteLine($"P: {(floating/10000).ToString("P02", ci)}"); // Displays "P: 107.62 %"
Console.WriteLine($"R: {floating.ToString("R", ci)}");           // Displays "R: 10761.937554"
Console.WriteLine();

// Output integral values
int integral = 8395;
Console.WriteLine($"C: {integral.ToString("C", ci)}");           // Displays "C: $8,395.00"
Console.WriteLine($"D: {integral.ToString("D6", ci)}");          // Displays "D: 008395"
Console.WriteLine($"E: {integral.ToString("E03", ci)}");         // Displays "E: 8.395E+003"
Console.WriteLine($"F: {integral.ToString("F01", ci)}");         // Displays "F: 8395.0"
Console.WriteLine($"G: {integral.ToString("G", ci)}");           // Displays "G: 8395"
Console.WriteLine($"N: {integral.ToString("N01", ci)}");         // Displays "N: 8,395.0"
Console.WriteLine($"P: {(integral/10000.0).ToString("P02", ci)}"); // Displays "P: 83.95 %"
Console.WriteLine($"X: 0x{integral.ToString("X", ci)}");           // Displays "X: 0x20CB"
Console.WriteLine();

Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
    Public Sub Main()
        ' Display string representations of numbers for en-us culture
        Dim ci As New CultureInfo("en-us")

        ' Output floating point values
        Dim floating As Double = 10761.937554
        Console.WriteLine("C: {0}", _
                floating.ToString("C", ci))           ' Displays "C: $10,761.94"
        Console.WriteLine("E: {0}", _
                floating.ToString("E03", ci))         ' Displays "E: 1.076E+004"
        Console.WriteLine("F: {0}", _
                floating.ToString("F04", ci))         ' Displays "F: 10761.9376"         
        Console.WriteLine("G: {0}", _
                floating.ToString("G", ci))           ' Displays "G: 10761.937554"
        Console.WriteLine("N: {0}", _
                floating.ToString("N03", ci))         ' Displays "N: 10,761.938"
        Console.WriteLine("P: {0}", _
                (floating / 10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
        Console.WriteLine("R: {0}", _
                floating.ToString("R", ci))           ' Displays "R: 10761.937554"            
        Console.WriteLine()

        ' Output integral values
        Dim integral As Integer = 8395
        Console.WriteLine("C: {0}", _
                integral.ToString("C", ci))           ' Displays "C: $8,395.00"
        Console.WriteLine("D: {0}", _
                integral.ToString("D6"))              ' Displays "D: 008395" 
        Console.WriteLine("E: {0}", _
                integral.ToString("E03", ci))         ' Displays "E: 8.395E+003"
        Console.WriteLine("F: {0}", _
                integral.ToString("F01", ci))         ' Displays "F: 8395.0"    
        Console.WriteLine("G: {0}", _
                integral.ToString("G", ci))           ' Displays "G: 8395"
        Console.WriteLine("N: {0}", _
                integral.ToString("N01", ci))         ' Displays "N: 8,395.0"
        Console.WriteLine("P: {0}", _
                (integral / 10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
        Console.WriteLine("X: 0x{0}", _
                integral.ToString("X", ci))           ' Displays "X: 0x20CB"
        Console.WriteLine()
    End Sub
End Module

Se även