Dela via

Numeriska standardformatsträngar

  • Artikel

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

    Anteckning

    Precisionsspecificeraren avgör antalet siffror i resultatsträngen. Om du vill fylla en resultatsträng med inledande eller avslutande blanksteg använder du funktionen för sammansatt formatering och definierar en justeringskomponent 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 genereras 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 deras användning.

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 alla 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.

Formatspecificerare Name 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: Formatspecificeraren valuta ("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: Formatspecificeraren decimal("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: General ("G") Format Specifier.		 -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" Tal 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: Formatspecificeraren för numeriskt ("N").		 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 turas om 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 för rundresa ("R").		 123456789.12345678 ("R")
-> 123456789.12345678

-1234567890.12345678 ("R")
-> -1234567890.1234567
"X" eller "x" Hexadecimala 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 enkla tecken Okänd specificerare Resultat: Kastar en FormatException vid körning.

Använda numeriska standardformatsträngar

Anteckning

C#-exemplen i den här artikeln körs i Try.NET inline code runner och playground. 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 från 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 kulturen en-US).

    Decimal value = static_cast<Decimal>(123.456);
Console::WriteLine(value.ToString("C2"));
// Displays $123.46

    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 = static_cast<Decimal>(123.456);
Console::WriteLine("Your account balance is {0:C2}.", value);
// Displays "Your account balance is $123.46."

    decimal value = 123.456m;
Console.WriteLine("Your account balance is {0:C2}.", value);
// 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 på 28 tecken och högerjusterar ett valutavärde i ett fält med 14 tecken.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                            static_cast<Decimal>(18794.16) };
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      

    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)

Den binära formatspecificeraren ("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. Vid behov är talet vadderat med nollor till vänster för att producera 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 standardmässiga antalet decimaler avrundas bråkvärdet i resultatsträngen. Om värdet till höger om antalet angivna decimaler är 5 eller högre 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 av den returnerade strängen.

Egenskapen NumberFormatInfo Beskrivning
CurrencyPositivePattern Definierar valutasymbolens placering för positiva värden.
CurrencyNegativePattern Definierar valutasymbolens placering 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 decimaler i ett valutavärde. Det här värdet kan åsidosättas med hjälp av precisionsspecificeraren.
CurrencyDecimalSeparator Definierar strängen som separerar heltals- och decimalsiffror.
CurrencyGroupSeparator Definierar strängen som separerar grupper av 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
//       kr 12.345,679

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), föregås av 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. Vid behov är talet vadderat med nollor till vänster för att producera antalet siffror som anges av precisionsspecificeraren. Om ingen precisionsspecificerare anges är standardvärdet det minsta värde som krävs för att representera heltal 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.

Egenskapen NumberFormatInfo 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

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)

Den exponentiella formatspecificeraren ("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 önskat antal siffror efter decimaltecknet. Om precisionsspecificeraren utelämnas används standardvärdet sex siffror efter decimaltecknet.

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 av den returnerade strängen.

Egenskapen NumberFormatInfo 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

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 ger 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.

Egenskapen NumberFormatInfo Beskrivning
NegativeSign Definierar strängen som anger att ett tal är negativt.
NumberDecimalSeparator Definierar strängen som skiljer heltalssiffror från decimaler.
NumberDecimalDigits Definierar standardantalet decimaler. 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 formatspecificeraren för fast punkt:

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                        

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)

Den allmänna formatspecificeraren ("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, enligt följande tabell.

Numerisk typ Standardprecision
Byte eller SByte Tre 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-trippbara antal siffror som representerar 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-trippbara antal siffror som representerar 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 ett Decimal och precisionsspecificeraren utelämnas används alltid notation med fast punkt och avslutande nollor bevaras.

Om vetenskaplig notation används föregås exponenten i resultatet av "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 lyckas med tur och retur. Detta beror på att Double är ett IEEE 754-2008-kompatibelt flyttal med dubbel precision (binary64) som ger upp till 17 signifikanta precisionssiffror. På .NET Framework rekommenderar vi dess användning i stället för "R"-formatspecificeraren, eftersom "R" i vissa fall inte lyckas flytta flyttal 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 flyttal med enkel precision (binary32) som ger upp till nio signifikanta precisionssiffror. Av prestandaskäl rekommenderar vi dess användning 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.

Egenskapen NumberFormatInfo Beskrivning
NegativeSign Definierar strängen som anger att ett tal är negativt.
NumberDecimalSeparator Definierar strängen som separerar heltalssiffror från decimalsiffror.
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    

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)

Den numeriska formatspecificeraren ("N") konverterar ett tal till en sträng i formatet "-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 decimaltecken. 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.

Egenskapen NumberFormatInfo 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 heltal som visas mellan gruppavgränsare.
NumberGroupSeparator Definierar strängen som avgränsar grupper med heltal.
NumberDecimalSeparator Definierar strängen som separerar heltals- 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 

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)

Procentformatsspecificeraren 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 av den returnerade strängen.

Egenskapen NumberFormatInfo 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 heltals- och decimalsiffror.
PercentGroupSeparator Definierar strängen som avgränsar 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 %

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 ("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 tidigare än 3.0 misslyckas R-formatspecificeraren i vissa fall med tur och retur-värdenDouble. 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 värden och formatspecificeraren "G9" för Double att kunna avrunda Single värdena.

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

Även om du kan inkludera en precisionsspecificerare ignoreras den. Tur och retur prioriteras 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.

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

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

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

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



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 för numeriskt format inte avrundas om de /platform:x64 kompileras med hjälp av switcharna eller /platform:anycpu och körs på 64-bitarssystem. Mer information finns i följande stycke.

Om du vill undvika problemet med värden som är formaterade med "R"-standardsträngen i numeriskt format som inte kan avrundas om de kompileras med hjälp av Double/platform:x64 switcharna eller /platform:anycpu och körs på 64-bitarssystem, kan du formatera Double värden med hjälp av standardsträngen för numeriskt format "G17". I följande exempel används formatsträngen "R" med ett Double värde som inte kan avrundas utan fel, och även formatsträngen "G17" används 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("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

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("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// 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)

Hexadecimalformatsspecificeraren ("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 skapa "ABCDEF" och "x" för att producera "abcdef". Det här formatet stöds endast för helta typer.

Precisionsspecificeraren anger det minsta antalet siffror som önskas i den resulterande strängen. Om det behövs fylls talet ut 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

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

Kommentarer

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

Kontrollpanelen inställningar

Inställningarna i objektet Nationella alternativ och Språkalternativ i Kontrollpanelen påverka 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 upprättas av objektet Regionala alternativ och Språkalternativ i 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 den parametern.

Anteckning

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 flyttalspunkter

Vissa beskrivningar av numeriska standardformatsspecificerare refererar till numeriska typer av integraler eller flyttalspunkter. De integrala 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 PositiveInfinitySymbol, NegativeInfinitySymboleller NaNSymbol egenskap som anges av det aktuella objektetNumberFormatInfo.DoubleSingleHalf

Kodexempel

I följande exempel formateras en integral och ett numeriskt flyttalsvärde med hjälp av en-US-kulturen 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, UInt16Int64, UInt32, 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: {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
int integral = 8395;
Console.WriteLine("C: {0}",
        integral.ToString("C", ci));           // Displays "C: $8,395.00"
Console.WriteLine("D: {0}",
        integral.ToString("D6", ci));          // 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.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}",
        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