Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Standaardtekenreeksen voor numerieke notatie worden gebruikt om algemene numerieke typen op te maken. Een standaardtekenreeks voor numerieke notatie heeft de volgende notatie [format specifier][precision specifier]:
De notatieaanduiding is één alfabetisch teken dat het type getalnotatie aangeeft, bijvoorbeeld valuta of percentage. Elke tekenreeks met numerieke notatie die meer dan één alfabetisch teken bevat, inclusief witruimte, wordt geïnterpreteerd als een aangepaste tekenreeks voor numerieke notatie. Zie Tekenreeksen met aangepaste numerieke notatie 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.Ceiling, Math.Floorof Math.Round methode.
Wanneer precisieaanduiding het aantal fractionele cijfers in de resultaattekenreeks bepaalt, geeft de resultaattekenreeks een getal weer dat is afgerond op een vertegenwoordigbaar resultaat dat het dichtst bij het oneindig nauwkeurige resultaat ligt. Als er twee even bijna vertegenwoordigbare 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).
- Op .NET Core 2.1 en hoger selecteert de runtime het resultaat met een nog 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 met voorloop- of volgspaties wilt opmaken, gebruikt u de functie samengestelde opmaak en definieert u een breedteonderdeel in het opmaakitem.
Standaardtekenreeksen voor numerieke notatie worden ondersteund door:
Sommige overbelastingen van de
ToStringmethode van alle numerieke typen. U kunt bijvoorbeeld een tekenreeks voor een numerieke notatie opgeven voor de Int32.ToString(String) en Int32.ToString(String, IFormatProvider) methoden.De
TryFormatmethode van alle numerieke typen, bijvoorbeeld Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) en Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).De samengestelde .NET-opmaakfunctie, die wordt gebruikt door een aantal
WriteenWriteLinemethoden van de Console en StreamWriter klassen, de String.Format methode en de StringBuilder.AppendFormat methode. Met de functie samengestelde indeling 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 notatietekenreeksen.
Hint
U kunt het hulpprogramma Opmaak 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.
Standaardnotatieaanduidingen
In de volgende tabel worden de standaardaanduidingen voor numerieke notaties beschreven en worden voorbeelduitvoer weergegeven die door elke indelingsaanduiding wordt 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 voor besturingssystemen, 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 samenvoegen. Zie .NET-globalisering en ICU voor meer informatie.
| Opmaakaanduiding | Naam | Beschrijving | Voorbeelden |
|---|---|---|---|
| "B" of "b" | Binaire | Resultaat: een binaire tekenreeks. Ondersteund door: Alleen integrale typen (.NET 8+). Precisieaanduiding: Aantal cijfers in de resultaattekenreeks. Meer informatie: De binaire indeling ('B') Specifier. |
42 ("B") -> 101010 255 ("b16") -> 0000000011111111 |
| "C" of "c" | Valuta | Resultaat: Een valutawaarde. Ondersteund door: Alle numerieke typen. Precisieaanduiding: Aantal decimalen. Standaardprecisieaanduiding: gedefinieerd door NumberFormatInfo.CurrencyDecimalDigits. Meer informatie: De valutanotatie ("C") Specifier. |
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. Alleen ondersteund door: Integrale typen. Precisieaanduiding: Minimumaantal cijfers. Standaardprecisieaanduiding: Minimaal aantal cijfers vereist. Meer informatie: De decimaal("D") Notatieaanduiding. |
1234 ("D") -> nummer 1234 -1234 ("D6") -> -001234 |
| "E" of "e" | Exponentieel (wetenschappelijk) | Resultaat: Exponentiële notatie. Ondersteund door: Alle numerieke typen. Precisieaanduiding: Aantal decimalen. Standaardprecisieaanduiding: 6. Meer informatie: De Exponentiële notatieaanduiding (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 decimalen. Standaardprecisieaanduiding: gedefinieerd door NumberFormatInfo.NumberDecimalDigits. Meer informatie: De Fixed-Point ("F") Format Specifier. |
1234.567 ("F", en-US) -> 1234,57 Zoekertjes 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: Hoe compacter de vaste punt- of wetenschappelijke notatie. Ondersteund door: Alle numerieke typen. Precisieaanduiding: Aantal significante cijfers. Standaardprecisieaanduiding: afhankelijk van numeriek 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 Zoekertjes 123.4546 ("G4", sv-SE) -> 123,5 Zoekertjes -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, groepsscheidingstekens en een decimaalteken met optioneel negatief teken. Ondersteund door: Alle numerieke typen. Precisieaanduiding: Gewenst aantal decimalen. Standaardprecisieaanduiding: gedefinieerd door NumberFormatInfo.NumberDecimalDigits. Meer informatie: De numerieke notatieaanduiding (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" | Procent | 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: The Percent ("P") Format Specifier. |
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 een retour naar een identiek getal kan afronden. Ondersteund door: Single, Doubleen BigInteger. Opmerking: Dit wordt alleen aanbevolen voor het BigInteger type. Gebruik Double 'G17' voor Single typen, gebruik 'G9'. Precisieaanduiding: genegeerd. Meer informatie: De round-trip ("R") Format Specifier. |
123456789.12345678 ("R") -> 123456789.12345678 -1234567890.12345678 ("R") -> -1234567890.1234567 |
| "X" of "x" | Hexadecimaal | Resultaat: een hexadecimale tekenreeks. Alleen ondersteund door: Integrale typen. Precisieaanduiding: Aantal cijfers in de resultaattekenreeks. Meer informatie: De Hexadecimale ("X") Format Specifier. |
255 ("X") -> FF -1 ("x") -> ff 255 ("x4") -> 00ff -1 ("X4") -> 00FF |
| Elk ander teken met één 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 coderunner en playground. Selecteer de knop uitvoeren om een voorbeeld uit te voeren in een interactief venster. Zodra u de code hebt uitgevoerd, kunt u deze wijzigen en de gewijzigde code uitvoeren door opnieuw uit te voeren. De gewijzigde code wordt uitgevoerd in het interactieve venster of, als de compilatie mislukt, worden 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:
Het kan worden doorgegeven aan de
TryFormatmethode of een overbelasting van deToStringmethode met eenformatparameter. 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 = 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 dergelijke methoden, zoals String.Format, Console.WriteLineen StringBuilder.AppendFormat. Zie Samengestelde opmaak voor meer informatie. In het volgende voorbeeld wordt een notatie-item gebruikt om een valutawaarde in te voegen in een tekenreeks.decimal value = 123.456m; Console.WriteLine($"Your account balance is {value:C2}."); // Displays "Your account balance is $123.46."Dim value As Decimal = 123.456d Console.WriteLine("Your account balance is {0:C2}.", value) ' Displays "Your account balance is $123.46."U kunt desgewenst 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 in een veld van 28 tekens links uitgelijnd en wordt een valutawaarde rechts uitgelijnd in een veld van 14 tekens.decimal[] amounts = { 16305.32m, 18794.16m }; Console.WriteLine(" Beginning Balance Ending Balance"); Console.WriteLine(" {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]); // Displays: // Beginning Balance Ending Balance // $16,305.32 $18,794.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 voor binaire indeling (B)
De binaire notatieaanduiding ('B') converteert een getal naar een tekenreeks met 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 opgevuld met nullen links om het aantal cijfers te produceren dat wordt opgegeven door de precisieaanduiding.
De resultaattekenreeks wordt niet beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object.
Valutanotatieaanduiding (C)
De notatieaanduiding 'C' (of valuta) converteert een getal naar een tekenreeks die een valutabedrag vertegenwoordigt. De precisieaanduiding geeft het gewenste aantal decimalen in de resultaattekenreeks aan. Als de precisieaanduiding wordt weggelaten, wordt de standaardprecisie gedefinieerd door de NumberFormatInfo.CurrencyDecimalDigits eigenschap.
Als de waarde die moet worden opgemaakt meer dan het opgegeven of standaardaantal decimalen heeft, wordt de breukwaarde afgerond in de resultaattekenreeks. Als de waarde rechts van het opgegeven aantal decimalen 5 of hoger is, wordt het laatste cijfer in de resultaattekenreeks afgerond van nul.
De resultaattekenreeks wordt beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object. De volgende tabel bevat de NumberFormatInfo eigenschappen waarmee de opmaak van de geretourneerde tekenreeks wordt beheerd.
| Eigenschap NumberFormatInfo | Beschrijving |
|---|---|
| CurrencyPositivePattern | Hiermee definieert u 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 integrale en decimale cijfers scheidt. |
| CurrencyGroupSeparator | Hiermee definieert u de tekenreeks die groepen van 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
// 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
Decimaalnotatieaanduiding (D)
De notatieaanduiding D (of decimaal) converteert een getal naar een tekenreeks met 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 opgevuld met nullen links om het aantal cijfers te produceren dat wordt opgegeven door de precisieaanduiding. Als er geen precisieaanduiding is opgegeven, is de standaardwaarde de minimumwaarde die nodig is om het gehele getal weer te geven zonder voorloopnullen.
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.
| Eigenschap NumberFormatInfo | Beschrijving |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
In het volgende voorbeeld wordt een Int32 waarde opgemaakt met de decimaalnotatieaanduiding.
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 van het formulier '-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 wordt altijd voorafgegaan door het decimaalteken.
De precisieaanduiding geeft het gewenste aantal cijfers na het decimaalteken aan. Als de precisieaanduiding wordt weggelaten, wordt een standaardwaarde van zes cijfers na het decimaalteken gebruikt.
In het geval van de notatieaanduiding wordt aangegeven 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 zo 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 waarmee de opmaak van de geretourneerde tekenreeks wordt beheerd.
| Eigenschap NumberFormatInfo | Beschrijving |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is voor zowel de coëfficiënt als de exponent. |
| NumberDecimalSeparator | Definieert 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 exponentiële notatieaanduiding:
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
Indelingsaanduiding met vaste punten (F)
De notatieaanduiding voor vast punt ('F') converteert een getal naar een tekenreeks van het formulier '-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 waarmee de opmaak van de resultaattekenreeks wordt beheerd.
| Eigenschap NumberFormatInfo | Beschrijving |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die integrale cijfers van decimalen scheidt. |
| NumberDecimalDigits | Hiermee definieert u het standaardaantal decimalen. Deze waarde kan worden overschreven met behulp van de precisieaanduiding. |
In het volgende voorbeeld wordt een Double en een Int32 waarde opgemaakt met de opmaakaanduiding 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
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 notatieaanduiding ('G') converteert een getal naar de compactere notatie van vaste punten of wetenschappelijke notatie, afhankelijk van het type getal en of 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 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 (hetzelfde als 'R') |
| Half | Kleinste retourneerbaar aantal cijfers dat het getal aangeeft |
| Single | Het kleinste retourneerbaar aantal cijfers dat het getal aangeeft (in .NET Framework is G7 de standaardinstelling) |
| Double | Het kleinste retourneerbaar aantal cijfers dat het getal aangeeft (in .NET Framework is G15 de standaardinstelling) |
| Decimal | Kleinste retourneerbaar aantal cijfers dat het getal aangeeft |
Notatie met vaste punten wordt gebruikt als de exponent die zou voortvloeien uit het uitdrukken van het getal in de wetenschappelijke notatie groter is dan -5 en kleiner is dan de precisieaanduiding; anders wordt wetenschappelijke notatie gebruikt. Het resultaat bevat indien nodig een decimaalteken en volgnullen na het decimaalteken worden weggelaten. Als de precisieaanduiding aanwezig is en het aantal significante cijfers in het resultaat de opgegeven precisie overschrijdt, worden de overtollige volgcijfers verwijderd door af te ronden.
Als het getal echter een Decimal getal is en de precisieaanduiding wordt weggelaten, wordt de notatie met vaste punten altijd gebruikt en blijven volgnullen behouden.
Als wetenschappelijke notatie wordt gebruikt, wordt de exponent in het resultaat voorafgegaan door 'E' als de notatieaanduiding 'G' of 'e' is als de notatieaanduiding 'g' is. De exponent bevat minimaal twee cijfers. Dit verschilt van de notatie voor wetenschappelijke notatie die wordt geproduceerd door de exponentiële notatieaanduiding, die minimaal drie cijfers in de exponent bevat.
Wanneer deze wordt gebruikt met een Double waarde, zorgt de notatieaanduiding 'G17' ervoor dat de oorspronkelijke Double waarde retourneert. Dit komt doordat Double een IEEE 754-2008-compatibele dubbele precisie (binary64) drijvendekommagetal is dat maximaal 17 significante cijfers van precisie geeft. In .NET Framework raden we het gebruik ervan aan in plaats van de R-indelingsaanduiding, omdat in sommige gevallen 'R' geen dubbele precisie drijvendekommawaarden met dubbele precisie kan afronden.
Wanneer deze wordt gebruikt met een Single waarde, zorgt de notatieaanduiding 'G9' ervoor dat de oorspronkelijke Single waarde met succes wordt afgerond. Dit komt doordat Single een IEEE 754-2008-compatibel drijvendekommagetal (binary32) is dat maximaal negen significante cijfers van precisie geeft. Om prestatieredenen raden we het gebruik ervan 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 waarmee de opmaak van de resultaattekenreeks wordt beheerd.
| Eigenschap NumberFormatInfo | Beschrijving |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die integrale cijfers van decimalen scheidt. |
| PositiveSign | Definieert de tekenreeks die aangeeft dat een exponent positief is. |
In het volgende voorbeeld worden gesorteerde waarden voor drijvende komma 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
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)
De notatieaanduiding ('N') converteert een getal naar een tekenreeks van het formulier '-d,ddd,ddd.ddd...', waarbij '-' indien nodig een negatief getalsymbool aangeeft, 'd' geeft een cijfer aan (0-9), ',' geeft een groepsscheidingsteken aan en '.' geeft een decimaalteken aan. De precisieaanduiding geeft het gewenste aantal cijfers na het decimaalteken aan. Als de precisieaanduiding wordt weggelaten, 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 waarmee de opmaak van de resultaattekenreeks wordt beheerd.
| Eigenschap NumberFormatInfo | Beschrijving |
|---|---|
| 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 tussen groepsscheidingstekens wordt weergegeven. |
| NumberGroupSeparator | Hiermee definieert u de tekenreeks die groepen van integrale getallen scheidt. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die integrale en decimale cijfers scheidt. |
| NumberDecimalDigits | Hiermee definieert u het standaardaantal decimalen. Deze waarde kan worden overschreven met behulp van een precisieaanduiding. |
In het volgende voorbeeld worden gesorteerde waarden voor drijvende komma opgemaakt met de getalnotatieaanduiding:
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 procentnotatie (P)
De notatieaanduiding percentage ('P') vermenigvuldigt een getal met 100 en converteert deze naar een tekenreeks die een percentage vertegenwoordigt. De precisieaanduiding geeft het gewenste aantal decimalen aan. Als de precisieaanduiding wordt weggelaten, wordt de standaard numerieke precisie gebruikt die wordt opgegeven door de huidige PercentDecimalDigits eigenschap.
De volgende tabel bevat de NumberFormatInfo eigenschappen waarmee de opmaak van de geretourneerde tekenreeks wordt beheerd.
| Eigenschap NumberFormatInfo | Beschrijving |
|---|---|
| PercentPositivePattern | Hiermee definieert u de plaatsing van het procentsymbool 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 procentteken. |
| PercentDecimalDigits | Hiermee definieert u het standaardaantal decimalen in een percentagewaarde. Deze waarde kan worden overschreven met behulp van de precisieaanduiding. |
| PercentDecimalSeparator | Hiermee definieert u de tekenreeks die integrale en decimale cijfers scheidt. |
| PercentGroupSeparator | Hiermee definieert u de tekenreeks die groepen van integrale getallen scheidt. |
| PercentGroupSizes | Hiermee definieert u het aantal gehele getallen dat in een groep wordt weergegeven. |
In het volgende voorbeeld worden waarden voor drijvende komma opgemaakt met de aanduiding voor procentnotatie:
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 voor retourritindeling (R)
De notatieaanduiding ('R') probeert ervoor te zorgen dat een numerieke waarde die naar een tekenreeks wordt geconverteerd, weer wordt geparseerd in dezelfde numerieke waarde. Deze indeling wordt alleen ondersteund voor de Halftypen , Singleen DoubleBigInteger typen.
In .NET Framework en in .NET Core-versies die ouder zijn dan 3.0, kan de R-indelingsaanduiding Double in sommige gevallen geen retourwaarden meer afronden. Voor zowel als DoubleSingle waarden biedt de indelingsaanduiding R relatief slechte prestaties. In plaats daarvan raden we u aan de notatieaanduiding 'G17' te gebruiken voor Double waarden en de notatieaanduiding 'G9' om de retourwaarden Single succesvol te afronden.
Wanneer een BigInteger waarde wordt opgemaakt met 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 waarmee de opmaak van de resultaattekenreeks wordt beheerd.
| Eigenschap NumberFormatInfo | Beschrijving |
|---|---|
| NegativeSign | Definieert de tekenreeks die aangeeft dat een getal negatief is. |
| NumberDecimalSeparator | Hiermee definieert u de tekenreeks die integrale cijfers van decimalen scheidt. |
| PositiveSign | Definieert de tekenreeks die aangeeft dat een exponent positief is. |
In het volgende voorbeeld wordt een BigInteger waarde opgemaakt met de aanduiding voor de retour-reisindeling.
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 zijn opgemaakt met de standaardtekenreeks voor numerieke R-notatie, Double niet voltooid als ze zijn gecompileerd met behulp van de /platform:x64 of /platform:anycpu switches en worden uitgevoerd op 64-bits systemen. Zie de volgende alinea voor meer informatie.
Als u het probleem wilt omzeilen van Double waarden die zijn opgemaakt met de standaardtekenreeks voor numerieke notatie 'R', wordt deze niet afgerond als deze is gecompileerd met de /platform:x64 of /platform:anycpu schakelopties en wordt uitgevoerd op 64-bits systemen, kunt u waarden opmaken Double met behulp van de standaardtekenreeks voor numerieke notatie G17. In het volgende voorbeeld wordt de tekenreeks 'R'-indeling gebruikt met een Double waarde die niet met succes 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($"{initialValue:R} = {roundTripped:R}: {initialValue.Equals(roundTripped)}\n");
Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
CultureInfo.InvariantCulture);
Console.WriteLine($"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals(roundTripped17)}\n");
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
// Attempting to round-trip a Double with 'R':
// .NET Framework:
// 0.6822871999174 = 0.68228719991740006: False
// .NET:
// 0.6822871999174 = 0.6822871999174: True
//
// Attempting to round-trip a Double with 'G17':
// 0.6822871999174 = 0.6822871999174: True
Imports System.Globalization
Module Example
Public Sub Main()
Console.WriteLine("Attempting to round-trip a Double with 'R':")
Dim initialValue As Double = 0.6822871999174
Dim valueString As String = initialValue.ToString("R",
CultureInfo.InvariantCulture)
Dim roundTripped As Double = Double.Parse(valueString,
CultureInfo.InvariantCulture)
Console.WriteLine("{0:R} = {1:R}: {2}",
initialValue, roundTripped, initialValue.Equals(roundTripped))
Console.WriteLine()
Console.WriteLine("Attempting to round-trip a Double with 'G17':")
Dim valueString17 As String = initialValue.ToString("G17",
CultureInfo.InvariantCulture)
Dim roundTripped17 As Double = double.Parse(valueString17,
CultureInfo.InvariantCulture)
Console.WriteLine("{0:R} = {1:R}: {2}",
initialValue, roundTripped17, initialValue.Equals(roundTripped17))
End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
' Attempting to round-trip a Double with 'R':
' .NET Framework:
' 0.6822871999174 = 0.68228719991740006: False
' .NET:
' 0.6822871999174 = 0.6822871999174: True
'
' Attempting to round-trip a Double with 'G17':
' 0.6822871999174 = 0.6822871999174: True
Hexadecimale notatieaanduiding (X)
De hexadecimale notatieaanduiding (X) converteert een getal naar een reeks hexadecimale cijfers. In het geval van de notatieaanduiding wordt aangegeven of u hoofdletters of kleine letters wilt gebruiken voor hexadecimale cijfers die groter zijn dan 9. Gebruik bijvoorbeeld 'X' om 'ABCDEF' en 'x' te produceren 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 wordt opgegeven door de precisieaanduiding.
De resultaattekenreeks wordt niet beïnvloed door de opmaakgegevens van het huidige NumberFormatInfo object.
In het volgende voorbeeld worden waarden opgemaakt Int32 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
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
Opmerkingen
Deze sectie bevat aanvullende informatie over het gebruik van tekenreeksen met een standaard numerieke notatie.
Configuratiescherm-instellingen
De instellingen in het item Landinstellingen in het Configuratiescherm zijn van invloed op de resultaattekenreeks die wordt geproduceerd door een opmaakbewerking. Deze instellingen worden gebruikt om het NumberFormatInfo object te initialiseren dat is gekoppeld aan de huidige cultuur, die waarden biedt die worden gebruikt voor het beheren van opmaak. Computers die verschillende instellingen gebruiken, genereren verschillende resultaattekenreeksen.
Als de CultureInfo(String) constructor wordt gebruikt om een nieuw CultureInfo object te instantiëren dat dezelfde cultuur vertegenwoordigt als de huidige systeemcultuur, worden alle aanpassingen die zijn ingesteld door het item Landinstellingen in het Configuratiescherm 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.
Eigenschappen NumberFormatInfo
Opmaak wordt beïnvloed door de eigenschappen van het huidige NumberFormatInfo object, dat impliciet wordt geleverd door de huidige cultuur of expliciet door de parameter van de IFormatProvider methode die opmaak aanroept. Geef een NumberFormatInfo of CultureInfo object op voor die parameter.
Notitie
Zie het NumberFormatInfo klasseonderwerp voor informatie over het aanpassen van de patronen of tekenreeksen die worden gebruikt voor het opmaken van numerieke waarden.
Integrale en numerieke typen drijvende komma
Sommige beschrijvingen van standaardaanduidingen voor numerieke notaties verwijzen naar integrale of numerieke typen drijvende komma. De integrale numerieke typen zijn Byte, , SByte, Int16, Int32, Int64, , UInt16, UInt32, en UInt64BigInteger. De numerieke typen drijvende komma zijn Decimal, Halfen SingleDouble.
Drijvendekomma-infiniteiten en NaN
Ongeacht de notatietekenreeks, is de opgemaakte tekenreeks de waarde van een , of drijvende-kommatype positief oneindig, negatief oneindig of niet een getal (NaN), de opgemaakte tekenreeks de waarde van de respectieve Half, Singleof Double eigenschap die is opgegeven door het momenteel toepasselijke PositiveInfinitySymbol object.NegativeInfinitySymbolNaNSymbolNumberFormatInfo
Codevoorbeeld
In het volgende voorbeeld wordt een integraal en een numerieke waarde met drijvende komma opgemaakt met behulp van de en-US cultuur en alle standaardaanduidingen voor numerieke notaties. In dit voorbeeld worden twee specifieke numerieke typen (DoubleenInt32) gebruikt, maar zouden vergelijkbare resultaten opleveren voor een van de andere numerieke basistypen (Byte, SByte, Int16Int32, , Int64, , UInt16, UInt32, UInt64, BigInteger, , Decimalen ). HalfSingle
// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");
// Output floating point values
double floating = 10761.937554;
Console.WriteLine($"C: {floating.ToString("C", ci)}"); // Displays "C: $10,761.94"
Console.WriteLine($"E: {floating.ToString("E03", ci)}"); // Displays "E: 1.076E+004"
Console.WriteLine($"F: {floating.ToString("F04", ci)}"); // Displays "F: 10761.9376"
Console.WriteLine($"G: {floating.ToString("G", ci)}"); // Displays "G: 10761.937554"
Console.WriteLine($"N: {floating.ToString("N03", ci)}"); // Displays "N: 10,761.938"
Console.WriteLine($"P: {(floating/10000).ToString("P02", ci)}"); // Displays "P: 107.62 %"
Console.WriteLine($"R: {floating.ToString("R", ci)}"); // Displays "R: 10761.937554"
Console.WriteLine();
// Output integral values
int integral = 8395;
Console.WriteLine($"C: {integral.ToString("C", ci)}"); // Displays "C: $8,395.00"
Console.WriteLine($"D: {integral.ToString("D6", ci)}"); // Displays "D: 008395"
Console.WriteLine($"E: {integral.ToString("E03", ci)}"); // Displays "E: 8.395E+003"
Console.WriteLine($"F: {integral.ToString("F01", ci)}"); // Displays "F: 8395.0"
Console.WriteLine($"G: {integral.ToString("G", ci)}"); // Displays "G: 8395"
Console.WriteLine($"N: {integral.ToString("N01", ci)}"); // Displays "N: 8,395.0"
Console.WriteLine($"P: {(integral/10000.0).ToString("P02", ci)}"); // Displays "P: 83.95 %"
Console.WriteLine($"X: 0x{integral.ToString("X", ci)}"); // Displays "X: 0x20CB"
Console.WriteLine();
Option Strict On
Imports System.Globalization
Imports System.Threading
Module NumericFormats
Public Sub Main()
' Display string representations of numbers for en-us culture
Dim ci As New CultureInfo("en-us")
' Output floating point values
Dim floating As Double = 10761.937554
Console.WriteLine("C: {0}", _
floating.ToString("C", ci)) ' Displays "C: $10,761.94"
Console.WriteLine("E: {0}", _
floating.ToString("E03", ci)) ' Displays "E: 1.076E+004"
Console.WriteLine("F: {0}", _
floating.ToString("F04", ci)) ' Displays "F: 10761.9376"
Console.WriteLine("G: {0}", _
floating.ToString("G", ci)) ' Displays "G: 10761.937554"
Console.WriteLine("N: {0}", _
floating.ToString("N03", ci)) ' Displays "N: 10,761.938"
Console.WriteLine("P: {0}", _
(floating / 10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
Console.WriteLine("R: {0}", _
floating.ToString("R", ci)) ' Displays "R: 10761.937554"
Console.WriteLine()
' Output integral values
Dim integral As Integer = 8395
Console.WriteLine("C: {0}", _
integral.ToString("C", ci)) ' Displays "C: $8,395.00"
Console.WriteLine("D: {0}", _
integral.ToString("D6")) ' Displays "D: 008395"
Console.WriteLine("E: {0}", _
integral.ToString("E03", ci)) ' Displays "E: 8.395E+003"
Console.WriteLine("F: {0}", _
integral.ToString("F01", ci)) ' Displays "F: 8395.0"
Console.WriteLine("G: {0}", _
integral.ToString("G", ci)) ' Displays "G: 8395"
Console.WriteLine("N: {0}", _
integral.ToString("N01", ci)) ' Displays "N: 8,395.0"
Console.WriteLine("P: {0}", _
(integral / 10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}", _
integral.ToString("X", ci)) ' Displays "X: 0x20CB"
Console.WriteLine()
End Sub
End Module
Zie ook
Met ons samenwerken op GitHub
De bron voor deze inhoud vindt u op GitHub, waar u ook problemen en pull-aanvragen kunt maken en controleren. Bekijk onze gids voor inzenders voor meer informatie.
