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 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 een aangepaste numerieke notatievoor 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 de maximale precisiewaarde Int32.MaxValue. 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 methode Math.Ceiling, Math.Floorof Math.Round.

    Wanneer precisieaanduiding het aantal fractionele cijfers in de resultaattekenreeks bepaalt, weerspiegelt de resultaattekenreeks een getal dat wordt 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 .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 even aanzienlijk 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 uitlijningsonderdeel in het opmaakitem.

Standaardtekenreeksen voor numerieke notatie worden ondersteund door:

Hint

U kunt het Hulpprogramma voor opmaak downloaden, een .NET Core Windows Forms-toepassing waarmee u notatietekenreeksen kunt toepassen op numerieke of datum- en tijdwaarden en de resultaattekenreeks wordt weergegeven. 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 het codevoorbeeld sectie 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-globalisatie 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: 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 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")
-> 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 Specifier van de vaste puntnotatie ('F').		 1234.567 ("F", en-US)
-> 1234.57

1234.567 ("F", de-DE)
-> 1234,57

1234 ("F1", en-US)
-> 1234.0

1234 ("F1", de-DE)
-> 1234,0

-1234.56 ("F4", en-US)
-> -1234.5600

-1234.56 ("F4", de-DE)
-> -1234.5600
"G" 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

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, 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: Aanbevolen voor het BigInteger type. Gebruik G17 voor Double typen; gebruik G9 voor Single typen.
Precisieaanduiding: genegeerd.

Meer informatie: The 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 code-runner en speelomgeving. 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 TryFormat methode of een overbelasting van de ToString methode met een format parameter. 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 argument formatString in een indelingsitem dat wordt gebruikt met methoden zoals String.Format, Console.WriteLineen StringBuilder.AppendFormat. Zie Samengestelde opmaakvoor meer informatie. In het volgende voorbeeld wordt een notatie-item 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 {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 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 in een veld van 28 tekens links uitgelijnd en wordt een valutawaarde rechts uitgelijnd in een veld van 14 tekens.

    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 argument formatString in een geïnterpoleerd expressie-item van een geïnterpoleerde tekenreeks. Zie het artikel Tekenreeksinterpolatie artikel in de C#-verwijzing of het geïnterpoleerde tekenreeksen artikel 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 eigenschap NumberFormatInfo.CurrencyDecimalDigits.

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 eigenschap NegativeSign.
NegativeSign Definieert het negatieve teken dat wordt gebruikt als CurrencyNegativePattern aangeeft dat er geen haakjes 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
//       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

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 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 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

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 eigenschap NumberFormatInfo.NumberDecimalDigits 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 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 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 precisie geeft. In .NET Framework raden we het gebruik ervan aan in plaats van de 'R'-indelingsaanduiding, omdat in sommige gevallen 'R' dubbele precisie zwevende kommawaarden niet kan afronden.

Wanneer deze wordt gebruikt met een Single waarde, zorgt de notatieaanduiding 'G9' ervoor dat de oorspronkelijke Single waarde retourneert. Dit komt doordat Single een IEEE 754-2008-compatibele single-precision (binary32) drijvendekommagetal is dat maximaal negen significante cijfers precisie geeft. Om prestatieredenen raden we het gebruik ervan aan in plaats van de 'R'-indelingsaanduiding.

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    

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 eigenschap NumberFormatInfo.NumberDecimalDigits.

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 eigenschap NegativeSign.
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 

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 eigenschap PercentDecimalDigits.

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 %

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 typen Half, Single, Doubleen BigInteger.

In .NET Framework en in .NET Core-versies ouder dan 3.0 kan de aanduiding voor de indeling R in sommige gevallen niet worden afgerond Double waarden. Voor zowel Double als Single waarden biedt de indelingsaanduiding R relatief slechte prestaties. In plaats daarvan raden we u aan de 'G17' notatieaanduiding te gebruiken voor Double waarden en de 'G9' notatieaanduiding om Single waarden met succes te afronden.

Wanneer een BigInteger-waarde wordt 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 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.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 Double waarden die zijn opgemaakt met de standaardtekenreeks voor numerieke R-notatie, niet voltooid als deze is 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 R-notatie, wordt deze niet afgerond als deze is gecompileerd met behulp van de schakelopties /platform:x64 of /platform:anycpu en worden uitgevoerd op 64-bits systemen, kunt u Double waarden opmaken 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 succesvol 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. 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 Int32 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

Opmerkingen

Deze sectie bevat aanvullende informatie over het gebruik van tekenreeksen met een standaard numerieke notatie.

Configuratiescherm-instellingen

De instellingen in de Landinstellingen item in het Configuratiescherm zijn van invloed op de resultaattekenreeks die wordt geproduceerd door een opmaakbewerking. Deze instellingen worden gebruikt voor het initialiseren van het NumberFormatInfo object 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 de landinstellingen item 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 IFormatProvider van de methode die opmaak aanroept. Geef een NumberFormatInfo of CultureInfo-object op voor die parameter.

Notitie

Zie het onderwerp NumberFormatInfo klasse 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, UInt64en BigInteger. De numerieke typen drijvende komma zijn Decimal, Half, Singleen Double.

Drijvendekomma-infiniteiten en NaN

Ongeacht de notatietekenreeks, als de waarde van een Half, Singleof Double type drijvende komma positief oneindig, negatief oneindig of niet een getal (NaN) is, is de opgemaakte tekenreeks de waarde van de respectieve PositiveInfinitySymbol, NegativeInfinitySymbolof NaNSymbol eigenschap die is opgegeven door het momenteel toepasselijke NumberFormatInfo-object.

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 (Double en Int32) gebruikt, maar zouden vergelijkbare resultaten opleveren voor een van de andere numerieke basistypen (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, 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