NumberFormatInfo Klas

Definitie

Naamruimte:

System.Globalization

Assembly's:

netstandard.dll, System.Runtime.dll

Bron:

NumberFormatInfo.cs

Biedt cultuurspecifieke informatie voor het opmaken en parseren van numerieke waarden.

public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider

public sealed class NumberFormatInfo : ICloneable, IFormatProvider

type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider

Public NotInheritable Class NumberFormatInfo
Implements ICloneable, IFormatProvider

Overname

Object

NumberFormatInfo

Implementeringen

IFormatProvider ICloneable

Opmerkingen

De NumberFormatInfo klasse bevat cultuurspecifieke informatie die wordt gebruikt bij het opmaken en parseren van numerieke waarden. Deze informatie omvat het valutasymbool, het decimaalteken, het groepsscheidingsteken en de symbolen voor positieve en negatieve tekens.

Een NumberFormatInfo-object instantiëren

U kunt een NumberFormatInfo object instantiëren dat de opmaakconventies van de huidige cultuur, de invariante cultuur, een specifieke cultuur of een neutrale cultuur vertegenwoordigt.

Een NumberFormatInfo-object instantiëren voor de huidige cultuur

U kunt op een van de volgende manieren een NumberFormatInfo object instantiëren voor de huidige cultuur. In elk geval is het geretourneerde NumberFormatInfo object alleen voor lezen.

• Door een CultureInfo object op te halen dat de huidige cultuur vertegenwoordigt vanuit de CultureInfo.CurrentCulture eigenschap, en vervolgens het NumberFormatInfo object op te halen uit zijn CultureInfo.NumberFormat eigenschap.

• Door het NumberFormatInfo object op te halen dat wordt geretourneerd door de static (Shared in Visual Basic) CurrentInfo eigenschap.

• Door de GetInstance methode aan te roepen met een CultureInfo object dat de huidige cultuur vertegenwoordigt.

In het volgende voorbeeld worden deze drie manieren gebruikt om objecten te maken NumberFormatInfo die de opmaakconventies van de huidige cultuur vertegenwoordigen. Ook wordt de waarde van de IsReadOnly eigenschap opgehaald om aan te geven dat elk object het kenmerk Alleen-lezen heeft.

using System;
using System.Globalization;

public class InstantiateEx1
{
    public static void Main()
    {
        NumberFormatInfo current1 = CultureInfo.CurrentCulture.NumberFormat;
        Console.WriteLine(current1.IsReadOnly);

        NumberFormatInfo current2 = NumberFormatInfo.CurrentInfo;
        Console.WriteLine(current2.IsReadOnly);

        NumberFormatInfo current3 = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture);
        Console.WriteLine(current3.IsReadOnly);
    }
}
// The example displays the following output:
//       True
//       True
//       True

U kunt op een van de volgende manieren een beschrijfbaar NumberFormatInfo object maken dat de conventies van de huidige cultuur vertegenwoordigt:

• Door een NumberFormatInfo object op te halen op een van de manieren die in het vorige codevoorbeeld worden geïllustreerd en de Clone methode voor het geretourneerde NumberFormatInfo object aan te roepen. Hiermee maakt u een kopie van het oorspronkelijke NumberFormatInfo object, met als enige verschil dat de IsReadOnly eigenschap false is.

• Door de CultureInfo.CreateSpecificCulture methode aan te roepen om een CultureInfo object te maken dat de huidige cultuur vertegenwoordigt en vervolgens de eigenschap ervan te gebruiken CultureInfo.NumberFormat om het NumberFormatInfo object op te halen.

Het volgende voorbeeld illustreert deze twee manieren om een NumberFormatInfo-object te creëren en geeft de waarde van de IsReadOnly-eigenschap weer om te illustreren dat het object niet alleen-lezen is.

using System;
using System.Globalization;

public class InstantiateEx2
{
    public static void Main()
    {
        NumberFormatInfo current1 = NumberFormatInfo.CurrentInfo;
        current1 = (NumberFormatInfo)current1.Clone();
        Console.WriteLine(current1.IsReadOnly);

        CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
        NumberFormatInfo current2 = culture2.NumberFormat;
        Console.WriteLine(current2.IsReadOnly);
    }
}
// The example displays the following output:
//       False
//       False

Houd er rekening mee dat de gebruiker met het Windows-besturingssysteem bepaalde NumberFormatInfo eigenschapswaarden die in numerieke opmaak en parseringsbewerkingen worden gebruikt, kan overschrijven via het item Regio en Taal in het Configuratiescherm. Een gebruiker van wie de cultuur Engels (Verenigde Staten) is, kan er bijvoorbeeld voor kiezen om valutawaarden weer te geven als 1,1 USD in plaats van de standaardwaarde van $ 1,1. De NumberFormatInfo objecten die op de eerder besproken manieren zijn opgehaald, weerspiegelen allemaal de aanpassingen van deze gebruikers. Als dit ongewenst is, kunt u een NumberFormatInfo object maken dat geen gebruikersoverschrijvingen weergeeft (en dat ook lees- en schrijfbaar is in plaats van alleen-lezen) door de CultureInfo.CultureInfo(String, Boolean) constructor aan te roepen en een waarde van false voor het useUserOverride argument op te geven. In het volgende voorbeeld ziet u een afbeelding van een systeem waarvan de huidige cultuur Engels (Verenigde Staten) is en waarvan het valutasymbool is gewijzigd van de standaardwaarde van $ in USD.

using System;
using System.Globalization;

public class InstantiateEx3
{
    public static void Main()
    {
        CultureInfo culture;
        NumberFormatInfo nfi;

        culture = CultureInfo.CurrentCulture;
        nfi = culture.NumberFormat;
        Console.WriteLine($"Culture Name:    {culture.Name}");
        Console.WriteLine($"User Overrides:  {culture.UseUserOverride}");
        Console.WriteLine($"Currency Symbol: {culture.NumberFormat.CurrencySymbol}\n");

        culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
        Console.WriteLine($"Culture Name:    {culture.Name}");
        Console.WriteLine($"User Overrides:  {culture.UseUserOverride}");
        Console.WriteLine($"Currency Symbol: {culture.NumberFormat.CurrencySymbol}");
    }
}
// The example displays the following output:
//       Culture Name:    en-US
//       User Overrides:  True
//       Currency Symbol: USD
//
//       Culture Name:    en-US
//       User Overrides:  False
//       Currency Symbol: $

