Tekenreeksen voor aangepaste numerieke notatie
U kunt een tekenreeks voor een aangepaste numerieke notatie maken, die bestaat uit een of meer aangepaste numerieke aanduidingen, om te definiëren hoe u numerieke gegevens opmaken. Een tekenreeks met een aangepaste numerieke notatie is een notatietekenreeks die geen standaardtekenreeks met numerieke notatie is.
Tekenreeksen met aangepaste numerieke notatie worden ondersteund door een aantal overbelastingen van de ToString methode van alle numerieke typen. U kunt bijvoorbeeld een tekenreeks voor numerieke notatie opgeven voor de ToString(String) en ToString(String, IFormatProvider) methoden van het Int32 type. Tekenreeksen voor aangepaste numerieke notatie worden ook ondersteund door de functie voor samengestelde .NET-opmaak, die wordt gebruikt door sommige Write methoden en WriteLine methoden van de Console en StreamWriter klassen, de String.Format methode en de StringBuilder.AppendFormat methode. De functie tekenreeksinterpolatie ondersteunt ook tekenreeksen met aangepaste numerieke notatie.
Fooi
U kunt het hulpprogramma Opmaak downloaden, een .NET Core Windows Forms-toepassing waarmee u opmaaktekenreeksen kunt toepassen op numerieke waarden of datum- en tijdwaarden en de resultaattekenreeks kunt weergeven. Broncode is beschikbaar voor C# en Visual Basic.
In de volgende tabel worden de aangepaste numerieke notatieaanduidingen beschreven en wordt voorbeelduitvoer weergegeven die door elke indelingsaanduiding wordt geproduceerd. Zie de sectie Notities voor meer informatie over het gebruik van tekenreeksen met aangepaste numerieke notaties en de sectie Voorbeeld voor een uitgebreide illustratie van het gebruik ervan.
| Opmaakaanduiding | Naam | Beschrijving | Voorbeelden |
|---|---|---|---|
| "0" | Tijdelijke aanduiding nul | Vervangt de nul door het bijbehorende cijfer als er een aanwezig is; anders wordt nul weergegeven in de resultaattekenreeks. Meer informatie: De aangepaste aanduiding 0. |
1234.5678 ("00000") -> 01235 0.45678 ("0,00", en-US) -> 0,46 0.45678 ("0,00", fr-FR) -> 0,46 |
| "#" | Tijdelijke aanduiding voor cijfers | Vervangt het symbool '#' door het bijbehorende cijfer als er een aanwezig is; anders wordt er geen cijfer weergegeven in de resultaattekenreeks. Houd er rekening mee dat er geen cijfer wordt weergegeven in de resultaattekenreeks als het bijbehorende cijfer in de invoertekenreeks een niet-significante 0 is. Bijvoorbeeld 0003 ('####') -> 3. Meer informatie: De aangepaste aanduiding '#'. |
1234.5678 ("#####")-> 1235 0.45678 ("#.#", en-US) -> .46 0.45678 ("#.#", fr-FR) -> ,46 |
| "." | Decimaalteken | Bepaalt de locatie van het decimaalteken in de resultaattekenreeks. Meer informatie: De "." Aangepaste aanduiding. |
0.45678 ("0,00", en-US) -> 0,46 0.45678 ("0,00", fr-FR) -> 0,46 |
| "," | Groepsscheidingsteken en schalen van getallen | Fungeert als een groepsscheidingsteken en een aanduiding voor het schalen van getallen. Als groepsscheidingsteken wordt een gelokaliseerd groepsscheidingsteken tussen elke groep ingevoegd. Als aanduiding voor het schalen van getallen wordt een getal met 1000 gedeeld voor elke opgegeven komma. Meer informatie: De ',' aangepaste aanduiding. |
Aanduiding voor groepsscheidingsteken: 2147483647 ("##,#", en-US) -> 2.147.483.647 2147483647 ("##,#", es-ES) -> 2.147.483.647 Schaalaanduiding: 2147483647 ("#,#,", en-US) -> 2.147 2147483647 ("#,#,", es-ES) -> 2,147 |
| "%" | Tijdelijke aanduiding voor percentage | Vermenigvuldigt een getal met 100 en voegt een gelokaliseerd percentagesymbool in de resultaattekenreeks in. Meer informatie: De aangepaste aanduiding %. |
0.3697 ("%#0.00", en-US) -> %36.97 0.3697 ("%#0,00", el-GR) -> %36,97 0.3697 ("##.0 %", en-US) -> 37,0 % 0,3697 ("###.0 %", el-GR) -> 37,0 % |
| "‰" | Tijdelijke aanduiding per mille | Hiermee wordt een getal vermenigvuldigd met 1000 en wordt een gelokaliseerd per mille-symbool in de resultaattekenreeks ingevoegd. Meer informatie: De aangepaste aanduiding '‰'. |
0.03697 ("#0.00‰", en-US) -> 36,97‰ 0.03697 ("#0.00‰", ru-RU) -> 36,97‰ |
| "E0" "E+0" "E-0" "e0" "e+0" "e-0" |
Exponentiële notatie | Als er ten minste één 0 (nul) wordt gevolgd, wordt het resultaat opgemaakt met exponentiële notatie. Het geval 'E' of 'e' geeft het hoofdlettergebruik aan van het exponentsymbool in de resultaattekenreeks. Het aantal nullen na het teken 'E' of 'e' bepaalt het minimumaantal cijfers in de exponent. Een plusteken (+) geeft aan dat een teken altijd voorafgaat aan de exponent. Een minteken (-) geeft aan dat een teken voorafgaat aan alleen negatieve exponenten. Meer informatie: De aangepaste aanduidingen 'E' en 'e'. |
987654 ("#0.0e0") -> 98.8e4 1503.92311 ("0,0##e+00") -> 1,504e+03 1.8901385E-16 ("0,0e+00") -> 1,9e-16 |
| "\" | Escape-teken | Hiermee wordt het volgende teken geïnterpreteerd als een letterlijke tekst in plaats van als een aangepaste notatieaanduiding. Meer informatie: Het escapeteken '\'. |
987654 ("\###00\#") -> #987654# |
| 'tekenreeks' "tekenreeks" |
Letterlijk tekenreeksscheidingsteken | Geeft aan dat de ingesloten tekens moeten worden gekopieerd naar de resultaattekenreeks ongewijzigd. Meer informatie: letterlijke tekens. |
68 ("# 'degrees') -> 68 graden 68 ('#' graden') -> 68 graden |
| ; | Sectiescheidingsteken | Definieert secties met afzonderlijke notatietekenreeksen voor positieve, negatieve en nul getallen. Meer informatie: De ";" Sectiescheidingsteken. |
12.345 ("#0.0#;( #0.0#);-\0-") -> 12,35 0 ("#0.0#;( #0.0#);-\0-") -> -0- -12.345 ("#0.0#;( #0.0#);-\0-") -> (12,35) 12.345 ("#0.0#;( #0.0#)") -> 12.35 0 ("#0.0#;( #0.0#)") -> 0.0 -12.345 ("#0.0#;( #0.0#)") -> (12.35) |
| Anders | Alle andere tekens | Het teken wordt ongewijzigd gekopieerd naar de resultaattekenreeks. Meer informatie: letterlijke tekens. |
68 ("# °") -> 68 ° |
De volgende secties bevatten gedetailleerde informatie over elk van de aangepaste numerieke notatieaanduidingen.
Notitie
Enkele van de C#-voorbeelden in dit artikel worden uitgevoerd in de Try.NET inline coderunner en playground. Selecteer de knop Uitvoeren om een voorbeeld uit te voeren in een interactief venster. 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 alle C#-compilerfoutberichten weergegeven.
De aangepaste aanduiding 0
De aanduiding voor aangepaste notatie '0' fungeert als een symbool van een tijdelijke aanduiding voor nul. Als de waarde die wordt opgemaakt een cijfer heeft op de positie waar de nul wordt weergegeven in de notatietekenreeks, wordt dat cijfer gekopieerd naar de resultaattekenreeks; anders wordt er een nul weergegeven in de resultaattekenreeks. De positie van de meest linkse nul vóór het decimaalteken en de meest rechtse nul na het decimaalteken bepaalt het bereik van cijfers die altijd aanwezig zijn in de resultaattekenreeks.
De aanduiding '00' zorgt ervoor dat de waarde wordt afgerond op het dichtstbijzijnde cijfer vóór het decimaal, waarbij het afronden van nul altijd wordt gebruikt. Als u bijvoorbeeld 34,5 opmaakt met '00', resulteert dit in de waarde 35.
In het volgende voorbeeld worden verschillende waarden weergegeven die zijn opgemaakt met aangepaste notatietekenreeksen die nul tijdelijke aanduidingen bevatten.
double value;
value = 123;
Console::WriteLine(value.ToString("00000"));
Console::WriteLine(String::Format("{0:00000}", value));
// Displays 00123
value = 1.2;
Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.00}", value));
// Displays 1.20
Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:00.00}", value));
// Displays 01.20
CultureInfo^ daDK = CultureInfo::CreateSpecificCulture("da-DK");
Console::WriteLine(value.ToString("00.00", daDK));
Console::WriteLine(String::Format(daDK, "{0:00.00}", value));
// Displays 01,20
value = .56;
Console::WriteLine(value.ToString("0.0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.0}", value));
// Displays 0.6
value = 1234567890;
Console::WriteLine(value.ToString("0,0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0,0}", value));
// Displays 1,234,567,890
CultureInfo^ elGR = CultureInfo::CreateSpecificCulture("el-GR");
Console::WriteLine(value.ToString("0,0", elGR));
Console::WriteLine(String::Format(elGR, "{0:0,0}", value));
// Displays 1.234.567.890
value = 1234567890.123456;
Console::WriteLine(value.ToString("0,0.0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0,0.0}", value));
// Displays 1,234,567,890.1
value = 1234.567890;
Console::WriteLine(value.ToString("0,0.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0,0.00}", value));
// Displays 1,234.57
double value;
value = 123;
Console.WriteLine(value.ToString("00000"));
Console.WriteLine(String.Format("{0:00000}", value));
// Displays 00123
value = 1.2;
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.00}", value));
// Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:00.00}", value));
// Displays 01.20
CultureInfo daDK = CultureInfo.CreateSpecificCulture("da-DK");
Console.WriteLine(value.ToString("00.00", daDK));
Console.WriteLine(String.Format(daDK, "{0:00.00}", value));
// Displays 01,20
value = .56;
Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.0}", value));
// Displays 0.6
value = 1234567890;
Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0}", value));
// Displays 1,234,567,890
CultureInfo elGR = CultureInfo.CreateSpecificCulture("el-GR");
Console.WriteLine(value.ToString("0,0", elGR));
Console.WriteLine(String.Format(elGR, "{0:0,0}", value));
// Displays 1.234.567.890
value = 1234567890.123456;
Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0.0}", value));
// Displays 1,234,567,890.1
value = 1234.567890;
Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0.00}", value));
// Displays 1,234.57
Dim value As Double
value = 123
Console.WriteLine(value.ToString("00000"))
Console.WriteLine(String.Format("{0:00000}", value))
' Displays 00123
value = 1.2
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.00}", value))
' Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:00.00}", value))
' Displays 01.20
Dim daDK As CultureInfo = CultureInfo.CreateSpecificCulture("da-DK")
Console.WriteLine(value.ToString("00.00", daDK))
Console.WriteLine(String.Format(daDK, "{0:00.00}", value))
' Displays 01,20
value = .56
Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.0}", value))
' Displays 0.6
value = 1234567890
Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0}", value))
' Displays 1,234,567,890
Dim elGR As CultureInfo = CultureInfo.CreateSpecificCulture("el-GR")
Console.WriteLine(value.ToString("0,0", elGR))
Console.WriteLine(String.Format(elGR, "{0:0,0}", value))
' Displays 1.234.567.890
value = 1234567890.123456
Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0.0}", value))
' Displays 1,234,567,890.1
value = 1234.567890
Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0,0.00}", value))
' Displays 1,234.57
De aangepaste aanduiding '#'
De aanduiding voor aangepaste notatie '#' fungeert als een symbool voor een tijdelijke aanduiding voor cijfers. Als de waarde die wordt opgemaakt een cijfer heeft op de positie waar het symbool '#' wordt weergegeven in de notatietekenreeks, wordt dat cijfer gekopieerd naar de resultaattekenreeks. Anders wordt er niets opgeslagen op die positie in de resultaattekenreeks.
Houd er rekening mee dat met deze aanduiding nooit een nul wordt weergegeven die geen significant cijfer is, zelfs als nul het enige cijfer in de tekenreeks is. De waarde wordt alleen nul weergegeven als het een significant cijfer is in het getal dat wordt weergegeven.
De notatietekenreeks ##zorgt ervoor dat de waarde wordt afgerond op het dichtstbijzijnde cijfer vóór het decimaal, waarbij het afronden van nul altijd wordt gebruikt. Als u bijvoorbeeld 34,5 opmaakt met '##', resulteert dit in de waarde 35.
In het volgende voorbeeld worden verschillende waarden weergegeven die zijn opgemaakt met aangepaste notatietekenreeksen die tijdelijke aanduidingen voor cijfers bevatten.
double value;
value = 1.2;
Console::WriteLine(value.ToString("#.##", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#.##}", value));
// Displays 1.2
value = 123;
Console::WriteLine(value.ToString("#####"));
Console::WriteLine(String::Format("{0:#####}", value));
// Displays 123
value = 123456;
Console::WriteLine(value.ToString("[##-##-##]"));
Console::WriteLine(String::Format("{0:[##-##-##]}", value));
// Displays [12-34-56]
value = 1234567890;
Console::WriteLine(value.ToString("#"));
Console::WriteLine(String::Format("{0:#}", value));
// Displays 1234567890
Console::WriteLine(value.ToString("(###) ###-####"));
Console::WriteLine(String::Format("{0:(###) ###-####}", value));
// Displays (123) 456-7890
double value;
value = 1.2;
Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#.##}", value));
// Displays 1.2
value = 123;
Console.WriteLine(value.ToString("#####"));
Console.WriteLine(String.Format("{0:#####}", value));
// Displays 123
value = 123456;
Console.WriteLine(value.ToString("[##-##-##]"));
Console.WriteLine(String.Format("{0:[##-##-##]}", value));
// Displays [12-34-56]
value = 1234567890;
Console.WriteLine(value.ToString("#"));
Console.WriteLine(String.Format("{0:#}", value));
// Displays 1234567890
Console.WriteLine(value.ToString("(###) ###-####"));
Console.WriteLine(String.Format("{0:(###) ###-####}", value));
// Displays (123) 456-7890
Dim value As Double
value = 1.2
Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#.##}", value))
' Displays 1.2
value = 123
Console.WriteLine(value.ToString("#####"))
Console.WriteLine(String.Format("{0:#####}", value))
' Displays 123
value = 123456
Console.WriteLine(value.ToString("[##-##-##]"))
Console.WriteLine(String.Format("{0:[##-##-##]}", value))
' Displays [12-34-56]
value = 1234567890
Console.WriteLine(value.ToString("#"))
Console.WriteLine(String.Format("{0:#}", value))
' Displays 1234567890
Console.WriteLine(value.ToString("(###) ###-####"))
Console.WriteLine(String.Format("{0:(###) ###-####}", value))
' Displays (123) 456-7890
Als u een resultaattekenreeks wilt retourneren waarin ontbrekende cijfers of voorloopnullen worden vervangen door spaties, gebruikt u de functie samengestelde opmaak en geeft u een veldbreedte op, zoals in het volgende voorbeeld wordt geïllustreerd.
using namespace System;
void main()
{
Double value = .324;
Console::WriteLine("The value is: '{0,5:#.###}'", value);
}
// The example displays the following output if the current culture
// is en-US:
// The value is: ' .324'
using System;
public class SpaceOrDigit
{
public static void Main()
{
Double value = .324;
Console.WriteLine("The value is: '{0,5:#.###}'", value);
}
}
// The example displays the following output if the current culture
// is en-US:
// The value is: ' .324'
Module SpaceExample
Public Sub Main()
Dim value As Double = 0.324
Console.WriteLine("The value is: '{0,5:#.###}'", value)
End Sub
End Module
' The example displays the following output if the current culture
' is en-US:
' The value is: ' .324'
De aangepaste aanduiding '.'
Met de aanduiding voor aangepaste notatie wordt een gelokaliseerd decimaalteken in de resultaattekenreeks ingevoegd. De eerste punt in de notatietekenreeks bepaalt de locatie van het decimaalteken in de opgemaakte waarde; eventuele extra perioden worden genegeerd. Als de notatieaanduiding eindigt op een '.' worden alleen de significante cijfers opgemaakt in de resultaattekenreeks.
Het teken dat wordt gebruikt als het decimaalteken in de resultaattekenreeks is niet altijd een punt; dit wordt bepaald door de NumberDecimalSeparator eigenschap van het NumberFormatInfo object waarmee de opmaak wordt bepaald.
In het volgende voorbeeld wordt de notatieaanduiding '.' gebruikt om de locatie van het decimaalteken in verschillende resultaattekenreeksen te definiëren.
double value;
value = 1.2;
Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.00}", value));
// Displays 1.20
Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:00.00}", value));
// Displays 01.20
Console::WriteLine(value.ToString("00.00",
CultureInfo::CreateSpecificCulture("da-DK")));
Console::WriteLine(String::Format(CultureInfo::CreateSpecificCulture("da-DK"),
"{0:00.00}", value));
// Displays 01,20
value = .086;
Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#0.##%}", value));
// Displays 8.6%
value = 86000;
Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.###E+0}", value));
// Displays 8.6E+4
double value;
value = 1.2;
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.00}", value));
// Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:00.00}", value));
// Displays 01.20
Console.WriteLine(value.ToString("00.00",
CultureInfo.CreateSpecificCulture("da-DK")));
Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
"{0:00.00}", value));
// Displays 01,20
value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#0.##%}", value));
// Displays 8.6%
value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+0}", value));
// Displays 8.6E+4
Dim value As Double
value = 1.2
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.00}", value))
' Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:00.00}", value))
' Displays 01.20
Console.WriteLine(value.ToString("00.00", _
CultureInfo.CreateSpecificCulture("da-DK")))
Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
"{0:00.00}", value))
' Displays 01,20
value = .086
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#0.##%}", value))
' Displays 8.6%
value = 86000
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+0}", value))
' Displays 8.6E+4
De aangepaste aanduiding ','
Het teken ',' fungeert als een groepsscheidingsteken en een aanduiding voor het schalen van getallen.
Groepsscheidingsteken: Als een of meer komma's worden opgegeven tussen twee tijdelijke aanduidingen (0 of #) die de integrale cijfers van een getal opmaken, wordt er een groepsscheidingsteken ingevoegd tussen elke getalgroep in het integraal deel van de uitvoer.
De NumberGroupSeparator en NumberGroupSizes eigenschappen van het huidige NumberFormatInfo object bepalen het teken dat wordt gebruikt als het scheidingsteken voor getallengroepen en de grootte van elke getalgroep. Als bijvoorbeeld de tekenreeks '#,#' en de invariante cultuur worden gebruikt om het getal 1000 op te maken, is de uitvoer '1000'.
Aanduiding voor het schalen van getallen: als een of meer komma's direct links van het expliciete of impliciete decimaalteken worden opgegeven, wordt het getal dat moet worden opgemaakt, gedeeld door 1000 voor elke komma. Als de tekenreeks '0' bijvoorbeeld wordt gebruikt om het getal 100 miljoen op te maken, is de uitvoer '100'.
U kunt groepsscheidingstekens en schaalaanduidingen voor getallen in dezelfde notatietekenreeks gebruiken. Als de tekenreeks #,0 en de invariante cultuur bijvoorbeeld worden gebruikt om het getal één miljard op te maken, is de uitvoer '1000'.
In het volgende voorbeeld ziet u het gebruik van de komma als groepsscheidingsteken.
double value = 1234567890;
Console::WriteLine(value.ToString("#,#", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,#}", value));
// Displays 1,234,567,890
Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,##0,,}", value));
// Displays 1,235
double value = 1234567890;
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,#}", value));
// Displays 1,234,567,890
Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,##0,,}", value));
// Displays 1,235
Dim value As Double = 1234567890
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,#}", value))
' Displays 1,234,567,890
Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,##0,,}", value))
' Displays 1,235
In het volgende voorbeeld ziet u het gebruik van de komma als een aanduiding voor het schalen van getallen.
double value = 1234567890;
Console::WriteLine(value.ToString("#,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,,}", value));
// Displays 1235
Console::WriteLine(value.ToString("#,,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,,,}", value));
// Displays 1
Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#,##0,,}", value));
// Displays 1,235
double value = 1234567890;
Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,,}", value));
// Displays 1235
Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,,,}", value));
// Displays 1
Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,##0,,}", value));
// Displays 1,235
Dim value As Double = 1234567890
Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "{0:#,,}", value))
' Displays 1235
Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,,,}", value))
' Displays 1
Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#,##0,,}", value))
' Displays 1,235
De aangepaste aanduiding %
Een procentteken (%) in een notatietekenreeks zorgt ervoor dat een getal wordt vermenigvuldigd met 100 voordat het wordt opgemaakt. Het gelokaliseerde procentsymbool wordt ingevoegd in het getal op de locatie waar het percentage wordt weergegeven in de notatietekenreeks. Het gebruikte percentageteken wordt gedefinieerd door de PercentSymbol eigenschap van het huidige NumberFormatInfo object.
In het volgende voorbeeld worden verschillende tekenreeksen voor aangepaste notatie gedefinieerd die de aangepaste aanduiding %bevatten.
double value = .086;
Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:#0.##%}", value));
// Displays 8.6%
double value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#0.##%}", value));
// Displays 8.6%
Dim value As Double = .086
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:#0.##%}", value))
' Displays 8.6%
De aangepaste aanduiding ‰
Een teken per mille (‰ of \u2030) in een notatietekenreeks zorgt ervoor dat een getal wordt vermenigvuldigd met 1000 voordat het wordt opgemaakt. Het juiste symbool voor mille wordt ingevoegd in de geretourneerde tekenreeks op de locatie waar het symbool ‰ wordt weergegeven in de notatietekenreeks. Het gebruikte milleteken wordt gedefinieerd door de NumberFormatInfo.PerMilleSymbol eigenschap van het object dat cultuurspecifieke opmaakinformatie biedt.
In het volgende voorbeeld wordt een aangepaste notatietekenreeks gedefinieerd die de aangepaste aanduiding '‰' bevat.
double value = .00354;
String^ perMilleFmt = "#0.## " + '\u2030';
Console::WriteLine(value.ToString(perMilleFmt, CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:" + perMilleFmt + "}", value));
// Displays 3.54‰
double value = .00354;
string perMilleFmt = "#0.## " + '\u2030';
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:" + perMilleFmt + "}", value));
// Displays 3.54‰
Dim value As Double = .00354
Dim perMilleFmt As String = "#0.## " & ChrW(&h2030)
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:" + perMilleFmt + "}", value))
' Displays 3.54 ‰
De aangepaste aanduidingen 'E' en 'e'
Als een van de tekenreeksen "E", "E+", "E-", "e", "e+" of "e-" aanwezig is in de notatietekenreeks en onmiddellijk wordt gevolgd door ten minste één nul, wordt het getal opgemaakt met behulp van wetenschappelijke notatie met een "E" of "e" ingevoegd tussen het getal en de exponent. Het aantal nullen na de wetenschappelijke notatieindicator bepaalt het minimumaantal cijfers dat moet worden uitgevoerd voor de exponent. De notatie 'E+' en 'e+' geven aan dat een plusteken of minteken altijd vóór de exponent moet gaan. De notatie 'E', 'E-', 'e' of 'e-' geeft aan dat een tekenteken alleen voor negatieve exponenten moet gaan.
In het volgende voorbeeld worden verschillende numerieke waarden opgemaakt met behulp van de aanduidingen voor wetenschappelijke notatie.
double value = 86000;
Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.###E+0}", value));
// Displays 8.6E+4
Console::WriteLine(value.ToString("0.###E+000", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.###E+000}", value));
// Displays 8.6E+004
Console::WriteLine(value.ToString("0.###E-000", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture,
"{0:0.###E-000}", value));
// Displays 8.6E004
double value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+0}", value));
// Displays 8.6E+4
Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+000}", value));
// Displays 8.6E+004
Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E-000}", value));
// Displays 8.6E004
Dim value As Double = 86000
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+0}", value))
' Displays 8.6E+4
Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E+000}", value))
' Displays 8.6E+004
Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
"{0:0.###E-000}", value))
' Displays 8.6E004
Het escape-teken '\'
De symbolen "#", "0", ".", ",", "%" en "‰" in een notatietekenreeks worden geïnterpreteerd als notatieaanduidingen in plaats van als letterlijke tekens. Afhankelijk van hun positie in een tekenreeks met aangepaste notatie, kunnen de hoofdletters en kleine letters 'E' en de symbolen + en - ook worden geïnterpreteerd als opmaakaanduidingen.
Als u wilt voorkomen dat een teken wordt geïnterpreteerd als opmaakaanduiding, kunt u dit voorafgaan door een backslash, het escape-teken. Het escapeteken geeft aan dat het volgende teken een letterlijke tekenreeks is die niet moet worden opgenomen in de resultaattekenreeks.
Als u een backslash wilt opnemen in een resultaattekenreeks, moet u deze escapen met een andere backslash (\\).
Notitie
Sommige compilers, zoals de C++- en C#-compilers, kunnen ook één backslash-teken interpreteren als een escape-teken. Als u ervoor wilt zorgen dat een tekenreeks correct wordt geïnterpreteerd bij het opmaken, kunt u het letterlijke teken van de letterlijke tekenreeks (het @-teken) voor de tekenreeks in C# gebruiken of een ander backslash-teken toevoegen vóór elke backslash in C# en C++. In het volgende C#-voorbeeld ziet u beide benaderingen.
In het volgende voorbeeld wordt het escapeteken gebruikt om te voorkomen dat de opmaakbewerking de tekens '#', '0' en '\' interpreteert als escapetekens of opmaakaanduidingen. In de C#-voorbeelden wordt een extra backslash gebruikt om ervoor te zorgen dat een backslash wordt geïnterpreteerd als een letterlijk teken.
int value = 123;
Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console::WriteLine(String::Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
value));
// Displays ### 123 dollars and 00 cents ###
Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#"));
Console::WriteLine(String::Format("{0:\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#}",
value));
// Displays ### 123 dollars and 00 cents ###
Console::WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console::WriteLine(String::Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
value));
// Displays \\\ 123 dollars and 00 cents \\\
Console::WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console::WriteLine(String::Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
value));
// Displays \\\ 123 dollars and 00 cents \\\
int value = 123;
Console.WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console.WriteLine(String.Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
value));
// Displays ### 123 dollars and 00 cents ###
Console.WriteLine(value.ToString(@"\#\#\# ##0 dollars and \0\0 cents \#\#\#"));
Console.WriteLine(String.Format(@"{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
value));
// Displays ### 123 dollars and 00 cents ###
Console.WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console.WriteLine(String.Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
value));
// Displays \\\ 123 dollars and 00 cents \\\
Console.WriteLine(value.ToString(@"\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console.WriteLine(String.Format(@"{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
value));
// Displays \\\ 123 dollars and 00 cents \\\
Dim value As Integer = 123
Console.WriteLine(value.ToString("\#\#\# ##0 dollars and \0\0 cents \#\#\#"))
Console.WriteLine(String.Format("{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
value))
' Displays ### 123 dollars and 00 cents ###
Console.WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"))
Console.WriteLine(String.Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
value))
' Displays \\\ 123 dollars and 00 cents \\\
Het scheidingsteken voor de sectie ';'
De puntkomma (;) is een voorwaardelijke opmaakaanduiding die verschillende opmaak toepast op een getal, afhankelijk van of de waarde positief, negatief of nul is. Om dit gedrag te produceren, kan een tekenreeks met aangepaste notatie maximaal drie secties bevatten, gescheiden door puntkomma's. Deze secties worden beschreven in de volgende tabel.
| Aantal secties | Omschrijving |
|---|---|
| Eén sectie | De notatietekenreeks is van toepassing op alle waarden. |
| Twee secties | De eerste sectie is van toepassing op positieve waarden en nullen, en de tweede sectie is van toepassing op negatieve waarden. Als het getal dat moet worden opgemaakt negatief is, maar nul wordt na afronding volgens de notatie in de tweede sectie, wordt de resulterende nul opgemaakt volgens de eerste sectie. |
| Drie secties | De eerste sectie is van toepassing op positieve waarden, de tweede sectie is van toepassing op negatieve waarden en de derde sectie is van toepassing op nullen. De tweede sectie kan leeg blijven (door niets tussen de puntkomma's te hebben), in welk geval de eerste sectie van toepassing is op alle niet-nulwaarden. Als het getal dat moet worden opgemaakt, niet-nul is, maar nul wordt na afronding volgens de notatie in de eerste of tweede sectie, wordt de resulterende nul opgemaakt volgens de derde sectie. |
Sectiescheidingstekens negeren alle bestaande opmaak die aan een getal is gekoppeld wanneer de uiteindelijke waarde is opgemaakt. Negatieve waarden worden bijvoorbeeld altijd weergegeven zonder minteken wanneer sectiescheidingstekens worden gebruikt. Als u wilt dat de uiteindelijke opgemaakte waarde een minteken heeft, moet u het minteken expliciet opnemen als onderdeel van de aangepaste notatieaanduiding.
In het volgende voorbeeld wordt de notatieaanduiding ';' gebruikt om positieve, negatieve en nul getallen anders op te maken.
double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;
String^ fmt2 = "##;(##)";
String^ fmt3 = "##;(##);**Zero**";
Console::WriteLine(posValue.ToString(fmt2));
Console::WriteLine(String::Format("{0:" + fmt2 + "}", posValue));
// Displays 1234
Console::WriteLine(negValue.ToString(fmt2));
Console::WriteLine(String::Format("{0:" + fmt2 + "}", negValue));
// Displays (1234)
Console::WriteLine(zeroValue.ToString(fmt3));
Console::WriteLine(String::Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**
double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;
string fmt2 = "##;(##)";
string fmt3 = "##;(##);**Zero**";
Console.WriteLine(posValue.ToString(fmt2));
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue));
// Displays 1234
Console.WriteLine(negValue.ToString(fmt2));
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue));
// Displays (1234)
Console.WriteLine(zeroValue.ToString(fmt3));
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**
Dim posValue As Double = 1234
Dim negValue As Double = -1234
Dim zeroValue As Double = 0
Dim fmt2 As String = "##;(##)"
Dim fmt3 As String = "##;(##);**Zero**"
Console.WriteLine(posValue.ToString(fmt2))
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue))
' Displays 1234
Console.WriteLine(negValue.ToString(fmt2))
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue))
' Displays (1234)
Console.WriteLine(zeroValue.ToString(fmt3))
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue))
' Displays **Zero**
Letterlijke tekens
Opmaakaanduidingen die worden weergegeven in een aangepaste tekenreeks voor numerieke notatie, worden altijd geïnterpreteerd als opmaaktekens en nooit als letterlijke tekens. Dit omvat de volgende tekens:
Alle andere tekens worden altijd geïnterpreteerd als letterlijke tekens en worden in een opmaakbewerking ongewijzigd in de resultaattekenreeks opgenomen. In een parseringsbewerking moeten ze exact overeenkomen met de tekens in de invoertekenreeks; de vergelijking hoofdlettergevoelig is.
In het volgende voorbeeld ziet u één gemeenschappelijk gebruik van letterlijke tekeneenheden (in dit geval duizenden):
double n = 123.8;
Console.WriteLine($"{n:#,##0.0K}");
// The example displays the following output:
// 123.8K
Dim n As Double = 123.8
Console.WriteLine($"{n:#,##0.0K}")
' The example displays the following output:
' 123.8K
Er zijn twee manieren om aan te geven dat tekens moeten worden geïnterpreteerd als letterlijke tekens en niet als opmaaktekens, zodat ze kunnen worden opgenomen in een resultaattekenreeks of met succes worden geparseerd in een invoertekenreeks:
Door een opmaakteken te ontsnappen. Zie het escape-teken '\' voor meer informatie.
Door de hele letterlijke tekenreeks tussen aanhalingstekens te plaatsen.
In het volgende voorbeeld worden beide benaderingen gebruikt om gereserveerde tekens op te nemen in een aangepaste tekenreeks voor numerieke notatie.
double n = 9.3;
Console.WriteLine($@"{n:##.0\%}");
Console.WriteLine($@"{n:\'##\'}");
Console.WriteLine($@"{n:\\##\\}");
Console.WriteLine();
Console.WriteLine($"{n:##.0'%'}");
Console.WriteLine($@"{n:'\'##'\'}");
// The example displays the following output:
// 9.3%
// '9'
// \9\
//
// 9.3%
// \9\
Dim n As Double = 9.3
Console.WriteLine($"{n:##.0\%}")
Console.WriteLine($"{n:\'##\'}")
Console.WriteLine($"{n:\\##\\}")
Console.WriteLine()
Console.WriteLine($"{n:##.0'%'}")
Console.WriteLine($"{n:'\'##'\'}")
' The example displays the following output:
' 9.3%
' '9'
' \9\
'
' 9.3%
' \9\
Aantekeningen
Drijvendekomma-infiniteiten en NaN
Ongeacht de notatietekenreeks, is de opgemaakte tekenreeks de waarde van een , of drijvende-kommatype positief oneindig, negatief oneindig of niet een getal (NaN), de opgemaakte tekenreeks de waarde van het respectieve PositiveInfinitySymbol, NegativeInfinitySymbolof NaNSymbol de eigenschap die is opgegeven door het momenteel toepasselijke NumberFormatInfo object.DoubleSingleHalf
Configuratiescherm-instellingen
De instellingen in het item Landinstellingen in Configuratiescherm invloed hebben op de resultaattekenreeks die wordt geproduceerd door een opmaakbewerking. Deze instellingen worden gebruikt om het NumberFormatInfo object te initialiseren dat is gekoppeld aan de huidige cultuur en de huidige cultuur biedt waarden die worden gebruikt voor het beheren van opmaak. Computers die verschillende instellingen gebruiken, genereren verschillende resultaattekenreeksen.
Als u de CultureInfo(String) constructor gebruikt om een nieuw CultureInfo object te instantiëren dat dezelfde cultuur vertegenwoordigt als de huidige systeemcultuur, worden alle aanpassingen die zijn ingesteld door het item Landinstellingen in 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.
Tekenreeksen afronden en opmaak met vaste punten
Voor tekenreeksen met een vaste puntnotatie (dat wil gezegd, notatietekens opmaken die geen wetenschappelijke notatietekens bevatten), worden getallen afgerond op zoveel decimalen als er tijdelijke aanduidingen voor cijfers rechts van het decimaalteken staan. Als de notatietekenreeks geen decimaalteken bevat, wordt het getal afgerond op het dichtstbijzijnde gehele getal. Als het getal meer cijfers bevat dan er tijdelijke aanduidingen voor cijfers links van het decimaalteken staan, worden de extra cijfers direct vóór de eerste tijdelijke aanduiding voor cijfers gekopieerd naar de resultaattekenreeks.
voorbeeld
In het volgende voorbeeld ziet u twee tekenreeksen met een aangepaste numerieke notatie. In beide gevallen worden in de tijdelijke aanduiding voor cijfers (#) de numerieke gegevens weergegeven en worden alle andere tekens gekopieerd naar de resultaattekenreeks.
double number1 = 1234567890;
String^ value1 = number1.ToString("(###) ###-####");
Console::WriteLine(value1);
int number2 = 42;
String^ value2 = number2.ToString("My Number = #");
Console::WriteLine(value2);
// The example displays the following output:
// (123) 456-7890
// My Number = 42
double number1 = 1234567890;
string value1 = number1.ToString("(###) ###-####");
Console.WriteLine(value1);
int number2 = 42;
string value2 = number2.ToString("My Number = #");
Console.WriteLine(value2);
// The example displays the following output:
// (123) 456-7890
// My Number = 42
Dim number1 As Double = 1234567890
Dim value1 As String = number1.ToString("(###) ###-####")
Console.WriteLine(value1)
Dim number2 As Integer = 42
Dim value2 As String = number2.ToString("My Number = #")
Console.WriteLine(value2)
' The example displays the following output:
' (123) 456-7890
' My Number = 42
Zie ook
Feedback
Binnenkort: Gedurende 2024 worden GitHub Issues uitgefaseerd als het feedbackmechanisme voor inhoud. Dit wordt vervangen door een nieuw feedbacksysteem. Ga voor meer informatie naar: https://aka.ms/ContentUserFeedback.
Feedback verzenden en bekijken voor