Standaardtekenreeksen voor numerieke notatie
Standaardtekenreeksen voor numerieke notatie worden gebruikt om algemene numerieke typen op te maken. Een standaardtekenreeks voor numerieke notatie heeft de vorm [format specifier][precision specifier], waarbij:
Notatieaanduiding is één alfabetisch teken dat het type getalnotatie aangeeft, bijvoorbeeld valuta of percentage. Een tekenreeks met een numerieke notatie die meer dan één alfabetisch teken bevat, inclusief witruimte, wordt geïnterpreteerd als een aangepaste tekenreeks voor numerieke notatie. Zie Aangepaste numerieke notatietekenreeksen voor meer informatie.
Precisieaanduiding is een optioneel geheel getal dat van invloed is op het aantal cijfers in de resulterende tekenreeks. In .NET 7 en latere versies is de maximale precisiewaarde 999.999.999. In .NET 6 is Int32.MaxValuede maximale precisiewaarde . In eerdere .NET-versies kan de precisie variëren van 0 tot 99. De precisieaanduiding bepaalt het aantal cijfers in de tekenreeksweergave van een getal. Het getal zelf wordt niet afgerond. Als u een afrondingsbewerking wilt uitvoeren, gebruikt u de Math.Ceilingmethode , Math.Floorof Math.Round .
Wanneer precisieaanduiding het aantal breukcijfers in de resultaattekenreeks bepaalt, geeft de resultaattekenreeks een getal weer dat wordt afgerond op een representeerbaar resultaat dat het dichtst bij het oneindig nauwkeurige resultaat ligt. Als er twee even goed te vertegenwoordigen resultaten zijn:
- Op .NET Framework en .NET Core tot en met .NET Core 2.0 selecteert de runtime het resultaat met het kleinste significante cijfer (dat wil gezegd, met behulp van MidpointRounding.AwayFromZero).
- In .NET Core 2.1 en hoger selecteert de runtime het resultaat met een zelfs minst significante cijfer (dat wil gezegd, met behulp van MidpointRounding.ToEven).
Notitie
De precisieaanduiding bepaalt het aantal cijfers in de resultaattekenreeks. Als u een resultaattekenreeks wilt opvultekens met voorloop- of volgspaties, gebruikt u de functie samengestelde opmaak en definieert u een uitlijningsonderdeel in het opmaakitem.
Tekenreeksen met een standaard numerieke notatie worden ondersteund door:
Enige overbelasting van de
ToStringmethode van alle numerieke typen. U kunt bijvoorbeeld een tekenreeks met een numerieke notatie opgeven voor de Int32.ToString(String) methoden en Int32.ToString(String, IFormatProvider) .De
TryFormatmethode van alle numerieke typen, Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) bijvoorbeeld en Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).De functie voor samengestelde .NET-opmaak, die wordt gebruikt door sommige
Writemethoden enWriteLinevan de Console klassen en StreamWriter , de String.Format methode en de StringBuilder.AppendFormat methode. Met de functie samengestelde opmaak kunt u de tekenreeksweergave van meerdere gegevensitems in één tekenreeks opnemen, de veldbreedte opgeven en getallen in een veld uitlijnen. Zie Samengestelde opmaak voor meer informatie.Geïnterpoleerde tekenreeksen in C# en Visual Basic, die een vereenvoudigde syntaxis bieden in vergelijking met samengestelde tekenreeksen.
Tip
U kunt het opmaakhulpprogramma downloaden, een .NET Core-Windows Forms-toepassing waarmee u opmaaktekenreeksen kunt toepassen op numerieke waarden of datum- en tijdwaarden en de resultaattekenreeks kunt weergeven. Broncode is beschikbaar voor C# en Visual Basic.
Standaardindelingsaanduidingen
In de volgende tabel worden de standaardaanduidingen voor numerieke notaties beschreven en worden voorbeelduitvoer weergegeven die door elke notatieaanduiding is geproduceerd. Zie de sectie Notities voor meer informatie over het gebruik van standaardtekenreeksen voor numerieke notatie en de sectie Codevoorbeeld voor een uitgebreide illustratie van het gebruik ervan.
Het resultaat van een opgemaakte tekenreeks voor een specifieke cultuur kan afwijken van de volgende voorbeelden. Instellingen van het besturingssysteem, gebruikersinstellingen, omgevingsvariabelen en de .NET-versie die u gebruikt, kunnen allemaal van invloed zijn op de indeling. Vanaf .NET 5 probeert .NET bijvoorbeeld culturele indelingen op verschillende platforms te verenigen. Zie .NET-globalisering en ICU voor meer informatie.
| Opmaakaanduiding | Naam | Beschrijving | Voorbeelden |
|---|---|---|---|
| "B" of "b" | Binair | Resultaat: een binaire tekenreeks. Ondersteund door: Alleen integrale typen (.NET 8+). Precisieaanduiding: het aantal cijfers in de resultaattekenreeks. Meer informatie: The Binary (B) Format Specifier. |
42 ("B") -> 101010 255 ("b16") -> 0000000011111111 |
| "C" of "c" | Valuta | Resultaat: een valutawaarde. Ondersteund door: Alle numerieke typen. Precisieaanduiding: aantal decimale cijfers. Standaardprecisieaanduiding: Gedefinieerd door NumberFormatInfo.CurrencyDecimalDigits. Meer informatie: De notatiespecificatie van de 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" of "d" | Decimaal | Resultaat: Gehele getallen met optioneel negatief teken. Ondersteund door: Alleen integrale typen. Precisieaanduiding: Minimumaantal cijfers. Standaardprecisieaanduiding: minimaal aantal cijfers vereist. Meer informatie: De notatieaanduiding Decimaal("D"). |
1234 ("D") -> 1234 -1234 ("D6") -> -001234 |
| "E" of "e" | Exponentieel (wetenschappelijk) | Resultaat: Exponentiële notatie. Ondersteund door: Alle numerieke typen. Precisieaanduiding: aantal decimale cijfers. Standaard precisieaanduiding: 6. Meer informatie: De aanduiding voor exponentiële notatie ('E'). |
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" of "f" | Vast punt | Resultaat: integrale en decimale cijfers met optioneel negatief teken. Ondersteund door: Alle numerieke typen. Precisieaanduiding: aantal decimale cijfers. Standaardprecisieaanduiding: Gedefinieerd door NumberFormatInfo.NumberDecimalDigits. Meer informatie: De Fixed-Point (F) Format Specifier. |
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" of "g" | Algemeen | Resultaat: De compactere notatie van een vaste of wetenschappelijke notatie. Ondersteund door: Alle numerieke typen. Precisieaanduiding: aantal significante cijfers. Standaard precisieaanduiding: is afhankelijk van het numerieke type. Meer informatie: De algemene notatieaanduiding ('G'). |
-123.456 ("G", en-US) -> -123.456 -123.456 ("G", sv-SE) -> -123.456 123.4546 ("G4", en-US) -> 123,5 123.4546 ("G4", sv-SE) -> 123,5 -1.234567890e-25 ("G", en-US) -> -1.23456789E-25 -1,234567890e-25 ("G", sv-SE) -> -1.23456789E-25 |
| "N" of "n" | Aantal | Resultaat: integrale en decimale cijfers, scheidingstekens voor groepen en een decimaalteken met optioneel negatief teken. Ondersteund door: Alle numerieke typen. Precisieaanduiding: Gewenst aantal decimalen. Standaardprecisieaanduiding: Gedefinieerd door NumberFormatInfo.NumberDecimalDigits. Meer informatie: De notatieaanduiding voor numerieke notatie (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" of "p" | Percentage | Resultaat: getal vermenigvuldigd met 100 en weergegeven met een procentsymbool. Ondersteund door: Alle numerieke typen. Precisieaanduiding: Gewenst aantal decimalen. Standaardprecisieaanduiding: Gedefinieerd door NumberFormatInfo.PercentDecimalDigits. Meer informatie: De aanduiding percentagenotatie ('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" of "r" | Round-trip | Resultaat: een tekenreeks die kan worden afgerond naar een identiek getal. Ondersteund door: Single, Doubleen BigInteger. Opmerking: alleen aanbevolen voor het BigInteger type. Voor Double typen gebruikt u 'G17'; voor Single typen gebruikt u 'G9'. Precisieaanduiding: Genegeerd. Meer informatie: The Round-trip (R) Format Specifier. |
123456789.12345678 ("R") -> 123456789.12345678 -1234567890.12345678 ("R") -> -1234567890.1234567 |
| "X" of "x" | Hexadecimale | Resultaat: een hexadecimale tekenreeks. Ondersteund door: Alleen integrale typen. Precisieaanduiding: het aantal cijfers in de resultaattekenreeks. Meer informatie: De hexadecimale notatieaanduiding (X). |
255 ("X") -> FF -1 ("x") -> ff 255 ("x4") -> 00ff -1 ("X4") -> 00FF |
| Een ander enkel teken | Onbekende aanduiding | Resultaat: genereert een FormatException tijdens runtime. |
Standaardtekenreeksen voor numerieke notatie gebruiken
Notitie
De C#-voorbeelden in dit artikel worden uitgevoerd in de Try.NET inline code-runner en playground. Selecteer de knop Uitvoeren om een voorbeeld in een interactief venster uit te voeren. Nadat u de code hebt uitgevoerd, kunt u deze wijzigen en de gewijzigde code uitvoeren door opnieuw Uitvoeren te selecteren. De gewijzigde code wordt uitgevoerd in het interactieve venster of, als de compilatie mislukt, worden in het interactieve venster alle C#-compilerfoutberichten weergegeven.
Een standaardtekenreeks voor numerieke notatie kan worden gebruikt om de opmaak van een numerieke waarde op een van de volgende manieren te definiëren:
Deze kan worden doorgegeven aan de
TryFormatmethode of een overbelasting van deToStringmethode die eenformatparameter heeft. In het volgende voorbeeld wordt een numerieke waarde opgemaakt als een valutatekenreeks in de huidige cultuur (in dit geval de en-US-cultuur).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.46Het kan worden opgegeven als het
formatStringargument in een indelingsitem dat wordt gebruikt met methoden als String.Format, Console.WriteLineen StringBuilder.AppendFormat. Zie Samengestelde opmaak voor meer informatie. In het volgende voorbeeld wordt een opmaakitem gebruikt om een valutawaarde in te voegen in een tekenreeks.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."Desgewenst kunt u een
alignmentargument opgeven om de breedte van het numerieke veld op te geven en of de waarde rechts of links is uitgelijnd. In het volgende voorbeeld wordt een valutawaarde links uitgelijnd in een veld van 28 tekens en wordt een valutawaarde in een veld van 14 tekens rechts uitgelijnd.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.16Het kan worden opgegeven als het
formatStringargument in een geïnterpoleerd expressie-item van een geïnterpoleerde tekenreeks. Zie het artikel Tekenreeksinterpolatie in de C#-verwijzing of het artikel Geïnterpoleerde tekenreeksen in de Visual Basic-verwijzing voor meer informatie.
De volgende secties bevatten gedetailleerde informatie over elk van de standaardtekenreeksen voor numerieke notatie.
Aanduiding binaire indeling (B)
De binaire notatieaanduiding (B) converteert een getal naar een tekenreeks van binaire cijfers. Deze indeling wordt alleen ondersteund voor integrale typen en alleen op .NET 8+.
De precisieaanduiding geeft het minimale aantal cijfers aan dat in de resulterende tekenreeks is gewenst. Indien nodig wordt het getal links opgevuld met nullen om het aantal cijfers te produceren dat door de precisieaanduiding wordt opgegeven.
De resultaattekenreeks wordt niet beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object.
Aanduiding valutanotatie (C)
De aanduiding 'C' (of valuta) converteert een getal naar een tekenreeks die een valutabedrag vertegenwoordigt. De precisieaanduiding geeft het gewenste aantal decimalen in de resultaatreeks aan. Als u de precisieaanduiding weglaat, wordt de standaardprecisie gedefinieerd door de NumberFormatInfo.CurrencyDecimalDigits eigenschap .
Als de op te maken waarde meer dan het opgegeven of standaardaantal decimalen bevat, wordt de breukwaarde afgerond in de resultaattekenreeks. Als de waarde rechts van het aantal opgegeven decimalen 5 of groter is, wordt het laatste cijfer in de resultaatreeks afgerond van nul.
De resultaattekenreeks wordt beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object. De volgende tabel bevat de NumberFormatInfo eigenschappen die de opmaak van de geretourneerde tekenreeks bepalen.
| De eigenschap NumberFormatInfo | Description |
|---|---|
| CurrencyPositivePattern | Definieert de plaatsing van het valutasymbool voor positieve waarden. |
| CurrencyNegativePattern | Definieert de plaatsing van het valutasymbool voor negatieve waarden en geeft aan of het negatieve teken wordt vertegenwoordigd door haakjes of de NegativeSign eigenschap. |
| NegativeSign | Definieert het negatieve teken dat wordt gebruikt als CurrencyNegativePattern aangeeft dat haakjes niet worden gebruikt. |
| CurrencySymbol | Hiermee definieert u het valutasymbool. |
| CurrencyDecimalDigits | Hiermee definieert u het standaardaantal decimale cijfers in een valutawaarde. Deze waarde kan worden overschreven met behulp van de precisieaanduiding. |
| CurrencyDecimalSeparator | Hiermee definieert u de tekenreeks die integraal en decimaal cijfer scheidt. |
| CurrencyGroupSeparator | Hiermee definieert u de tekenreeks die groepen integrale getallen scheidt. |
| CurrencyGroupSizes | Hiermee definieert u het aantal gehele getallen dat in een groep wordt weergegeven. |
In het volgende voorbeeld wordt een Double waarde opgemaakt met de valutanotatieaanduiding:
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
Decimale notatieaanduiding (D)
De aanduiding 'D' (of decimaal) converteert een getal naar een reeks decimale cijfers (0-9), voorafgegaan door een minteken als het getal negatief is. Deze indeling wordt alleen ondersteund voor integrale typen.
De precisieaanduiding geeft het minimale aantal cijfers aan dat in de resulterende tekenreeks is gewenst. Indien nodig wordt het getal links opgevuld met nullen om het aantal cijfers te produceren dat door de precisieaanduiding wordt opgegeven. Als er geen precisieaanduiding is opgegeven, is de standaardwaarde de minimumwaarde die is vereist om het gehele getal zonder voorloopnullen weer te geven.
De resultaattekenreeks wordt beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object. Zoals in de volgende tabel wordt weergegeven, is één eigenschap van invloed op de opmaak van de resultaattekenreeks.
| De eigenschap NumberFormatInfo | Description |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
In het volgende voorbeeld wordt een Int32 waarde opgemaakt met de aanduiding voor de decimale notatie.
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
Exponentiële notatieaanduiding (E)
De exponentiële notatieaanduiding ('E') converteert een getal naar een tekenreeks met de notatie '-d.ddd... E+ddd" of "-d.ddd... e+ddd', waarbij elke 'd' een cijfer aangeeft (0-9). De tekenreeks begint met een minteken als het getal negatief is. Precies één cijfer voorafgaat altijd aan de decimale komma.
De precisieaanduiding geeft het gewenste aantal cijfers na de decimale komma aan. Als de precisieaanduiding wordt weggelaten, wordt de standaardwaarde van zes cijfers na het decimaalteken gebruikt.
Het geval van de notatieaanduiding geeft aan of de exponent moet worden voorafgegaan door een 'E' of een 'e'. De exponent bestaat altijd uit een plus- of minteken en minimaal drie cijfers. De exponent wordt indien nodig opgevuld met nullen om aan dit minimum te voldoen.
De resultaattekenreeks wordt beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object. De volgende tabel bevat de NumberFormatInfo eigenschappen die de opmaak van de geretourneerde tekenreeks bepalen.
| De eigenschap NumberFormatInfo | Description |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is voor zowel de coëfficiënt als de exponent. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die het integrale cijfer scheidt van decimale cijfers in de coëfficiënt. |
| PositiveSign | Definieert de tekenreeks die aangeeft dat een exponent positief is. |
In het volgende voorbeeld wordt een Double waarde opgemaakt met de aanduiding exponentiële indeling:
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
Aanduiding voor vaste-puntnotatie (F)
De aanduiding met vaste-puntnotatie (F) converteert een getal naar een tekenreeks van de vorm '-ddd.ddd...' waarbij elke "d" een cijfer aangeeft (0-9). De tekenreeks begint met een minteken als het getal negatief is.
De precisieaanduiding geeft het gewenste aantal decimalen aan. Als de precisieaanduiding wordt weggelaten, levert de huidige NumberFormatInfo.NumberDecimalDigits eigenschap de numerieke precisie.
De resultaattekenreeks wordt beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object. De volgende tabel bevat de eigenschappen van het NumberFormatInfo -object dat de opmaak van de resultaattekenreeks bepaalt.
| De eigenschap NumberFormatInfo | Description |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die integrale cijfers van decimale cijfers scheidt. |
| NumberDecimalDigits | Hiermee definieert u het standaardaantal decimale cijfers. Deze waarde kan worden overschreven met behulp van de precisieaanduiding. |
In het volgende voorbeeld wordt een Double en een Int32 waarde opgemaakt met de notatieaanduiding voor vaste punten:
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
Algemene notatieaanduiding (G)
De algemene notatie ('G') converteert een getal naar de compactere notatie van een vaste of wetenschappelijke notatie, afhankelijk van het type getal en of er een precisieaanduiding aanwezig is. De precisieaanduiding definieert het maximum aantal significante cijfers dat in de resultaattekenreeks kan worden weergegeven. Als de precisieaanduiding wordt weggelaten of nul, bepaalt het type van het getal de standaardprecisie, zoals aangegeven in de volgende tabel.
| Numeriek type | Standaardprecisie |
|---|---|
| Byte of SByte | 3 cijfers |
| Int16 of UInt16 | 5 cijfers |
| Int32 of UInt32 | 10 cijfers |
| Int64 | 19 cijfers |
| UInt64 | 20 cijfers |
| BigInteger | Onbeperkt (gelijk aan 'R') |
| Half | Kleinste retourneerbaar aantal cijfers om het getal aan te geven |
| Single | Kleinste retourneerbaar aantal cijfers om het getal aan te geven (in .NET Framework is G7 de standaardinstelling) |
| Double | Kleinste retourneerbaar aantal cijfers om het getal aan te geven (in .NET Framework is G15 de standaardwaarde) |
| Decimal | Kleinste retourneerbaar aantal cijfers om het getal aan te geven |
De notatie met vaste punten wordt gebruikt als de exponent die het resultaat zou zijn van het uitdrukken van het getal in de wetenschappelijke notatie groter is dan -5 en kleiner is dan de precisieaanduiding; anders wordt de wetenschappelijke notatie gebruikt. Het resultaat bevat indien nodig een decimaalteken en volgnullen nadat de decimale komma is weggelaten. Als de precisieaanduiding aanwezig is en het aantal significante cijfers in het resultaat groter is dan de opgegeven precisie, worden de overtollige volgcijfers verwijderd door afronding.
Als het getal echter een Decimal is en de precisieaanduiding wordt weggelaten, wordt de notatie met vaste punten altijd gebruikt en blijven de volgnullen behouden.
Als wetenschappelijke notatie wordt gebruikt, wordt de exponent in het resultaat voorafgegaan door 'E' als de notatieaanduiding 'G' is of 'e' als de notatieaanduiding 'g' is. De exponent bestaat uit minimaal twee cijfers. Dit verschilt van het formaat voor wetenschappelijke notatie dat wordt geproduceerd door de exponentiële notatieaanduiding, die minimaal drie cijfers in de exponent bevat.
Bij gebruik met een Double waarde zorgt de aanduiding 'G17'-indeling ervoor dat de oorspronkelijke Double waarde met succes wordt afgerond. Dit komt omdat Double een IEEE 754-2008-compatibel dubbelprecisienummer (binary64) met drijvende komma is dat tot 17 significante cijfers van precisie geeft. Op .NET Framework raden we het gebruik ervan aan in plaats van de indelingSaanduiding 'R', omdat in sommige gevallen 'R' er niet in slaagt om waarden met dubbele precisie met dubbele precisie te afronden.
Bij gebruik met een Single waarde zorgt de aanduiding 'G9'-indeling ervoor dat de oorspronkelijke Single waarde met succes retourneert. Dit komt omdat Single een IEEE 754-2008-compatibel drijvendekommanummer met één precisie (binary32) is dat tot negen significante cijfers van precisie geeft. Om prestatieredenen raden we het gebruik aan in plaats van de indelingsaanduiding 'R'.
De resultaattekenreeks wordt beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object. De volgende tabel bevat de NumberFormatInfo eigenschappen die de opmaak van de resultaattekenreeks bepalen.
| De eigenschap NumberFormatInfo | Description |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die integrale cijfers scheidt van decimale cijfers. |
| PositiveSign | Hiermee definieert u de tekenreeks die aangeeft dat een exponent positief is. |
In het volgende voorbeeld worden verschillende drijvende-kommawaarden opgemaakt met de algemene notatieaanduiding:
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
Numerieke notatieaanduiding (N)
Met de notatieaanduiding N ('N') wordt een getal geconverteerd naar een tekenreeks van de notatie '-d,ddd,ddd.ddd...', waarbij '-' indien nodig een negatief getalsymbool aangeeft, 'd' een cijfer (0-9), ',' een scheidingsteken voor groepen aangeeft en '' een decimaalteken aangeeft. De precisieaanduiding geeft het gewenste aantal cijfers na de decimale komma aan. Als u de precisieaanduiding weglaat, wordt het aantal decimalen gedefinieerd door de huidige NumberFormatInfo.NumberDecimalDigits eigenschap.
De resultaattekenreeks wordt beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object. De volgende tabel bevat de NumberFormatInfo eigenschappen die de opmaak van de resultaattekenreeks bepalen.
| De eigenschap NumberFormatInfo | Description |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
| NumberNegativePattern | Definieert de notatie van negatieve waarden en geeft aan of het negatieve teken wordt vertegenwoordigd door haakjes of de NegativeSign eigenschap. |
| NumberGroupSizes | Hiermee definieert u het aantal integrale cijfers dat wordt weergegeven tussen groepsscheidingstekens. |
| NumberGroupSeparator | Hiermee definieert u de tekenreeks die groepen integrale getallen van elkaar scheidt. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die integraal en decimaal cijfer scheidt. |
| NumberDecimalDigits | Hiermee definieert u het standaardaantal decimale cijfers. Deze waarde kan worden overschreven met behulp van een precisieaanduiding. |
In het volgende voorbeeld worden verschillende drijvende-kommawaarden opgemaakt met de aanduiding voor getalnotatie:
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
Aanduiding voor percentagenotatie (P)
De aanduiding van de percentagenotatie ('P') vermenigvuldigt een getal met 100 en converteert dit naar een tekenreeks die een percentage vertegenwoordigt. De precisieaanduiding geeft het gewenste aantal decimalen aan. Als u de precisieaanduiding weglaat, wordt de standaard numerieke precisie gebruikt die door de huidige PercentDecimalDigits eigenschap wordt opgegeven.
De volgende tabel bevat de NumberFormatInfo eigenschappen die de opmaak van de geretourneerde tekenreeks bepalen.
| De eigenschap NumberFormatInfo | Description |
|---|---|
| PercentPositivePattern | Hiermee definieert u de plaatsing van het procentteken voor positieve waarden. |
| PercentNegativePattern | Hiermee definieert u de plaatsing van het procentsymbool en het negatieve symbool voor negatieve waarden. |
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
| PercentSymbol | Hiermee definieert u het procentsymbool. |
| PercentDecimalDigits | Hiermee definieert u het standaardaantal decimale cijfers in een percentagewaarde. Deze waarde kan worden overschreven met behulp van de precisieaanduiding. |
| PercentDecimalSeparator | Hiermee definieert u de tekenreeks die integraal en decimaal cijfer scheidt. |
| PercentGroupSeparator | Hiermee definieert u de tekenreeks die groepen integrale getallen van elkaar scheidt. |
| PercentGroupSizes | Hiermee definieert u het aantal gehele getallen dat in een groep wordt weergegeven. |
In het volgende voorbeeld worden drijvendekommawaarden opgemaakt met de notatieaanduiding percentage:
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 %
Aanduiding van retourindeling (R)
De aanduiding voor de round-trip-notatie (R) probeert ervoor te zorgen dat een numerieke waarde die wordt geconverteerd naar een tekenreeks, weer wordt geparseerd in dezelfde numerieke waarde. Deze indeling wordt alleen ondersteund voor de Halftypen , Single, Doubleen BigInteger .
In .NET Framework en in .NET Core-versies Double die ouder zijn dan 3.0, slaagt de indelingsaanduiding 'R' er in sommige gevallen niet in om waarden te afronden. Voor zowel als DoubleSingle waarden biedt de aanduiding 'R'-indeling relatief slechte prestaties. In plaats daarvan raden we u aan de indelingsaanduiding G17 te gebruiken voor Double waarden en de indelingsaanduiding 'G9' om waarden te afronden Single .
Wanneer een BigInteger waarde is opgemaakt met behulp van deze aanduiding, bevat de tekenreeksweergave alle significante cijfers in de BigInteger waarde.
Hoewel u een precisieaanduiding kunt opnemen, wordt deze genegeerd. Retouren krijgen voorrang op precisie bij het gebruik van deze aanduiding. De resultaattekenreeks wordt beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object. De volgende tabel bevat de NumberFormatInfo eigenschappen die de opmaak van de resultaattekenreeks bepalen.
| De eigenschap NumberFormatInfo | Description |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die integrale cijfers scheidt van decimale cijfers. |
| PositiveSign | Hiermee definieert u de tekenreeks die aangeeft dat een exponent positief is. |
In het volgende voorbeeld wordt een BigInteger waarde opgemaakt met de indelingsaanduiding round-trip.
#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
Belangrijk
In sommige gevallen worden waarden die Double zijn opgemaakt met de tekenreeks voor de numerieke standaardnotatie 'R' niet afgerond als ze zijn gecompileerd met behulp van de /platform:x64 schakelopties of /platform:anycpu en worden uitgevoerd op 64-bits systemen. Zie de volgende alinea voor meer informatie.
Als u het probleem wilt omzeilen dat waarden die zijn opgemaakt met de tekenreeks voor de standaard numerieke notatie 'R' niet kan worden afgerond als deze zijn gecompileerd met behulp van Double de /platform:x64 schakelopties of /platform:anycpu en worden uitgevoerd op 64-bits systemen, kunt u waarden opmaken Double met behulp van de standaardtekenreeks G17 voor numerieke notatie. In het volgende voorbeeld wordt de tekenreeks 'R'-indeling gebruikt met een Double waarde die niet correct wordt afgerond, en wordt ook de tekenreeks 'G17' gebruikt om de oorspronkelijke waarde te afronden:
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
Hexadecimale notatieaanduiding (X)
De hexadecimale notatieaanduiding (X) converteert een getal naar een reeks hexadecimale cijfers. De hoofdletters van de notatieaanduiding geven aan of hoofdletters of kleine letters moeten worden gebruikt voor hexadecimale cijfers die groter zijn dan 9. Gebruik bijvoorbeeld 'X' om 'ABCDEF' te produceren en 'x' om 'abcdef' te produceren. Deze indeling wordt alleen ondersteund voor integrale typen.
De precisieaanduiding geeft het minimale aantal cijfers aan dat in de resulterende tekenreeks is gewenst. Indien nodig wordt het getal opgevuld met nullen links om het aantal cijfers te produceren dat door de precisieaanduiding wordt opgegeven.
De resultaattekenreeks wordt niet beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object.
In het volgende voorbeeld Int32 worden waarden opgemaakt met de hexadecimale notatieaanduiding.
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
Notities
Deze sectie bevat aanvullende informatie over het gebruik van tekenreeksen met een standaard numerieke notatie.
Configuratiescherm-instellingen
De instellingen in het item Landinstellingen in Configuratiescherm invloed hebben op de resultaatreeks die door een opmaakbewerking wordt geproduceerd. Deze instellingen worden gebruikt om het NumberFormatInfo object te initialiseren dat is gekoppeld aan de huidige cultuur, dat waarden bevat die worden gebruikt voor het bepalen van de opmaak. Computers met verschillende instellingen genereren verschillende resultaatreeksen.
Als de CultureInfo(String) constructor bovendien wordt gebruikt om een nieuw CultureInfo object te instantiëren dat dezelfde cultuur vertegenwoordigt als de huidige systeemcultuur, worden alle aanpassingen die door het item Landinstellingen in Configuratiescherm zijn gemaakt, toegepast op het nieuwe CultureInfo object. U kunt de CultureInfo(String, Boolean) constructor gebruiken om een CultureInfo object te maken dat niet overeenkomt met de aanpassingen van een systeem.
NumberFormatInfo-eigenschappen
De opmaak wordt beïnvloed door de eigenschappen van het huidige NumberFormatInfo object, dat impliciet wordt opgegeven door de huidige cultuur of expliciet door de IFormatProvider parameter van de methode die opmaak aanroept. Geef een NumberFormatInfo of-object CultureInfo op voor die parameter.
Notitie
Zie het klasseonderwerp voor informatie over het aanpassen van de patronen of tekenreeksen die worden gebruikt bij het NumberFormatInfo opmaken van numerieke waarden.
Integrale en numerieke typen met drijvende komma
Sommige beschrijvingen van standaard numerieke notatieaanduidingen verwijzen naar integrale of numerieke typen met drijvende komma. De integrale numerieke typen zijn Byte, SByte, , Int16, Int32, Int64, UInt16, UInt32, , en .BigIntegerUInt64 De numerieke typen met drijvende komma zijn Decimal, Half, Singleen Double.
Infinities met drijvende komma en NaN
Ongeacht de notatietekenreeks, als de waarde van een Halftype , Singleof Double drijvende komma positief oneindig, negatief oneindig of geen getal (NaN) is, is de opgemaakte tekenreeks de waarde van de betreffende PositiveInfinitySymboleigenschap , NegativeInfinitySymbolof NaNSymbol die is opgegeven door het momenteel toepasselijke NumberFormatInfo object.
Voorbeeld van code
In het volgende voorbeeld wordt een integraal en een numerieke waarde met drijvende komma opgemaakt met behulp van de en-US-cultuur en alle standaard numerieke notatieaanduidingen. In dit voorbeeld worden twee specifieke numerieke typen (Double en Int32) gebruikt, maar zouden vergelijkbare resultaten opleveren voor elk van de andere numerieke basistypen (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, BigIntegerUInt64, , , Decimal, Halfen 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
Zie ook
Feedback
Binnenkort beschikbaar: In de loop van 2024 zullen we GitHub-problemen geleidelijk uitfaseren als het feedbackmechanisme voor inhoud en deze vervangen door een nieuw feedbacksysteem. Zie voor meer informatie: https://aka.ms/ContentUserFeedback.
Feedback verzenden en weergeven voor