Als de CultureInfo.UseUserOverride eigenschap is ingesteld op true, worden de eigenschappen CultureInfo.DateTimeFormat, CultureInfo.NumberFormat en CultureInfo.TextInfo ook opgehaald uit de gebruikersinstellingen. Als de gebruikersinstellingen niet compatibel zijn met de cultuur die aan het CultureInfo object is gekoppeld (bijvoorbeeld als de geselecteerde agenda niet een van de agenda's is die door de OptionalCalendars eigenschap worden vermeld), zijn de resultaten van de methoden en de waarden van de eigenschappen niet gedefinieerd.

Een NumberFormatInfo-object instantiëren voor de invariante cultuur

De invariante cultuur vertegenwoordigt een cultuur die niet gevoelig is voor cultuur. Het is gebaseerd op de Engelse taal, maar niet op een specifiek Engels sprekend land/regio. Hoewel de gegevens van specifieke culturen dynamisch kunnen zijn en kunnen veranderen in overeenstemming met nieuwe culturele conventies of gebruikersvoorkeuren, veranderen de gegevens van de invariante cultuur niet. Een NumberFormatInfo object dat de opmaakconventies van de invariante cultuur vertegenwoordigt, kan worden gebruikt voor opmaakbewerkingen waarin resultaattekenreeksen niet per cultuur moeten verschillen.

U kunt op de volgende manieren een exemplaar maken van een NumberFormatInfo object dat de opmaakconventies van de invariante cultuur vertegenwoordigt:

• Door de waarde van de InvariantInfo eigenschap op te halen. Het geretourneerde NumberFormatInfo object heeft het kenmerk Alleen-lezen.

• Door de waarde van de CultureInfo.NumberFormat eigenschap op te halen uit het CultureInfo object dat wordt geretourneerd door de CultureInfo.InvariantCulture eigenschap. Het geretourneerde NumberFormatInfo object heeft het kenmerk Alleen-lezen.

• Door de parameterloze NumberFormatInfo klasseconstructor aan te roepen. Het geretourneerde NumberFormatInfo object is lees- en schrijfbaar.

In het volgende voorbeeld wordt elk van deze methoden gebruikt om een NumberFormatInfo object te instantiëren dat de invariante cultuur vertegenwoordigt. Vervolgens wordt aangegeven of het object alleen-lezen is,

using System;
using System.Globalization;

public class InstantiateEx4
{
    public static void Main()
    {
        NumberFormatInfo nfi;

        nfi = System.Globalization.NumberFormatInfo.InvariantInfo;
        Console.WriteLine(nfi.IsReadOnly);

        nfi = CultureInfo.InvariantCulture.NumberFormat;
        Console.WriteLine(nfi.IsReadOnly);

        nfi = new NumberFormatInfo();
        Console.WriteLine(nfi.IsReadOnly);
    }
}
// The example displays the following output:
//       True
//       True
//       False

Een NumberFormatInfo-object instantiëren voor een specifieke cultuur

Een specifieke cultuur vertegenwoordigt een taal die wordt gesproken in een bepaald land/bepaalde regio. En-US is bijvoorbeeld een specifieke cultuur die de Engelse taal vertegenwoordigt die in de Verenigde Staten wordt gesproken en-CA een specifieke cultuur is die de Engelse taal vertegenwoordigt die in Canada wordt gesproken. U kunt op de volgende manieren een exemplaar maken van een NumberFormatInfo object dat de opmaakconventies van een specifieke cultuur vertegenwoordigt:

• Door de CultureInfo.GetCultureInfo(String) methode aan te roepen en de waarde van de CultureInfo eigenschap van het geretourneerde NumberFormat object op te halen. Het geretourneerde NumberFormatInfo object heeft het kenmerk Alleen-lezen.

• Door een CultureInfo object door te geven aan de statische NumberFormatInfo methode, waarbij het GetInstance object de cultuur vertegenwoordigt die u wilt ophalen. Het geretourneerde NumberFormatInfo object is lees- en schrijfbaar.

• Door de CultureInfo.CreateSpecificCulture methode aan te roepen en de waarde van de CultureInfo eigenschap van het geretourneerde NumberFormat object op te halen. Het geretourneerde NumberFormatInfo object is lees- en schrijfbaar.

• Door een klasseconstructor van CultureInfo.CultureInfo aan te roepen en vervolgens de waarde van de eigenschap CultureInfo van het geretourneerde NumberFormat object op te halen. Het geretourneerde NumberFormatInfo object is lees- en schrijfbaar.

In het volgende voorbeeld worden deze vier manieren gebruikt om een NumberFormatInfo object te maken dat de opmaakconventies van de Indonesische cultuur (Indonesië) weerspiegelt. Ook wordt aangegeven of elk object het kenmerk Alleen-lezen heeft.

using System;
using System.Globalization;

public class InstantiateEx5
{
    public static void Main()
    {
        CultureInfo culture;
        NumberFormatInfo nfi;

        nfi = CultureInfo.GetCultureInfo("id-ID").NumberFormat;
        Console.WriteLine($"Read-only: {nfi.IsReadOnly}");

        culture = new CultureInfo("id-ID");
        nfi = NumberFormatInfo.GetInstance(culture);
        Console.WriteLine($"Read-only: {nfi.IsReadOnly}");

        culture = CultureInfo.CreateSpecificCulture("id-ID");
        nfi = culture.NumberFormat;
        Console.WriteLine($"Read-only: {nfi.IsReadOnly}");

        culture = new CultureInfo("id-ID");
        nfi = culture.NumberFormat;
        Console.WriteLine($"Read-only: {nfi.IsReadOnly}");
    }
}
// The example displays the following output:
//       Read-only: True
//       Read-only: False
//       Read-only: False
//       Read-only: False

Een NumberFormatInfo-object instantiëren voor een neutrale cultuur

Een neutrale cultuur vertegenwoordigt een cultuur of taal die onafhankelijk is van een land/regio. Het is meestal de oorsprong van een of meer specifieke culturen. fr is bijvoorbeeld een neutrale cultuur voor de Franse taal en de ouder van de cultuur fr-FR. U maakt een NumberFormatInfo object dat de opmaakconventies van een neutrale cultuur vertegenwoordigt op dezelfde manier als u een NumberFormatInfo object maakt dat de opmaakconventies van een specifieke cultuur vertegenwoordigt.

Omdat het echter onafhankelijk is van een specifiek land/regio, ontbreekt een neutrale cultuur aan cultuurspecifieke opmaakinformatie. In plaats van het NumberFormatInfo object te vullen met algemene waarden, retourneert .NET een NumberFormatInfo object dat de opmaakconventies weerspiegelt van een specifieke cultuur die een onderliggend element van de neutrale cultuur is. Het object voor de neutrale cultuur weerspiegelt bijvoorbeeld NumberFormatInfo de opmaakconventies van de en-US-cultuur en het NumberFormatInfo object voor de fr-cultuur weerspiegelt de opmaakconventies van de fr-FR-cultuur.

U kunt code zoals de volgende gebruiken om te bepalen welke specifieke cultuuropmaakconventies elke neutrale cultuur vertegenwoordigt.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;

public class InstantiateEx6
{
    public static void Main()
    {
        // Get all the neutral cultures
        List<String> names = new List<String>();
        Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                      culture => names.Add(culture.Name));
        names.Sort();
        foreach (var name in names)
        {
            // Ignore the invariant culture.
            if (name == "") continue;

            ListSimilarChildCultures(name);
        }
    }

    private static void ListSimilarChildCultures(string name)
    {
        // Create the neutral NumberFormatInfo object.
        NumberFormatInfo nfi = CultureInfo.GetCultureInfo(name).NumberFormat;
        // Retrieve all specific cultures of the neutral culture.
        CultureInfo[] cultures = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures),
                                 culture => culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase));
        // Create an array of NumberFormatInfo properties
        PropertyInfo[] properties = typeof(NumberFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
        bool hasOneMatch = false;

        foreach (var ci in cultures)
        {
            bool match = true;
            // Get the NumberFormatInfo for a specific culture.
            NumberFormatInfo specificNfi = ci.NumberFormat;
            // Compare the property values of the two.
            foreach (var prop in properties)
            {
                // We're not interested in the value of IsReadOnly.
                if (prop.Name == "IsReadOnly") continue;

                // For arrays, iterate the individual elements to see if they are the same.
                if (prop.PropertyType.IsArray)
                {
                    IList nList = (IList)prop.GetValue(nfi, null);
                    IList sList = (IList)prop.GetValue(specificNfi, null);
                    if (nList.Count != sList.Count)
                    {
                        match = false;
                        break;
                    }

                    for (int ctr = 0; ctr < nList.Count; ctr++)
                    {
                        if (!nList[ctr].Equals(sList[ctr]))
                        {
                            match = false;
                            break;
                        }
                    }
                }
                else if (!prop.GetValue(specificNfi).Equals(prop.GetValue(nfi)))
                {
                    match = false;
                    break;
                }
            }
            if (match)
            {
                Console.WriteLine($"NumberFormatInfo object for '{name}' matches '{ci.Name}'");
                hasOneMatch = true;
            }
        }
        if (!hasOneMatch)
            Console.WriteLine($"NumberFormatInfo object for '{name}' --> No Match");

        Console.WriteLine();
    }
}

