Anpassade numeriska formatsträngar
Du kan skapa en anpassad numerisk formatsträng, som består av en eller flera anpassade numeriska specificerare, för att definiera hur numeriska data ska formateras. En anpassad numerisk formatsträng är en formatsträng som inte är en standardsträng i numeriskt format.
Anpassade numeriska formatsträngar stöds av vissa överlagringar av ToString metoden för alla numeriska typer. Du kan till exempel ange en numerisk formatsträng till ToString(String) metoderna och ToString(String, IFormatProvider) för Int32 typen. Anpassade numeriska formatsträngar stöds också av .NET-funktionen för sammansatt formatering, som används av vissa Write metoder och WriteLine metoder Console i klasserna ochStreamWriter, String.Format metoden och StringBuilder.AppendFormat metoden. Funktionen för stränginterpolering stöder även anpassade numeriska formatsträngar.
Dricks
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.
I följande tabell beskrivs de anpassade numeriska formatspecificerarna och exempelutdata som produceras av varje formatspecificerare. Mer information om hur du använder anpassade numeriska formatsträngar finns i avsnittet Anteckningar och avsnittet Exempel för en omfattande bild av hur de används.
| Formatspecificerare | Namn | Beskrivning | Exempel |
|---|---|---|---|
| "0" | Platshållare utan plats | Ersätter noll med motsvarande siffra om en finns. annars visas noll i resultatsträngen. Mer information: Den anpassade specificeraren "0". |
1234.5678 ("00000") -> 01235 0.45678 ("0.00", en-US) -> 0.46 0,45678 ("0,00", fr-FR) -> 0,46 |
| "#" | Platshållare för siffror | Ersätter symbolen "#" med motsvarande siffra om en finns. annars visas ingen siffra i resultatsträngen. Observera att ingen siffra visas i resultatsträngen om motsvarande siffra i indatasträngen är en icke-signifikant 0. Till exempel 0003 ("#####") -> 3. Mer information: Den anpassade "#"-specificeraren. |
1234.5678 ("#####") -> 1235 0.45678 ("#.##", en-US) –> .46 0.45678 ("#.##", fr-FR) -> ,46 |
| "." | Decimaltecknet | Avgör platsen för decimalavgränsaren i resultatsträngen. Mer information: "". Anpassad specificerare. |
0.45678 ("0.00", en-US) -> 0.46 0,45678 ("0,00", fr-FR) -> 0,46 |
| "," | Gruppavgränsare och nummerskalning | Fungerar som både en gruppavgränsare och en sifferskalningsspecificerare. Som gruppavgränsare infogar den ett lokaliserat gruppavgränsartecken mellan varje grupp. Som talskalningsspecificerare delar den upp ett tal med 1 000 för varje angivet kommatecken. Mer information: "," Anpassad specificerare. |
Gruppavgränsarespecificerare: 2147483647 ("##,#", en-US) –> 2 147 483 647 2147483647 ("##,#", es-ES) –> 2.147.483.647 Skalningsspecificerare: 2147483647 ("#,#,,", en-US) -> 2 147 2147483647 ("#,#,,", es-ES) -> 2.147 |
| "%" | Platshållare i procent | Multiplicerar ett tal med 100 och infogar en lokaliserad procentsymbol i resultatsträngen. Mer information: Den anpassade specificeraren %. |
0.3697 ("%#0.00", en-US) –> %36.97 0.3697 ("%#0.00", el-GR) -> %36,97 0.3697 ("##.0 %", en-US) –> 37,0 % 0.3697 ("##.0 %", el-GR) -> 37,0 % |
| "‰" | Platshållare per mille | Multiplicerar ett tal med 1 000 och infogar en lokaliserad symbol per mille i resultatsträngen. Mer information: Anpassad specificerare för "‰". |
0.03697 ("#0.00‰", en-US) -> 36.97‰ 0.03697 ("#0.00‰", ru-RU) -> 36,97‰ |
| "E0" "E+0" "E-0" "e0" "e+0" "e-0" |
Exponentiell notation | Om det följs av minst 0 (noll) formateras resultatet med exponentiell notation. Fallet "E" eller "e" anger fallet med exponentsymbolen i resultatsträngen. Antalet nollor efter tecknet "E" eller "e" avgör det minsta antalet siffror i exponenten. Ett plustecken (+) anger att ett teckentecken alltid föregår exponenten. Ett minustecken (-) anger att ett teckentecken endast föregår negativa exponenter. Mer information: Anpassade specificerare för "E" och "e". |
987654 ("#0.0e0") –> 98.8e4 1503.92311 ("0.0##e+00") -> 1.504e+03 1.8901385E-16 ("0.0e+00") -> 1.9e-16 |
| "\" | Escape-tecken | Gör att nästa tecken tolkas som en literal snarare än som en anpassad formatspecificerare. Mer information: Escape-tecknet "\". |
987654 ("\###00\#") –> #987654# |
| "sträng" "sträng" |
Literal sträng avgränsare | Anger att de omslutna tecknen ska kopieras till resultatsträngen oförändrade. Mer information: Teckenliteraler. |
68 ("# 'grader'") -> 68 grader 68 ("#' grader'") -> 68 grader |
| ; | Avsnittsavgränsare | Definierar avsnitt med separata formatsträngar för positiva, negativa och noll tal. Mer information: ";" Avsnittsavgränsare. |
12.345 ("#0.0#;( #0.0#);-\0-") -> 12.35 0 ("#0.0#;( #0.0#);-\0-") -> -0- -12.345 ("#0.0#;( #0.0#);-\0-") -> (12.35) 12.345 ("#0.0#;( #0.0#)") -> 12.35 0 ("#0.0#;( #0.0#)") –> 0.0 -12.345 ("#0.0#;( #0.0#)") -> (12.35) |
| Övrigt | Alla andra tecken | Tecknet kopieras till resultatsträngen oförändrad. Mer information: Teckenliteraler. |
68 ("# °") -> 68 ° |
Följande avsnitt innehåller detaljerad information om var och en av de anpassade numeriska formatspecificerarna.
Kommentar
Några av C#-exemplen i den här artikeln körs i Try.NET infogad kodlöpare och lekplats. Välj knappen Kör för att köra ett exempel i ett interaktivt fönster. När du har kört koden kan du ändra den och köra den ändrade koden genom att välja Kör igen. Den ändrade koden körs antingen i det interaktiva fönstret eller, om kompilering misslyckas, visar det interaktiva fönstret alla felmeddelanden för C#-kompilatorn.
Den anpassade specificeraren "0"
Den anpassade formatspecificeraren "0" fungerar som en nollplatshållare. Om värdet som formateras har en siffra i den position där noll visas i formatsträngen kopieras den siffran till resultatsträngen. annars visas en nolla i resultatsträngen. Positionen för den vänstra nollan före decimaltecknet och den högra nollan efter decimaltecknet avgör det intervall med siffror som alltid finns i resultatsträngen.
"00"-specificeraren gör att värdet avrundas till närmaste siffra före decimaltecknet, där avrundning bort från noll alltid används. Till exempel skulle formatering 34.5 med "00" resultera i värdet 35.
I följande exempel visas flera värden som formateras med hjälp av anpassade formatsträngar som innehåller noll platshållare.
double value;
value = 123;
Console::WriteLine(value.ToString("00000"));
Console::WriteLine(String::Format("{0:00000}", value));
// Displays 00123
value = 1.2;
Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.00}", value));
// Displays 1.20
Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:00.00}", value));
// Displays 01.20
CultureInfo^ daDK = CultureInfo::CreateSpecificCulture("da-DK");
Console::WriteLine(value.ToString("00.00", daDK));
Console::WriteLine(String::Format(daDK, "{0:00.00}", value));
// Displays 01,20
value = .56;
Console::WriteLine(value.ToString("0.0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.0}", value));
// Displays 0.6
value = 1234567890;
Console::WriteLine(value.ToString("0,0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0,0}", value));
// Displays 1,234,567,890
CultureInfo^ elGR = CultureInfo::CreateSpecificCulture("el-GR");
Console::WriteLine(value.ToString("0,0", elGR));
Console::WriteLine(String::Format(elGR, "{0:0,0}", value));
// Displays 1.234.567.890
value = 1234567890.123456;
Console::WriteLine(value.ToString("0,0.0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0,0.0}", value));
// Displays 1,234,567,890.1
value = 1234.567890;
Console::WriteLine(value.ToString("0,0.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0,0.00}", value));
// Displays 1,234.57
double value;
value = 123;
Console.WriteLine(value.ToString("00000"));
Console.WriteLine(String.Format("{0:00000}", value));
// Displays 00123
value = 1.2;
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.00}", value));
// Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:00.00}", value));
// Displays 01.20
CultureInfo daDK = CultureInfo.CreateSpecificCulture("da-DK");
Console.WriteLine(value.ToString("00.00", daDK));
Console.WriteLine(String.Format(daDK, "{0:00.00}", value));
// Displays 01,20
value = .56;
Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.0}", value));
// Displays 0.6
value = 1234567890;
Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0}", value));
// Displays 1,234,567,890
CultureInfo elGR = CultureInfo.CreateSpecificCulture("el-GR");
Console.WriteLine(value.ToString("0,0", elGR));
Console.WriteLine(String.Format(elGR, "{0:0,0}", value));
// Displays 1.234.567.890
value = 1234567890.123456;
Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0.0}", value));
// Displays 1,234,567,890.1
value = 1234.567890;
Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0.00}", value));
// Displays 1,234.57
Dim value As Double
value = 123
Console.WriteLine(value.ToString("00000"))
Console.WriteLine(String.Format("{0:00000}", value))
' Displays 00123
value = 1.2
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.00}", value))
' Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:00.00}", value))
' Displays 01.20
Dim daDK As CultureInfo = CultureInfo.CreateSpecificCulture("da-DK")
Console.WriteLine(value.ToString("00.00", daDK))
Console.WriteLine(String.Format(daDK, "{0:00.00}", value))
' Displays 01,20
value = .56
Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.0}", value))
' Displays 0.6
value = 1234567890
Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0}", value))
' Displays 1,234,567,890
Dim elGR As CultureInfo = CultureInfo.CreateSpecificCulture("el-GR")
Console.WriteLine(value.ToString("0,0", elGR))
Console.WriteLine(String.Format(elGR, "{0:0,0}", value))
' Displays 1.234.567.890
value = 1234567890.123456
Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0.0}", value))
' Displays 1,234,567,890.1
value = 1234.567890
Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0.00}", value))
' Displays 1,234.57
Den anpassade "#"-specificeraren
Den anpassade formatspecificeraren "#" fungerar som en sifferplatshållarsymbol. Om värdet som formateras har en siffra i den position där "#"-symbolen visas i formatsträngen kopieras den siffran till resultatsträngen. Annars lagras ingenting i den positionen i resultatsträngen.
Observera att den här specificeraren aldrig visar en nolla som inte är en signifikant siffra, även om noll är den enda siffran i strängen. Den visar endast noll om det är en betydande siffra i talet som visas.
Formatsträngen "##" gör att värdet avrundas till närmaste siffra före decimaltecknet, där avrundning bort från noll alltid används. Till exempel skulle formatering 34.5 med "##" resultera i värdet 35.
I följande exempel visas flera värden som formateras med hjälp av anpassade formatsträngar som innehåller platshållare för siffror.
double value;
value = 1.2;
Console::WriteLine(value.ToString("#.##", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#.##}", value));
// Displays 1.2
value = 123;
Console::WriteLine(value.ToString("#####"));
Console::WriteLine(String::Format("{0:#####}", value));
// Displays 123
value = 123456;
Console::WriteLine(value.ToString("[##-##-##]"));
Console::WriteLine(String::Format("{0:[##-##-##]}", value));
// Displays [12-34-56]
value = 1234567890;
Console::WriteLine(value.ToString("#"));
Console::WriteLine(String::Format("{0:#}", value));
// Displays 1234567890
Console::WriteLine(value.ToString("(###) ###-####"));
Console::WriteLine(String::Format("{0:(###) ###-####}", value));
// Displays (123) 456-7890
double value;
value = 1.2;
Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#.##}", value));
// Displays 1.2
value = 123;
Console.WriteLine(value.ToString("#####"));
Console.WriteLine(String.Format("{0:#####}", value));
// Displays 123
value = 123456;
Console.WriteLine(value.ToString("[##-##-##]"));
Console.WriteLine(String.Format("{0:[##-##-##]}", value));
// Displays [12-34-56]
value = 1234567890;
Console.WriteLine(value.ToString("#"));
Console.WriteLine(String.Format("{0:#}", value));
// Displays 1234567890
Console.WriteLine(value.ToString("(###) ###-####"));
Console.WriteLine(String.Format("{0:(###) ###-####}", value));
// Displays (123) 456-7890
Dim value As Double
value = 1.2
Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#.##}", value))
' Displays 1.2
value = 123
Console.WriteLine(value.ToString("#####"))
Console.WriteLine(String.Format("{0:#####}", value))
' Displays 123
value = 123456
Console.WriteLine(value.ToString("[##-##-##]"))
Console.WriteLine(String.Format("{0:[##-##-##]}", value))
' Displays [12-34-56]
value = 1234567890
Console.WriteLine(value.ToString("#"))
Console.WriteLine(String.Format("{0:#}", value))
' Displays 1234567890
Console.WriteLine(value.ToString("(###) ###-####"))
Console.WriteLine(String.Format("{0:(###) ###-####}", value))
' Displays (123) 456-7890
Om du vill returnera en resultatsträng där frånvarande siffror eller inledande nollor ersätts av blanksteg använder du funktionen sammansatt formatering och anger en fältbredd, vilket visas i följande exempel.
using namespace System;
void main()
{
Double value = .324;
Console::WriteLine("The value is: '{0,5:#.###}'", value);
}
// The example displays the following output if the current culture
// is en-US:
// The value is: ' .324'
using System;
public class SpaceOrDigit
{
public static void Main()
{
Double value = .324;
Console.WriteLine("The value is: '{0,5:#.###}'", value);
}
}
// The example displays the following output if the current culture
// is en-US:
// The value is: ' .324'
Module SpaceExample
Public Sub Main()
Dim value As Double = 0.324
Console.WriteLine("The value is: '{0,5:#.###}'", value)
End Sub
End Module
' The example displays the following output if the current culture
' is en-US:
' The value is: ' .324'
Den anpassade specificeraren "."
Den anpassade formatspecificeraren "." infogar en lokaliserad decimalavgränsare i resultatsträngen. Den första perioden i formatsträngen avgör platsen för decimaltecknet i det formaterade värdet. eventuella ytterligare perioder ignoreras. Om formatspecificeraren slutar med ett "." formateras endast de signifikanta siffrorna i resultatsträngen.
Det tecken som används som decimalavgränsare i resultatsträngen är inte alltid en punkt. det bestäms av NumberDecimalSeparator egenskapen för objektet NumberFormatInfo som styr formateringen.
I följande exempel används formatspecificeraren "." för att definiera platsen för decimaltecknet i flera resultatsträngar.
double value;
value = 1.2;
Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.00}", value));
// Displays 1.20
Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:00.00}", value));
// Displays 01.20
Console::WriteLine(value.ToString("00.00",
CultureInfo::CreateSpecificCulture("da-DK")));
Console::WriteLine(String::Format(CultureInfo::CreateSpecificCulture("da-DK"),
"{0:00.00}", value));
// Displays 01,20
value = .086;
Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#0.##%}", value));
// Displays 8.6%
value = 86000;
Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.###E+0}", value));
// Displays 8.6E+4
double value;
value = 1.2;
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.00}", value));
// Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:00.00}", value));
// Displays 01.20
Console.WriteLine(value.ToString("00.00",
CultureInfo.CreateSpecificCulture("da-DK")));
Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
"{0:00.00}", value));
// Displays 01,20
value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#0.##%}", value));
// Displays 8.6%
value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+0}", value));
// Displays 8.6E+4
Dim value As Double
value = 1.2
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.00}", value))
' Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:00.00}", value))
' Displays 01.20
Console.WriteLine(value.ToString("00.00", _
CultureInfo.CreateSpecificCulture("da-DK")))
Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
"{0:00.00}", value))
' Displays 01,20
value = .086
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#0.##%}", value))
' Displays 8.6%
value = 86000
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+0}", value))
' Displays 8.6E+4
Den "," anpassade specificeraren
Tecknet "," fungerar som både en gruppavgränsare och en sifferskalningsspecificerare.
Gruppavgränsare: Om ett eller flera kommatecken anges mellan två sifferplatshållare (0 eller #) som formaterar de integralsiffror i ett tal infogas ett gruppavgränsartecken mellan varje nummergrupp i den integrerade delen av utdata.
Egenskaperna NumberGroupSeparator och NumberGroupSizes för det aktuella NumberFormatInfo objektet avgör vilket tecken som används som nummergruppsavgränsare och storleken på varje nummergrupp. Om till exempel strängen "#,#" och den invarianta kulturen används för att formatera talet 1000 är utdata "1 000".
Talskalningsspecificerare: Om ett eller flera kommatecken anges omedelbart till vänster om den explicita eller implicita decimalpunkten delas talet som ska formateras med 1 000 för varje kommatecken. Om strängen "0"till exempel används för att formatera talet 100 miljoner är utdata "100".
Du kan använda gruppavgränsare och nummerskalningsspecificerare i samma formatsträng. Om strängen "#,0" och den invarianta kulturen till exempel används för att formatera talet en miljard är utdata "1 000".
I följande exempel visas hur kommatecken används som gruppavgränsare.
double value = 1234567890;
Console::WriteLine(value.ToString("#,#", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,#}", value));
// Displays 1,234,567,890
Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,##0,,}", value));
// Displays 1,235
double value = 1234567890;
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,#}", value));
// Displays 1,234,567,890
Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,##0,,}", value));
// Displays 1,235
Dim value As Double = 1234567890
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,#}", value))
' Displays 1,234,567,890
Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,##0,,}", value))
' Displays 1,235
I följande exempel visas hur kommatecknet används som en specificerare för talskalning.
double value = 1234567890;
Console::WriteLine(value.ToString("#,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,,}", value));
// Displays 1235
Console::WriteLine(value.ToString("#,,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,,,}", value));
// Displays 1
Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,##0,,}", value));
// Displays 1,235
double value = 1234567890;
Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,,}", value));
// Displays 1235
Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,,,}", value));
// Displays 1
Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,##0,,}", value));
// Displays 1,235
Dim value As Double = 1234567890
Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "{0:#,,}", value))
' Displays 1235
Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,,,}", value))
' Displays 1
Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,##0,,}", value))
' Displays 1,235
Den anpassade "%"-specificeraren
Ett procenttecken (%) i en formatsträng gör att ett tal multipliceras med 100 innan det formateras. Symbolen för lokaliserad procent infogas i talet på den plats där % visas i formatsträngen. Procenttecknet som används definieras av PercentSymbol egenskapen för det aktuella NumberFormatInfo objektet.
I följande exempel definieras flera anpassade formatsträngar som innehåller den anpassade specificeraren %.
double value = .086;
Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#0.##%}", value));
// Displays 8.6%
double value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#0.##%}", value));
// Displays 8.6%
Dim value As Double = .086
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#0.##%}", value))
' Displays 8.6%
Den anpassade specificeraren "‰"
Ett per mille-tecken (‰ eller \u2030) i en formatsträng gör att ett tal multipliceras med 1 000 innan det formateras. Lämplig symbol per mille infogas i den returnerade strängen på den plats där symbolen ‰ visas i formatsträngen. Det per mille-tecken som används definieras av NumberFormatInfo.PerMilleSymbol egenskapen för objektet som tillhandahåller kulturspecifik formateringsinformation.
I följande exempel definieras en anpassad formatsträng som innehåller den anpassade specificeraren "‰".
double value = .00354;
String^ perMilleFmt = "#0.## " + '\u2030';
Console::WriteLine(value.ToString(perMilleFmt, CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:" + perMilleFmt + "}", value));
// Displays 3.54‰
double value = .00354;
string perMilleFmt = "#0.## " + '\u2030';
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:" + perMilleFmt + "}", value));
// Displays 3.54‰
Dim value As Double = .00354
Dim perMilleFmt As String = "#0.## " & ChrW(&h2030)
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:" + perMilleFmt + "}", value))
' Displays 3.54 ‰
Anpassade specificerare för "E" och "e"
Om någon av strängarna "E", "E+", "E-", "e", "e+" eller "e-" finns i formatsträngen och följs omedelbart av minst en nolla formateras talet med hjälp av vetenskaplig notation med ett "E" eller "e" infogat mellan talet och exponenten. Antalet nollor som följer den vetenskapliga notationsindikatorn avgör det minsta antalet siffror som ska matas ut för exponenten. Formaten "E+" och "e+" anger att ett plustecken eller minustecken alltid ska föregå exponenten. Formaten "E", "E-", "e" eller "e-" anger att ett teckentecken endast ska föregå negativa exponenter.
I följande exempel formateras flera numeriska värden med hjälp av specificerarna för vetenskaplig notation.
double value = 86000;
Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.###E+0}", value));
// Displays 8.6E+4
Console::WriteLine(value.ToString("0.###E+000", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.###E+000}", value));
// Displays 8.6E+004
Console::WriteLine(value.ToString("0.###E-000", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.###E-000}", value));
// Displays 8.6E004
double value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+0}", value));
// Displays 8.6E+4
Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+000}", value));
// Displays 8.6E+004
Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E-000}", value));
// Displays 8.6E004
Dim value As Double = 86000
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+0}", value))
' Displays 8.6E+4
Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+000}", value))
' Displays 8.6E+004
Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E-000}", value))
' Displays 8.6E004
Escape-tecknet "\"
Symbolerna "#", "0", ".", ",", "%" och "‰" i en formatsträng tolkas som formatspecificerare snarare än som literaltecken. Beroende på deras position i en anpassad formatsträng kan även versaler och gemener "E" samt symbolerna + och - tolkas som formatspecificerare.
Om du vill förhindra att ett tecken tolkas som en formatspecificerare kan du föregå det med ett omvänt snedstreck, vilket är escape-tecknet. Escape-tecknet betyder att följande tecken är en teckenliteral som ska inkluderas i resultatsträngen oförändrad.
Om du vill inkludera ett omvänt snedstreck i en resultatsträng måste du undvika det med ett annat omvänt snedstreck (\\).
Kommentar
Vissa kompilatorer, till exempel C++ och C#-kompilatorer, kan också tolka ett enda omvänt snedstreck som ett escape-tecken. För att säkerställa att en sträng tolkas korrekt vid formatering kan du använda det ordagranna strängliteraltecknet (@-tecknet) före strängen i C#, eller lägga till ytterligare ett omvänt snedstreck före varje omvänt snedstreck i C# och C++. Följande C#-exempel illustrerar båda metoderna.
I följande exempel används escape-tecknet för att förhindra att formateringsåtgärden tolkar tecknen "#", "0" och "\" som escape-tecken eller formatspecificerare. C#-exemplen använder ytterligare ett omvänt snedstreck för att säkerställa att ett omvänt snedstreck tolkas som ett literaltecken.
int value = 123;
Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console::WriteLine(String::Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
value));
// Displays ### 123 dollars and 00 cents ###
Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#"));
Console::WriteLine(String::Format("{0:\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#}",
value));
// Displays ### 123 dollars and 00 cents ###
Console::WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console::WriteLine(String::Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
value));
// Displays \\\ 123 dollars and 00 cents \\\
Console::WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console::WriteLine(String::Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
value));
// Displays \\\ 123 dollars and 00 cents \\\
int value = 123;
Console.WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console.WriteLine(String.Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
value));
// Displays ### 123 dollars and 00 cents ###
Console.WriteLine(value.ToString(@"\#\#\# ##0 dollars and \0\0 cents \#\#\#"));
Console.WriteLine(String.Format(@"{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
value));
// Displays ### 123 dollars and 00 cents ###
Console.WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console.WriteLine(String.Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
value));
// Displays \\\ 123 dollars and 00 cents \\\
Console.WriteLine(value.ToString(@"\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console.WriteLine(String.Format(@"{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
value));
// Displays \\\ 123 dollars and 00 cents \\\
Dim value As Integer = 123
Console.WriteLine(value.ToString("\#\#\# ##0 dollars and \0\0 cents \#\#\#"))
Console.WriteLine(String.Format("{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
value))
' Displays ### 123 dollars and 00 cents ###
Console.WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"))
Console.WriteLine(String.Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
value))
' Displays \\\ 123 dollars and 00 cents \\\
Avsnittsavgränsaren ";"
Semikolonet (;) är en villkorsstyrd formatspecificerare som tillämpar olika formatering på ett tal beroende på om dess värde är positivt, negativt eller noll. För att skapa det här beteendet kan en anpassad formatsträng innehålla upp till tre avsnitt avgränsade med semikolon. De här avsnitten beskrivs i följande tabell.
| Antal avsnitt | Description |
|---|---|
| Ett avsnitt | Formatsträngen gäller för alla värden. |
| Två avsnitt | Det första avsnittet gäller positiva värden och nollor, och det andra avsnittet gäller negativa värden. Om talet som ska formateras är negativt, men blir noll efter avrundning enligt formatet i det andra avsnittet, formateras den resulterande nolla enligt det första avsnittet. |
| Tre avsnitt | Det första avsnittet gäller positiva värden, det andra avsnittet gäller negativa värden och det tredje avsnittet gäller nollor. Det andra avsnittet kan lämnas tomt (genom att inte ha något mellan semikolonen), i vilket fall det första avsnittet gäller för alla icke-nollvärden. Om talet som ska formateras inte är noll, men blir noll efter avrundning enligt formatet i det första eller andra avsnittet, formateras den resulterande nollan enligt det tredje avsnittet. |
Avsnittsavgränsare ignorerar all befintlig formatering som är associerad med ett tal när det slutliga värdet formateras. Negativa värden visas till exempel alltid utan minustecken när avsnittsavgränsare används. Om du vill att det slutliga formaterade värdet ska ha ett minustecken bör du uttryckligen inkludera minustecknet som en del av den anpassade formatspecificeraren.
I följande exempel används formatspecificeraren ";" för att formatera positiva, negativa och noll tal på olika sätt.
double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;
String^ fmt2 = "##;(##)";
String^ fmt3 = "##;(##);**Zero**";
Console::WriteLine(posValue.ToString(fmt2));
Console::WriteLine(String::Format("{0:" + fmt2 + "}", posValue));
// Displays 1234
Console::WriteLine(negValue.ToString(fmt2));
Console::WriteLine(String::Format("{0:" + fmt2 + "}", negValue));
// Displays (1234)
Console::WriteLine(zeroValue.ToString(fmt3));
Console::WriteLine(String::Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**
double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;
string fmt2 = "##;(##)";
string fmt3 = "##;(##);**Zero**";
Console.WriteLine(posValue.ToString(fmt2));
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue));
// Displays 1234
Console.WriteLine(negValue.ToString(fmt2));
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue));
// Displays (1234)
Console.WriteLine(zeroValue.ToString(fmt3));
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**
Dim posValue As Double = 1234
Dim negValue As Double = -1234
Dim zeroValue As Double = 0
Dim fmt2 As String = "##;(##)"
Dim fmt3 As String = "##;(##);**Zero**"
Console.WriteLine(posValue.ToString(fmt2))
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue))
' Displays 1234
Console.WriteLine(negValue.ToString(fmt2))
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue))
' Displays (1234)
Console.WriteLine(zeroValue.ToString(fmt3))
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue))
' Displays **Zero**
Teckenliteraler
Formatspecificerare som visas i en anpassad numerisk formatsträng tolkas alltid som formateringstecken och aldrig som literaltecken. Detta omfattar följande tecken:
Alla andra tecken tolkas alltid som teckenliteraler och ingår i resultatsträngen oförändrad i en formateringsåtgärd. I en parsningsåtgärd måste de matcha tecknen i indatasträngen exakt. jämförelsen är skiftlägeskänslig.
I följande exempel visas en vanlig användning av literalteckenenheter (i det här fallet tusentals):
double n = 123.8;
Console.WriteLine($"{n:#,##0.0K}");
// The example displays the following output:
// 123.8K
Dim n As Double = 123.8
Console.WriteLine($"{n:#,##0.0K}")
' The example displays the following output:
' 123.8K
Det finns två sätt att ange att tecken ska tolkas som literaltecken och inte som formateringstecken, så att de kan inkluderas i en resultatsträng eller parsas i en indatasträng:
Genom att undvika ett formateringstecken. Mer information finns i Escape-tecknet "\".
Genom att omsluta hela literalsträngen i citattecken apostrofer.
I följande exempel används båda metoderna för att inkludera reserverade tecken i en anpassad numerisk formatsträng.
double n = 9.3;
Console.WriteLine($@"{n:##.0\%}");
Console.WriteLine($@"{n:\'##\'}");
Console.WriteLine($@"{n:\\##\\}");
Console.WriteLine();
Console.WriteLine($"{n:##.0'%'}");
Console.WriteLine($@"{n:'\'##'\'}");
// The example displays the following output:
// 9.3%
// '9'
// \9\
//
// 9.3%
// \9\
Dim n As Double = 9.3
Console.WriteLine($"{n:##.0\%}")
Console.WriteLine($"{n:\'##\'}")
Console.WriteLine($"{n:\\##\\}")
Console.WriteLine()
Console.WriteLine($"{n:##.0'%'}")
Console.WriteLine($"{n:'\'##'\'}")
' The example displays the following output:
' 9.3%
' '9'
' \9\
'
' 9.3%
' \9\
OBS!
Flyttals-infinities 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 NumberFormatInfo objektet.DoubleSingleHalf
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, och den aktuella kulturen innehåller värden som används för att styra formateringen. Datorer som använder olika inställningar genererar olika resultatsträngar.
Om du använder CultureInfo(String) konstruktorn för att instansiera ett nytt CultureInfo objekt som representerar samma kultur som den aktuella systemkulturen tillämpas dessutom eventuella anpassningar som har upprättats 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.
Avrundnings- och fastpunktsformatsträngar
För strängar med fast punktformat (dvs. formatsträngar som inte innehåller tecken i vetenskapligt notationsformat) avrundas talen till så många decimaler som det finns sifferplatshållare till höger om decimaltecknet. Om formatsträngen inte innehåller en decimalpunkt avrundas talet till närmaste heltal. Om talet har fler siffror än det finns platshållare för siffror till vänster om decimaltecknet kopieras de extra siffrorna till resultatsträngen omedelbart före platshållaren för den första siffran.
Exempel
I följande exempel visas två anpassade numeriska formatsträngar. I båda fallen visar sifferplatshållaren (#) numeriska data och alla andra tecken kopieras till resultatsträngen.
double number1 = 1234567890;
String^ value1 = number1.ToString("(###) ###-####");
Console::WriteLine(value1);
int number2 = 42;
String^ value2 = number2.ToString("My Number = #");
Console::WriteLine(value2);
// The example displays the following output:
// (123) 456-7890
// My Number = 42
double number1 = 1234567890;
string value1 = number1.ToString("(###) ###-####");
Console.WriteLine(value1);
int number2 = 42;
string value2 = number2.ToString("My Number = #");
Console.WriteLine(value2);
// The example displays the following output:
// (123) 456-7890
// My Number = 42
Dim number1 As Double = 1234567890
Dim value1 As String = number1.ToString("(###) ###-####")
Console.WriteLine(value1)
Dim number2 As Integer = 42
Dim value2 As String = number2.ToString("My Number = #")
Console.WriteLine(value2)
' The example displays the following output:
' (123) 456-7890
' My Number = 42
