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
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:
Vissa överlagringar av metoden för
ToStringalla numeriska typer. Du kan till exempel ange en numerisk formatsträng till Int32.ToString(String) metoderna och Int32.ToString(String, IFormatProvider) .Metoden
TryFormatför alla numeriska typer, till exempel Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) och Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).Funktionen för sammansatt formatering i .NET, som används av vissa
Writemetoder ochWriteLinemetoder Console för klasserna och StreamWriter , String.Format metoden och StringBuilder.AppendFormat metoden. Med funktionen sammansatt format kan du inkludera strängrepresentationen av flera dataobjekt i en enda sträng, ange fältbredd och justera tal i ett fält. Mer information finns i Sammansatt formatering.Interpolerade strängar i C# och Visual Basic, som ger en förenklad syntax jämfört med sammansatta formatsträngar.
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
TryFormatmetoden eller en överlagring av metodenToStringsom har enformatparameter. 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.46decimal value = 123.456m; Console.WriteLine(value.ToString("C2")); // Displays $123.46Dim value As Decimal = 123.456d Console.WriteLine(value.ToString("C2")) ' Displays $123.46Det kan anges som
formatStringargumentet 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
alignmentargument 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.16decimal[] 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.16Dim 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.16Den kan anges som
formatStringargument 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':
// 0.6822871999174 = 0.68228719991740006: False
//
// 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':
' 0.6822871999174 = 0.68228719991740006: False
'
' 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
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för