Dynamische gegevens

De cultuurspecifieke gegevens voor het opmaken van numerieke waarden die door de NumberFormatInfo klasse worden geleverd, zijn dynamisch, net als de culturele gegevens die door de CultureInfo klasse worden geleverd. U mag geen veronderstellingen maken over de stabiliteit van waarden voor NumberFormatInfo objecten die aan bepaalde CultureInfo objecten zijn gekoppeld. Alleen de gegevens van de invariante cultuur en het bijbehorende NumberFormatInfo object zijn stabiel. Andere gegevens kunnen om de volgende redenen veranderen tussen toepassingssessies of zelfs binnen één sessie:

• Systeemupdates. Culturele voorkeuren, zoals het valutasymbool of valutanotaties, veranderen in de loop van de tijd. Als dit gebeurt, bevat Windows Update wijzigingen in de NumberFormatInfo eigenschapswaarde voor een bepaalde cultuur.

• Vervangingsculturen. De CultureAndRegionInfoBuilder klasse kan worden gebruikt om de gegevens van een bestaande cultuur te vervangen.

• Cascadegewijze wijzigingen in eigenschapswaarden. Een aantal cultuurgerelateerde eigenschappen kan tijdens runtime worden gewijzigd, wat op zijn beurt leidt tot NumberFormatInfo wijzigingen in gegevens. De huidige cultuur kan bijvoorbeeld programmatisch of via gebruikersactie worden gewijzigd. Wanneer dit gebeurt, verandert het NumberFormatInfo object dat door de CurrentInfo eigenschap wordt geretourneerd in een object dat is gekoppeld aan de huidige cultuur.

• Gebruikersvoorkeuren. Gebruikers van uw toepassing kunnen een aantal waarden overschrijven die zijn gekoppeld aan de huidige systeemcultuur via de regio- en taalopties in het Configuratiescherm. Gebruikers kunnen bijvoorbeeld een ander valutasymbool of een ander decimaalteken kiezen. Als de CultureInfo.UseUserOverride eigenschap is ingesteld op true (de standaardwaarde), worden de eigenschappen van het NumberFormatInfo object ook opgehaald uit de gebruikersinstellingen.

Alle door de gebruiker aanpasbare eigenschappen van een NumberFormatInfo object worden geïnitialiseerd wanneer het object wordt gecreëerd. Er is nog steeds een mogelijkheid van inconsistentie, omdat noch de creatie van objecten noch het overschrijvingsproces door de gebruiker atomair is, en de relevante waarden kunnen veranderen tijdens de creatie van het object. Deze inconsistenties moeten echter uiterst zeldzaam zijn.

U kunt bepalen of gebruikersoverschrijvingen worden weerspiegeld in NumberFormatInfo objecten die dezelfde cultuur vertegenwoordigen als de huidige cultuur. De volgende tabel bevat de manieren waarop een NumberFormatInfo object kan worden opgehaald en geeft aan of het resulterende object gebruikersoverschrijvingen weerspiegelt.

Bron van object CultureInfo en NumberFormatInfo	Weerspiegelt aanpassingen van gebruikers
eigenschap CultureInfo.CurrentCulture.NumberFormat	Ja
eigenschap NumberFormatInfo.CurrentInfo	Ja
methode CultureInfo.CreateSpecificCulture	Ja
methode CultureInfo.GetCultureInfo	No
CultureInfo(String) bouwer	Ja
CultureInfo.CultureInfo(String, Boolean) bouwer	Afhankelijk van de waarde van useUserOverride de parameter

Tenzij er een overtuigende reden is om het anders te doen, moet u de aanpassingen van gebruikers respecteren wanneer u het NumberFormatInfo-object in clienttoepassingen gebruikt om gebruikersinvoer op te maken en te parseren of om numerieke gegevens weer te geven. Voor servertoepassingen of toepassingen zonder toezicht moet u de gebruikersaanpassingen niet respecteren. Als u echter het NumberFormatInfo object expliciet of impliciet gebruikt om numerieke gegevens in een tekenreeksformulier te behouden, moet u een NumberFormatInfo object gebruiken dat de opmaakconventies van de invariante cultuur weerspiegelt, of u moet een aangepaste tekenreeks voor numerieke notatie opgeven die u gebruikt, ongeacht cultuur.

