Delen via

Standaardtekenreeksen voor numerieke notatie

  • Artikel

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:

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 TryFormat methode of een overbelasting van de ToString methode die een format parameter 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.46

    decimal value = 123.456m;
Console.WriteLine(value.ToString("C2"));
// Displays $123.46

    Dim value As Decimal = 123.456d
Console.WriteLine(value.ToString("C2"))
' Displays $123.46

  • Het kan worden opgegeven als het formatString argument 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 alignment argument 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.16      

    decimal[] amounts = { 16305.32m, 18794.16m };
Console.WriteLine("   Beginning Balance           Ending Balance");
Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
// Displays:
//        Beginning Balance           Ending Balance
//        $16,305.32                      $18,794.16

    Dim amounts() As Decimal = {16305.32d, 18794.16d}
Console.WriteLine("   Beginning Balance           Ending Balance")
Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
' Displays:
'        Beginning Balance           Ending Balance
'        $16,305.32                      $18,794.16

  • Het kan worden opgegeven als het formatString argument 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':
//       .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. 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