IFormatProvider, NumberFormatInfo en numerieke opmaak

Een NumberFormatInfo object wordt impliciet of expliciet gebruikt in alle numerieke opmaakbewerkingen. Dit zijn aanroepen naar de volgende methoden:

• Alle numerieke opmaakmethoden, zoals Int32.ToString, Double.ToStringen Convert.ToString(Int32).

• De primaire methode voor samengestelde opmaak, String.Format.

• Andere samengestelde opmaakmethoden, zoals Console.WriteLine(String, Object[]) en StringBuilder.AppendFormat(String, Object[]).

Alle bewerkingen voor numerieke opmaak maken gebruik van een IFormatProvider implementatie. De IFormatProvider interface bevat één methode, GetFormat(Type). Dit is een callback-methode die wordt doorgegeven aan een Type object dat het type vertegenwoordigt dat nodig is om opmaakgegevens op te geven. De methode is verantwoordelijk voor het retourneren van een exemplaar van dat type of null, als deze geen exemplaar van het type kan leveren. .NET biedt twee IFormatProvider implementaties voor het opmaken van getallen:

• De CultureInfo klasse, die een specifieke cultuur vertegenwoordigt (of een specifieke taal in een specifiek land/regio). In een bewerking voor numerieke opmaak retourneert de CultureInfo.GetFormat-methode het NumberFormatInfo-object dat is gekoppeld aan de CultureInfo.NumberFormat-eigenschap.

• De NumberFormatInfo klasse, die informatie biedt over de opmaakconventies van de bijbehorende cultuur. De NumberFormatInfo.GetFormat methode retourneert een exemplaar van zichzelf.

Als een IFormatProvider implementatie niet expliciet wordt geleverd aan een opmaakmethode, wordt een CultureInfo object dat wordt geretourneerd door de CultureInfo.CurrentCulture eigenschap die de huidige cultuur vertegenwoordigt, gebruikt.

In het volgende voorbeeld wordt de relatie geïllustreerd tussen de IFormatProvider interface en de NumberFormatInfo class in opmaakbewerkingen door het definiëren van een aangepaste IFormatProvider implementatie. De GetFormat methode geeft de typenaam weer van het object dat is aangevraagd door de opmaakbewerking. Als de interface een NumberFormatInfo object aanvraagt, biedt deze methode het NumberFormatInfo object voor de huidige cultuur. Zoals de uitvoer uit het voorbeeld laat zien, vraagt de Decimal.ToString(IFormatProvider) methode een NumberFormatInfo object aan om opmaakgegevens op te geven, terwijl de String.Format(IFormatProvider, String, Object[]) methodeaanvragen NumberFormatInfo en DateTimeFormatInfo objecten evenals een ICustomFormatter implementatie.

using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
    public Object GetFormat(Type formatType)
    {
        Console.WriteLine($"Requesting an object of type {formatType.Name}");
        if (formatType == typeof(NumberFormatInfo))
            return NumberFormatInfo.CurrentInfo;
        else if (formatType == typeof(DateTimeFormatInfo))
            return DateTimeFormatInfo.CurrentInfo;
        else
            return null;
    }
}

public class FormatProviderEx
{
    public static void Main()
    {
        Decimal amount = 1203.541m;
        string value = amount.ToString("C2", new CurrentCultureFormatProvider());
        Console.WriteLine(value);
        Console.WriteLine();
        string composite = String.Format(new CurrentCultureFormatProvider(),
                                         "Date: {0}   Amount: {1}   Description: {2}",
                                         DateTime.Now, 1264.03m, "Service Charge");
        Console.WriteLine(composite);
        Console.WriteLine();
    }
}
// The example displays output like the following:
//    Requesting an object of type NumberFormatInfo
//    $1,203.54
//
//    Requesting an object of type ICustomFormatter
//    Requesting an object of type DateTimeFormatInfo
//    Requesting an object of type NumberFormatInfo
//    Date: 11/15/2012 2:00:01 PM   Amount: 1264.03   Description: Service Charge

Als een IFormatProvider implementatie niet expliciet is opgegeven in een aanroep van een numerieke opmaakmethode, roept de methode de CultureInfo.CurrentCulture.GetFormat methode aan, die het NumberFormatInfo object retourneert dat overeenkomt met de huidige cultuur.

Opmaakreeksen en NumberFormatInfo-eigenschappen

Elke opmaakbewerking maakt gebruik van een standaardtekenreeks of een aangepaste numerieke notatietekenreeks om een resultaattekenreeks van een getal te produceren. In sommige gevallen is het gebruik van een notatietekenreeks voor het produceren van een resultaattekenreeks expliciet, zoals in het volgende voorbeeld. Met deze code wordt de Decimal.ToString(IFormatProvider) methode aangeroepen om een Decimal waarde te converteren naar een aantal verschillende tekenreeksweergaven met behulp van de opmaakconventies van de en-US cultuur.

using System;
using System.Globalization;

public class PropertiesEx1
{
    public static void Main()
    {
        string[] formatStrings = { "C2", "E1", "F", "G3", "N",
                                 "#,##0.000", "0,000,000,000.0##" };
        CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
        Decimal[] values = { 1345.6538m, 1921651.16m };

        foreach (var value in values)
        {
            foreach (var formatString in formatStrings)
            {
                string resultString = value.ToString(formatString, culture);
                Console.WriteLine("{0,-18} -->  {1}", formatString, resultString);
            }
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//       C2                 -->  $1,345.65
//       E1                 -->  1.3E+003
//       F                  -->  1345.65
//       G3                 -->  1.35E+03
//       N                  -->  1,345.65
//       #,##0.000          -->  1,345.654
//       0,000,000,000.0##  -->  0,000,001,345.654
//
//       C2                 -->  $1,921,651.16
//       E1                 -->  1.9E+006
//       F                  -->  1921651.16
//       G3                 -->  1.92E+06
//       N                  -->  1,921,651.16
//       #,##0.000          -->  1,921,651.160
//       0,000,000,000.0##  -->  0,001,921,651.16

In andere gevallen is het gebruik van een notatietekenreeks impliciet. In de volgende aanroepen van de standaard- of parameterloze Decimal.ToString() methode, wordt de waarde van de Decimal instantie opgemaakt met behulp van de algemene notatieaanduiding ("G") en de conventies van de huidige cultuur, die in dit geval de cultuur en-US is.

using System;

public class PropertiesEx2
{
    public static void Main()
    {
        Decimal[] values = { 1345.6538m, 1921651.16m };

        foreach (var value in values)
        {
            string resultString = value.ToString();
            Console.WriteLine(resultString);
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//       1345.6538
//
//       1921651.16

Elke standaardtekenreeks voor numerieke notatie maakt gebruik van een of meer NumberFormatInfo eigenschappen om het patroon of de symbolen te bepalen die in de resultaattekenreeks worden gebruikt. Op dezelfde manier voegt elke aangepaste numerieke notatieaanduiding, behalve '0' en '#', symbolen in de resultaattekenreeks in die zijn gedefinieerd door NumberFormatInfo eigenschappen. De volgende tabel bevat de standaard- en aangepaste numerieke notatieaanduidingen en de bijbehorende NumberFormatInfo eigenschappen. Als u het uiterlijk van de resultaattekenreeks voor een bepaalde cultuur wilt wijzigen, raadpleegt u de sectie Eigenschappen van NumberFormatInfo wijzigen . Zie Standaardtekenreeksen voor numerieke notatie entekenreeksen met aangepaste numerieke notatie voor meer informatie over het gebruik van deze notatieaanduidingen.

Opmaakaanduiding	Gekoppelde eigenschappen
"C" of "c" (valutaopmaak)	CurrencyDecimalDigits, om het standaardaantal fractionele cijfers te definiëren. CurrencyDecimalSeparatorom het decimaalscheidingsteken te definiëren. CurrencyGroupSeparator, om de scheidingstekens voor groepen of duizendtallen te definiëren. CurrencyGroupSizes, om de grootten van integrale groepen te definiëren. CurrencyNegativePattern, om het patroon van negatieve valutawaarden te definiëren. CurrencyPositivePattern, om het patroon van positieve valutawaarden te definiëren. CurrencySymbolom het valutasymbool te definiëren. NegativeSignom het symbool voor het negatieve teken te definiëren.
"D" of "d" (decimaal opmaak)	NegativeSignom het symbool voor het negatieve teken te definiëren.
"E" of "e" (exponentiële of wetenschappelijke notatieaanduiding)	NegativeSign, om het negatieve tekensymbool in de mantissa en exponent te definiëren. NumberDecimalSeparatorom het decimaalscheidingsteken te definiëren. PositiveSignom het positieve tekensymbool in de exponent te definiëren.
"F" of "f" (opmaakaanduiding met vaste punten)	NegativeSignom het symbool voor het negatieve teken te definiëren. NumberDecimalDigits, om het standaardaantal fractionele cijfers te definiëren. NumberDecimalSeparatorom het decimaalscheidingsteken te definiëren.
"G" of "g" (algemene notatieaanduiding)	NegativeSignom het symbool voor het negatieve teken te definiëren. NumberDecimalSeparatorom het decimaalscheidingsteken te definiëren. PositiveSign, als u het symbool voor het positieve teken voor resultaattekenreeksen in exponentiële notatie wilt definiëren.
"N" ofwel "n" (Getalnotatieaanduiding)	NegativeSignom het symbool voor het negatieve teken te definiëren. NumberDecimalDigits, om het standaardaantal fractionele cijfers te definiëren. NumberDecimalSeparatorom het decimaalscheidingsteken te definiëren. NumberGroupSeparatorom het groepsscheidingsteken (duizendtallen) te definiëren. NumberGroupSizes, om het aantal integrale cijfers in een groep te definiëren. NumberNegativePattern, om de notatie van negatieve waarden te definiëren.
"P" of "p" (aanduiding voor procentnotatie)	NegativeSignom het symbool voor het negatieve teken te definiëren. PercentDecimalDigits, om het standaardaantal fractionele cijfers te definiëren. PercentDecimalSeparatorom het decimaalscheidingsteken te definiëren. PercentGroupSeparatorom het groepsscheidingsteken te definiëren. PercentGroupSizes, om het aantal integrale cijfers in een groep te definiëren. PercentNegativePattern, om de plaatsing van het procentsymbool en het negatieve symbool voor negatieve waarden te definiëren. PercentPositivePattern, om de plaatsing van het procentsymbool voor positieve waarden te definiëren. PercentSymbolom het procentsymbool te definiëren.
"R" of "r" (retourreis formaat specificatie)	NegativeSignom het symbool voor het negatieve teken te definiëren. NumberDecimalSeparatorom het decimaalscheidingsteken te definiëren. PositiveSignom het positieve tekensymbool in een exponent te definiëren.
"X" of "x" (hexadecimaal formaat specificator)	None.
"." (aangepaste notatieaanduiding voor decimalen)	NumberDecimalSeparatorom het decimaalscheidingsteken te definiëren.
"," (aangepaste opmaakaanduiding voor groepsscheidingsteken)	NumberGroupSeparatorom het scheidingsteken voor groepen (duizendtallen) te definiëren.
"%" (aanduiding voor aangepaste opmaak voor percentage)	PercentSymbolom het procentsymbool te definiëren.
"‰" (een speciaal opmaaknotatie voor per mille)	PerMilleSymbolom het per mille-symbool te definiëren.
"E" (aangepaste aanduiding voor exponentiële notatie)	NegativeSign, om het negatieve tekensymbool in de mantissa en exponent te definiëren. PositiveSignom het positieve tekensymbool in de exponent te definiëren.

Houd er rekening mee dat de NumberFormatInfo klasse een NativeDigits eigenschap bevat waarmee de basis 10 cijfers worden opgegeven die door een specifieke cultuur worden gebruikt. De eigenschap wordt echter niet gebruikt in opmaakbewerkingen; alleen de Latijnse basiscijfers 0 (U+0030) tot en met 9 (U+0039) worden gebruikt in de resultaattekenreeks. Daarnaast bestaat voor Single- en Double-waarden van NaN, PositiveInfinity, en NegativeInfinity de resultaattekenreeks uitsluitend uit de symbolen die respectievelijk zijn gedefinieerd door de eigenschappen NaNSymbol, PositiveInfinitySymbol en NegativeInfinitySymbol.

Eigenschappen van NumberFormatInfo wijzigen

U kunt de eigenschappen van een NumberFormatInfo object wijzigen om de resultaattekenreeks aan te passen die is geproduceerd in een numerieke opmaakbewerking. Dit doet u als volgt:

1. Maak een lees-/schrijfkopie van een NumberFormatInfo object waarvan u de opmaakconventies wilt wijzigen. Zie de sectie Instantiate a NumberFormatInfo object voor meer informatie.

2. Wijzig de eigenschap of eigenschappen die worden gebruikt om de gewenste resultaattekenreeks te produceren. Zie de sectie NumberFormatInfo voor informatie over hoe opmaakmethoden eigenschappen gebruiken om resultaattekenreeksen te definiëren.

3. Gebruik het aangepaste NumberFormatInfo object als argument IFormatProvider in aanroepen naar opmaakmethoden.

Note

In plaats van de eigenschapswaarden van een cultuur dynamisch te wijzigen telkens wanneer een toepassing wordt gestart, kunt u de CultureAndRegionInfoBuilder klasse gebruiken om een aangepaste cultuur te definiëren (een cultuur met een unieke naam en die een aanvulling vormt op bestaande culturen) of een vervangende cultuur (een cultuur die wordt gebruikt in plaats van een specifieke cultuur).

De volgende secties bevatten enkele voorbeelden.

Het valutasymbool en -patroon wijzigen

In het volgende voorbeeld wordt een NumberFormatInfo object gewijzigd dat de opmaakconventies van de en-US cultuur vertegenwoordigt. Hiermee wordt het ISO-4217-valutasymbool toegewezen aan de CurrencySymbol eigenschap en wordt een patroon gedefinieerd voor valutawaarden die bestaan uit het valutasymbool, gevolgd door een spatie en een numerieke waarde.

using System;
using System.Globalization;

public class Example
{
    public static void Main()
    {
        // Retrieve a writable NumberFormatInfo object.
        CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
        NumberFormatInfo nfi = enUS.NumberFormat;

        // Use the ISO currency symbol instead of the native currency symbol.
        nfi.CurrencySymbol = (new RegionInfo(enUS.Name)).ISOCurrencySymbol;
        // Change the positive currency pattern to <code><space><value>.
        nfi.CurrencyPositivePattern = 2;
        // Change the negative currency pattern to <code><space><sign><value>.
        nfi.CurrencyNegativePattern = 12;

        // Produce the result strings by calling ToString.
        Decimal[] values = { 1065.23m, 19.89m, -.03m, -175902.32m };
        foreach (var value in values)
            Console.WriteLine(value.ToString("C", enUS));

        Console.WriteLine();

        // Produce the result strings by calling a composite formatting method.
        foreach (var value in values)
            Console.WriteLine(String.Format(enUS, "{0:C}", value));
    }
}
// The example displays the following output:
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32
//
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32

Een nationaal identificatienummer opmaken

Veel nationale identificatienummers bestaan uitsluitend uit cijfers en kunnen dus eenvoudig worden opgemaakt door de eigenschappen van een NumberFormatInfo object te wijzigen. Een burgerservicenummer in de Verenigde Staten bestaat bijvoorbeeld uit 9 cijfers die als volgt zijn gerangschikt: XXX-XX-XXXX In het volgende voorbeeld wordt ervan uitgegaan dat burgerservicenummers als geheel getalwaarden worden opgeslagen en op de juiste wijze worden opgemaakt.

using System;
using System.Globalization;

public class CustomizeSSNEx
{
    public static void Main()
    {
        // Instantiate a read-only NumberFormatInfo object.
        CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
        NumberFormatInfo nfi = enUS.NumberFormat;

        // Modify the relevant properties.
        nfi.NumberGroupSeparator = "-";
        nfi.NumberGroupSizes = new int[] { 3, 2, 4 };
        nfi.NumberDecimalDigits = 0;

        int[] ids = { 111223333, 999776666 };

        // Produce the result string by calling ToString.
        foreach (var id in ids)
            Console.WriteLine(id.ToString("N", enUS));

        Console.WriteLine();

        // Produce the result string using composite formatting.
        foreach (var id in ids)
            Console.WriteLine(String.Format(enUS, "{0:N}", id));
    }
}
// The example displays the following output:
//       1112-23-333
//       9997-76-666
//
//       1112-23-333
//       9997-76-666

Numerieke tekenreeksen parseren

Parseren omvat het converteren van de tekenreeksweergave van een getal naar een getal. Elk numeriek type in .NET bevat twee overbelaste parseringsmethoden: Parse en TryParse. De Parse methode converteert een tekenreeks naar een getal en genereert een uitzondering als de conversie mislukt. De TryParse methode converteert een tekenreeks naar een getal, wijst het getal toe aan een out argument en retourneert een Boolean waarde die aangeeft of de conversie is geslaagd.

De parseringsmethoden gebruiken impliciet of expliciet een NumberStyles opsommingswaarde om te bepalen welke stijlelementen (zoals groepsscheidingstekens, een decimaalteken of een valutasymbool) aanwezig kunnen zijn in een tekenreeks als de parseringsbewerking is geslaagd. Als een NumberStyles waarde niet is opgegeven in de methode-aanroep, is de standaardwaarde een NumberStyles waarde die de Float en AllowThousands vlaggen bevat, waarmee wordt aangegeven dat de geparseerde tekenreeks groepssymbolen, een decimaalteken, een negatief teken en spatietekens kan bevatten, of de tekenreeksweergave van een getal in exponentiële notatie.

De parseringsmethoden gebruiken ook impliciet of expliciet een NumberFormatInfo object dat de specifieke symbolen en patronen definieert die in de tekenreeks kunnen worden geparseerd. Als er geen NumberFormatInfo object is opgegeven, is de standaardwaarde de NumberFormatInfo voor de huidige cultuur. Zie voor meer informatie over parseren de afzonderlijke parseringsmethoden, zoals Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), en Double.TryParse(String, Double).BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger)

In het volgende voorbeeld ziet u de cultuurgevoelige aard van het parseren van tekenreeksen. Er wordt geprobeerd een tekenreeks te parseren die duizendtallenscheidingstekens bevat met behulp van de conventies van de en-US-, fr-FR- en invariante culturen. Een tekenreeks die de komma als een groepsscheidingsteken bevat en de punt als een decimaalteken kan niet worden geparseerd in de fr-FR cultuur, en een tekenreeks met witruimte als een groepsscheidingsteken en een komma als decimaalteken kan niet worden geparseerd in de en-US en invariante culturen.

using System;
using System.Globalization;

public class ParseEx1
{
    public static void Main()
    {
        String[] values = { "1,034,562.91", "9 532 978,07" };
        String[] cultureNames = { "en-US", "fr-FR", "" };

        foreach (var value in values)
        {
            foreach (var cultureName in cultureNames)
            {
                CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
                String name = culture.Name == "" ? "Invariant" : culture.Name;
                try
                {
                    Decimal amount = Decimal.Parse(value, culture);
                    Console.WriteLine($"'{value}' --> {amount} ({name})");
                }
                catch (FormatException)
                {
                    Console.WriteLine($"'{value}': FormatException ({name})");
                }
            }
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//       '1,034,562.91' --> 1034562.91 (en-US)
//       '1,034,562.91': FormatException (fr-FR)
//       '1,034,562.91' --> 1034562.91 (Invariant)
//
//       '9 532 978,07': FormatException (en-US)
//       '9 532 978,07' --> 9532978.07 (fr-FR)
//       '9 532 978,07': FormatException (Invariant)

Parseren vindt in het algemeen plaats in twee contexten:

• Als een bewerking die is ontworpen om gebruikersinvoer te converteren naar een numerieke waarde.

• Als een bewerking die is ontworpen om een numerieke waarde af te ronden; dat wil gezegd, om een numerieke waarde te deserialiseren die eerder als een tekenreeks is geserialiseerd.

In de volgende secties worden deze twee bewerkingen uitgebreider besproken.

Gebruikersreeksen parseren

Wanneer u invoer van numerieke tekenreeksen door de gebruiker parseert, moet u altijd een NumberFormatInfo object instantiëren dat de culturele instellingen van de gebruiker weerspiegelt. Zie de sectie NumberFormatInfo voor informatie over het instantiëren van een object dat gebruikersaanpassingen weerspiegelt.

In het volgende voorbeeld ziet u het verschil tussen een parseringsbewerking die de culturele instellingen van gebruikers weerspiegelt en een bewerking die niet overeenkomt. In dit geval is de standaardsysteemcultuur en-US, maar de gebruiker heeft '' gedefinieerd als het decimaalteken en '.' als het groepsscheidingsteken in het Configuratiescherm, regio en taal. Deze symbolen worden gewoonlijk omgekeerd in de standaard en-US cultuur. Wanneer de gebruiker een tekenreeks invoert die gebruikersinstellingen weerspiegelt en de tekenreeks wordt geparseerd door een NumberFormatInfo object dat ook gebruikersinstellingen weergeeft (onderdrukkingen), retourneert de parseringsbewerking een correct resultaat. Wanneer de tekenreeks echter wordt geparseerd door een NumberFormatInfo object dat standaard en-US culturele instellingen weerspiegelt, wordt het kommasymbool voor een groepsscheidingsteken verkeerd weergegeven en wordt een onjuist resultaat geretourneerd.

using System;
using System.Globalization;

public class ParseUserEx
{
    public static void Main()
    {
        CultureInfo stdCulture = CultureInfo.GetCultureInfo("en-US");
        CultureInfo custCulture = CultureInfo.CreateSpecificCulture("en-US");

        String value = "310,16";
        try
        {
            Console.WriteLine($"{stdCulture.Name} culture reflects user overrides: {stdCulture.UseUserOverride}");
            Decimal amount = Decimal.Parse(value, stdCulture);
            Console.WriteLine($"'{value}' --> {amount.ToString(CultureInfo.InvariantCulture)}");
        }
        catch (FormatException)
        {
            Console.WriteLine($"Unable to parse '{value}'");
        }
        Console.WriteLine();

        try
        {
            Console.WriteLine($"{custCulture.Name} culture reflects user overrides: {custCulture.UseUserOverride}");
            Decimal amount = Decimal.Parse(value, custCulture);
            Console.WriteLine($"'{value}' --> {amount.ToString(CultureInfo.InvariantCulture)}");
        }
        catch (FormatException)
        {
            Console.WriteLine($"Unable to parse '{value}'");
        }
    }
}
// The example displays the following output:
//       en-US culture reflects user overrides: False
//       '310,16' --> 31016
//
//       en-US culture reflects user overrides: True
//       '310,16' --> 310.16

Numerieke gegevens serialiseren en deserialiseren

Wanneer numerieke gegevens worden geserialiseerd in tekenreeksindeling en later gedeserialiseerd en geparseerd, moeten de tekenreeksen worden gegenereerd en geparseerd met behulp van de conventies van de invariante cultuur. De opmaak- en parseringsbewerkingen mogen nooit de conventies van een specifieke cultuur weerspiegelen. Als cultuurspecifieke instellingen worden gebruikt, is de draagbaarheid van de gegevens strikt beperkt; het kan alleen worden gedeserialiseerd op een thread waarvan de cultuurspecifieke instellingen identiek zijn aan die van de thread waarop deze is geserialiseerd. In sommige gevallen betekent dit dat de gegevens niet eens kunnen worden gedeserialiseerd op hetzelfde systeem waarop ze zijn geserialiseerd.

In het volgende voorbeeld ziet u wat er kan gebeuren wanneer dit principe wordt geschonden. Drijvendekommawaarden in een matrix worden geconverteerd naar tekenreeksen wanneer de huidige thread gebruikmaakt van de cultuurspecifieke instellingen van de en-US cultuur. De gegevens worden vervolgens geparseerd door een thread die gebruikmaakt van de cultuurspecifieke instellingen van de pt-BR cultuur. In dit geval, hoewel elke parseringsbewerking slaagt, worden de gegevens niet afgerond en treedt er beschadiging van gegevens op. In andere gevallen kan een parseringsbewerking mislukken en kan er een FormatException uitzondering worden gegenereerd.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Threading;

public class ParsePersistedEx
{
    public static void Main()
    {
        CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
        PersistData();

        CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("pt-BR");
        RestoreData();
    }

    private static void PersistData()
    {
        // Define an array of floating-point values.
        Double[] values = { 160325.972, 8631.16, 1.304e5, 98017554.385,
                          8.5938287084321676e94 };
        Console.WriteLine("Original values: ");
        foreach (var value in values)
            Console.WriteLine(value.ToString("R", CultureInfo.InvariantCulture));

        // Serialize an array of doubles to a file
        StreamWriter sw = new StreamWriter(@".\NumericData.bin");
        for (int ctr = 0; ctr < values.Length; ctr++)
        {
            sw.Write(values[ctr].ToString("R"));
            if (ctr < values.Length - 1) sw.Write("|");
        }
        sw.Close();
        Console.WriteLine();
    }

    private static void RestoreData()
    {
        // Deserialize the data
        StreamReader sr = new StreamReader(@".\NumericData.bin");
        String data = sr.ReadToEnd();
        sr.Close();

        String[] stringValues = data.Split('|');
        List<Double> newValueList = new List<Double>();

        foreach (var stringValue in stringValues)
        {
            try
            {
                newValueList.Add(Double.Parse(stringValue));
            }
            catch (FormatException)
            {
                newValueList.Add(Double.NaN);
            }
        }

        Console.WriteLine("Restored values:");
        foreach (var newValue in newValueList)
            Console.WriteLine(newValue.ToString("R", NumberFormatInfo.InvariantInfo));
    }
}
// The example displays the following output:
//       Original values:
//       160325.972
//       8631.16
//       130400
//       98017554.385
//       8.5938287084321671E+94
//
//       Restored values:
//       160325972
//       863116
//       130400
//       98017554385
//       8.5938287084321666E+110

Voorbeeld

  The following example shows how to retrieve a <xref:System.Globalization.NumberFormatInfo> object for a corresponding <xref:System.Globalization.CultureInfo> object, and use the retrieved object to query number formatting information for the particular culture.

  :::code language="csharp" source="~/snippets/csharp/System.Globalization/NumberFormatInfo/Overview/NumberFormatInfo.cs" id="Snippet1":::
  :::code language="vb" source="~/snippets/visualbasic/System.Globalization/NumberFormatInfo/Overview/numberformatinfo.vb" id="Snippet1":::

Constructors

Name	Description
NumberFormatInfo()	Initialiseert een nieuw beschrijfbaar exemplaar van de NumberFormatInfo klasse die cultuuronafhankelijk is (invariant).

Eigenschappen

Name	Description
CurrencyDecimalDigits	Hiermee wordt het aantal decimalen opgehaald of ingesteld dat moet worden gebruikt in valutawaarden.
CurrencyDecimalSeparator	Hiermee haalt u de tekenreeks op die moet worden gebruikt als het decimaalteken in valutawaarden.
CurrencyGroupSeparator	Hiermee wordt de tekenreeks opgehaald of ingesteld waarmee groepen cijfers links van de decimale waarden in valutawaarden worden gescheiden.
CurrencyGroupSizes	Hiermee wordt het aantal cijfers in elke groep opgehaald of ingesteld links van de decimale waarden in valutawaarden.
CurrencyNegativePattern	Hiermee wordt het notatiepatroon voor negatieve valutawaarden opgehaald of ingesteld.
CurrencyPositivePattern	Hiermee wordt het notatiepatroon voor positieve valutawaarden opgehaald of ingesteld.
CurrencySymbol	Hiermee haalt u de tekenreeks op die moet worden gebruikt als valutasymbool of stelt u deze in.
CurrentInfo	Hiermee haalt u een alleen-lezen op NumberFormatInfo waarmee waarden worden opgemaakt op basis van de huidige cultuur.
DigitSubstitution	Hiermee wordt een waarde opgehaald of ingesteld die aangeeft hoe de grafische gebruikersinterface de vorm van een cijfer weergeeft.
InvariantInfo	Hiermee haalt u een alleen-lezen NumberFormatInfo object op dat cultuuronafhankelijk is (invariant).
IsReadOnly	Hiermee wordt een waarde opgehaald die aangeeft of dit NumberFormatInfo object het kenmerk Alleen-lezen heeft.
NaNSymbol	Hiermee wordt de tekenreeks opgehaald of ingesteld die de IEEE NaN-waarde (geen getal) vertegenwoordigt.
NativeDigits	Hiermee haalt u een tekenreeksmatrix van systeemeigen cijfers op die gelijk zijn aan de westerse cijfers 0 tot en met 9.
NegativeInfinitySymbol	Hiermee haalt u de tekenreeks op die negatieve oneindigheid vertegenwoordigt of stelt u deze in.
NegativeSign	Hiermee haalt u de tekenreeks op die aangeeft dat het bijbehorende getal negatief is.
NumberDecimalDigits	Hiermee wordt het aantal decimalen opgehaald of ingesteld dat moet worden gebruikt in numerieke waarden.
NumberDecimalSeparator	Hiermee haalt u de tekenreeks op die moet worden gebruikt als het decimaalteken in numerieke waarden.
NumberGroupSeparator	Hiermee wordt de tekenreeks opgehaald of ingesteld waarmee groepen cijfers links van het decimaalteken in numerieke waarden worden gescheiden.
NumberGroupSizes	Hiermee wordt het aantal cijfers in elke groep opgehaald of ingesteld links van het decimaalteken in numerieke waarden.
NumberNegativePattern	Hiermee wordt het notatiepatroon voor negatieve numerieke waarden opgehaald of ingesteld.
PercentDecimalDigits	Hiermee wordt het aantal decimalen opgehaald of ingesteld dat moet worden gebruikt in procentwaarden.
PercentDecimalSeparator	Hiermee haalt u de tekenreeks op die moet worden gebruikt als het decimaalteken in procentwaarden.
PercentGroupSeparator	Hiermee wordt de tekenreeks opgehaald of ingesteld waarmee groepen cijfers links van de decimale in procentwaarden worden gescheiden.
PercentGroupSizes	Hiermee wordt het aantal cijfers in elke groep opgehaald of ingesteld links van de decimale in procentwaarden.
PercentNegativePattern	Hiermee wordt het notatiepatroon voor negatieve procentwaarden opgehaald of ingesteld.
PercentPositivePattern	Hiermee wordt het notatiepatroon voor positieve procentwaarden opgehaald of ingesteld.
PercentSymbol	Hiermee haalt u de tekenreeks op die moet worden gebruikt als het procentsymbool.
PerMilleSymbol	Hiermee haalt u de tekenreeks op die moet worden gebruikt als het mille-symbool.
PositiveInfinitySymbol	Hiermee haalt u de tekenreeks op die positief oneindig is of stelt u deze in.
PositiveSign	Hiermee haalt u de tekenreeks op die aangeeft dat het bijbehorende getal positief is.

Methoden

Name	Description
Clone()	Hiermee maakt u een ondiepe kopie van het NumberFormatInfo object.
Equals(Object)	Bepaalt of het opgegeven object gelijk is aan het huidige object. (Overgenomen van Object)
GetFormat(Type)	Hiermee haalt u een object op van het opgegeven type dat een service voor getalopmaak biedt.
GetHashCode()	Fungeert als de standaardhashfunctie. (Overgenomen van Object)
GetInstance(IFormatProvider)	Hiermee wordt de NumberFormatInfo gekoppeld aan de opgegeven IFormatProvider.
GetType()	Hiermee haalt u de Type huidige instantie op. (Overgenomen van Object)
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
ReadOnly(NumberFormatInfo)	Retourneert een alleen-lezen NumberFormatInfo wrapper.
ToString()	Retourneert een tekenreeks die het huidige object vertegenwoordigt. (Overgenomen van Object)

Zie ook

• CultureInfo
• IFormatProvider
• Tekenreeksen voor aangepaste numerieke notatie