NumberFormatInfo Klass

Definition

public ref class NumberFormatInfo sealed : IFormatProvider

public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider

public sealed class NumberFormatInfo : IFormatProvider

public sealed class NumberFormatInfo : ICloneable, IFormatProvider

[System.Serializable]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider

type NumberFormatInfo = class
    interface IFormatProvider

type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider

[<System.Serializable>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider

Public NotInheritable Class NumberFormatInfo
Implements IFormatProvider

Public NotInheritable Class NumberFormatInfo
Implements ICloneable, IFormatProvider

Arv

Object

NumberFormatInfo

Attribut

SerializableAttribute ComVisibleAttribute

Implementeringar

IFormatProvider ICloneable

Kommentarer

Klassen NumberFormatInfo innehåller kulturspecifik information som används när du formaterar och parsar numeriska värden. Den här informationen innehåller valutasymbolen, decimaltecknet, gruppavgränsarsymbolen och symbolerna för positiva och negativa tecken.

Instansiera ett NumberFormatInfo-objekt

Du kan instansiera ett NumberFormatInfo objekt som representerar formateringskonventionerna för den aktuella kulturen, den invarianta kulturen, en specifik kultur eller en neutral kultur.

Instansiera ett NumberFormatInfo-objekt för den aktuella kulturen

Du kan instansiera ett NumberFormatInfo objekt för den aktuella kulturen på något av följande sätt. I varje fall är det returnerade NumberFormatInfo-objektet skrivskyddat.

• Genom att hämta ett CultureInfo objekt som representerar den aktuella kulturen från egenskapen CultureInfo.CurrentCulture och hämta NumberFormatInfo-objektet från dess egenskap CultureInfo.NumberFormat.

• Genom att hämta det NumberFormatInfo-objekt som returneras av egenskapen static (Shared i Visual Basic) CurrentInfo.

• Genom att anropa GetInstance metoden med ett CultureInfo objekt som representerar den aktuella kulturen.

I följande exempel används dessa tre sätt att skapa NumberFormatInfo objekt som representerar formateringskonventionerna i den aktuella kulturen. Den hämtar dessutom värdet för egenskapen IsReadOnly för att illustrera att varje objekt är skrivskyddat.

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

Du kan skapa ett skrivbart NumberFormatInfo objekt som representerar den aktuella kulturens konventioner på något av följande sätt:

• Genom att hämta ett NumberFormatInfo objekt på något av de sätt som illustreras i föregående kodexempel och anropa metoden Clone på det returnerade NumberFormatInfo objektet. Detta skapar en kopia av det ursprungliga NumberFormatInfo objektet, förutom att dess IsReadOnly egenskap är false.

• Genom att anropa metoden CultureInfo.CreateSpecificCulture för att skapa ett CultureInfo objekt som representerar den aktuella kulturen och sedan använda dess CultureInfo.NumberFormat-egenskap för att hämta NumberFormatInfo-objektet.

I följande exempel visas dessa två sätt att instansiera ett NumberFormatInfo-objekt och visar värdet för dess IsReadOnly-attribut för att illustrera att objektet inte är skrivskyddat.

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

Observera att Windows-operativsystemet tillåter att användaren åsidosätter vissa av de NumberFormatInfo egenskapsvärden som används i numerisk formatering och parsningsåtgärder via objektet Region och Språk i Kontrollpanelen. En användare vars kultur är engelska (USA) kan till exempel välja att visa valutavärden som 1,1 USD i stället för standardvärdet 1,1 USD. De NumberFormatInfo objekt som hämtades på det sätt som tidigare beskrivits reflekterar dessa användaråtsidosättningar. Om detta inte är önskvärt kan du skapa ett NumberFormatInfo-objekt som inte återspeglar användarens åsidosättningar (och som dessutom är skrivbar snarare än skrivskyddad) genom att anropa CultureInfo.CultureInfo(String, Boolean)-konstruktorn och ange värdet false för argumentet useUserOverride. I följande exempel visas en bild för ett system vars nuvarande kultur är engelska (USA) och vars valutasymbol har ändrats från standardvärdet $ till 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: $

Om egenskapen CultureInfo.UseUserOverride är inställd på truehämtas även egenskaperna CultureInfo.DateTimeFormat, CultureInfo.NumberFormatoch CultureInfo.TextInfo från användarinställningarna. Om användarinställningarna inte är kompatibla med den kultur som är associerad med CultureInfo -objektet (till exempel om den valda kalendern inte är en av kalendrarna som anges av egenskapen OptionalCalendars) är resultatet av metoderna och egenskapernas värden odefinierade.

Instansiera ett NumberFormatInfo-objekt för den invarianta kulturen

Den invarianta kulturen representerar en kultur som är kulturneutral. Det är baserat på det engelska språket men inte på något specifikt engelsktalande land/region. Även om data för specifika kulturer kan vara dynamiska och kan ändras för att återspegla nya kulturella konventioner eller användarinställningar, ändras inte data i den invarianta kulturen. Ett NumberFormatInfo objekt som representerar formateringskonventionerna för den invarianta kulturen kan användas för formateringsåtgärder där resultatsträngarna inte bör variera beroende på kultur.

Du kan instansiera ett NumberFormatInfo objekt som representerar formateringskonventionerna för den invarianta kulturen på följande sätt:

• Genom att hämta värdet för egenskapen InvariantInfo. Det returnerade NumberFormatInfo objektet är skrivskyddat.

• Genom att hämta värdet för egenskapen CultureInfo.NumberFormat från det CultureInfo objekt som returneras av egenskapen CultureInfo.InvariantCulture. Det returnerade NumberFormatInfo objektet är skrivskyddat.

• Genom att anropa den parameterlösa NumberFormatInfo klasskonstruktorn. Det returnerade NumberFormatInfo objektet är läsning/skrivning.

I följande exempel används var och en av dessa metoder för att instansiera ett NumberFormatInfo objekt som representerar den invarianta kulturen. Det anger sedan om objektet är skrivskyddat,

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

Instansiera ett NumberFormatInfo-objekt för en specifik kultur

En specifik kultur representerar ett språk som talas i ett visst land/en viss region. Till exempel är en-US en specifik kultur som representerar det engelska språket som talas i USA, och en-CA är en specifik kultur som representerar det engelska språket som talas i Kanada. Du kan instansiera ett NumberFormatInfo objekt som representerar formateringskonventionerna för en viss kultur på följande sätt:

• Genom att anropa CultureInfo.GetCultureInfo(String)-metoden och hämta värdet på egenskapen CultureInfo från det returnerade NumberFormat-objektet. Det returnerade NumberFormatInfo objektet är skrivskyddat.

• Genom att skicka ett CultureInfo-objekt som representerar den kultur vars NumberFormatInfo-objekt du vill hämta, till den statiska GetInstance-metoden. Det returnerade NumberFormatInfo objektet är läsning/skrivning.

• Genom att anropa CultureInfo.CreateSpecificCulture-metoden och hämta värdet på egenskapen CultureInfo från det returnerade NumberFormat-objektet. Det returnerade NumberFormatInfo objektet är läsning/skrivning.

• Genom att anropa någon av CultureInfo.CultureInfo-klasskonstruktorerna och hämta värdet för det returnerade CultureInfo objektets NumberFormat egenskap. Det returnerade NumberFormatInfo objektet är läsning/skrivning.

I följande exempel används dessa fyra sätt att skapa ett NumberFormatInfo objekt som återspeglar formateringskonventionerna för den indonesiska kulturen (Indonesien). Det anger också om varje objekt är skrivskyddat.

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

Instansiera ett NumberFormatInfo-objekt för en neutral kultur

En neutral kultur representerar en kultur eller ett språk som är oberoende av ett land/en region. Det är vanligtvis förälder till en eller flera specifika kulturer. Till exempel är fr en neutral kultur för det franska språket och föräldern till den fr-FR kulturen. Du skapar ett NumberFormatInfo objekt som representerar formateringskonventionerna för en neutral kultur på samma sätt som du skapar ett NumberFormatInfo objekt som representerar formateringskonventionerna för en viss kultur.

Men eftersom den är oberoende av ett visst land/en viss region saknar en neutral kultur kulturspecifik formateringsinformation. I stället för att fylla i NumberFormatInfo-objektet med generiska värden returnerar .NET ett NumberFormatInfo objekt som återspeglar formateringskonventionerna för en specifik kultur som är underordnad den neutrala kulturen. Till exempel återspeglar NumberFormatInfo-objektet för den neutrala kulturen formateringskonventionerna för en-US kultur, och NumberFormatInfo-objektet för fr-kulturen återspeglar formateringskonventionerna för fr-FR kultur.

Du kan använda kod som följande för att avgöra vilken specifik kulturs formateringskonventioner varje neutral kultur representerar.

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();
    }
}

Dynamiska data

Kulturspecifika data för formatering av numeriska värden som tillhandahålls av klassen NumberFormatInfo är dynamiska, precis som de kulturella data som tillhandahålls av klassen CultureInfo. Du bör inte göra några antaganden om stabiliteten för värden för NumberFormatInfo objekt som är associerade med vissa CultureInfo objekt. Endast data som tillhandahålls av den invarianta kulturen och dess associerade NumberFormatInfo objekt är stabila. Andra data kan ändras mellan programsessioner, eller till och med inom en enda session, av följande skäl:

• Systemuppdateringar. Kulturella preferenser som valutasymbolen eller valutaformat ändras över tid. När detta händer innehåller Windows Update ändringar i egenskapsvärdet NumberFormatInfo för en viss kultur.

• Ersättningskulturer. Klassen CultureAndRegionInfoBuilder kan användas för att ersätta data i en befintlig kultur.

• Sammanhängande ändringar av egenskapsvärden. Ett antal kulturrelaterade egenskaper kan ändras vid körning, vilket i sin tur medför att NumberFormatInfo data ändras. Den aktuella kulturen kan till exempel ändras antingen programmatiskt eller genom användaråtgärder. När detta inträffar ändras objektet NumberFormatInfo som returneras av CurrentInfo egenskapen till ett objekt som är associerat med den aktuella kulturen.

• Användarinställningar. Användare av ditt program kan åsidosätta några av de värden som är associerade med den aktuella systemkulturen via region- och språkalternativen i Kontrollpanelen. Användare kan till exempel välja en annan valutasymbol eller ett annat decimaltecken. Om egenskapen CultureInfo.UseUserOverride är inställd på true (dess standardvärde) hämtas även egenskaperna för det NumberFormatInfo objektet från användarinställningarna.

Alla användarspecifika egenskaper för ett NumberFormatInfo-objekt initieras när objektet skapas. Det finns fortfarande en risk för inkonsekvens eftersom varken skapande av objekt eller användarens åsidosättningsprocess är atomisk, och relevanta värden kan ändras när objektet skapas. Dessa inkonsekvenser bör dock vara extremt sällsynta.

Du kan styra om användaröverstyrningar återspeglas i NumberFormatInfo-objekten som representerar samma som den aktuella kulturen. I följande tabell visas hur ett NumberFormatInfo-objekt kan hämtas och om det resulterande objektet återspeglar användaröverstyrningar.

Källa till CultureInfo- och NumberFormatInfo-objekt	Återspeglar användarinställningar
egenskapen CultureInfo.CurrentCulture.NumberFormat	Ja
egenskapen NumberFormatInfo.CurrentInfo	Ja
CultureInfo.CreateSpecificCulture metod	Ja
CultureInfo.GetCultureInfo metod	No
CultureInfo(String) konstruktor	Ja
CultureInfo.CultureInfo(String, Boolean) konstruktor	Beror på värdet för useUserOverride parametern

Om det inte finns en övertygande anledning att göra något annat bör du respektera användar åsidosättningar när du använder NumberFormatInfo-objektet i klientprogram för att formatera och parsa användarindata eller för att visa numeriska data. För serverprogram och obevakade program bör du inte ta hänsyn till användarinställningar. Men om du använder NumberFormatInfo-objektet explicit eller implicit för att spara numeriska data i strängform bör du antingen använda ett NumberFormatInfo objekt som återspeglar formateringskonventionerna för den invarianta kulturen, eller så bör du ange en anpassad numerisk formatsträng som du använder oavsett kultur.

IFormatProvider, NumberFormatInfo och numerisk formatering

Ett NumberFormatInfo objekt används implicit eller explicit i alla numeriska formateringsåtgärder. Dessa inkluderar anrop till följande metoder:

• Alla numeriska formateringsmetoder, till exempel Int32.ToString, Double.ToStringoch Convert.ToString(Int32).

• Den huvudsakliga sammansatta formateringsmetoden String.Format.

• Andra sammansatta formateringsmetoder, till exempel Console.WriteLine(String, Object[]) och StringBuilder.AppendFormat(String, Object[]).

Alla numeriska formateringsåtgärder använder en IFormatProvider implementering. Gränssnittet IFormatProvider innehåller en enda metod, GetFormat(Type). Det här är en återkallaningsmetod som tilldelas ett Type-objekt som representerar den typ som behövs för att tillhandahålla formateringsinformation. Metoden ansvarar för att returnera antingen en instans av den typen eller null, om den inte kan ange en instans av typen. .NET tillhandahåller två IFormatProvider implementeringar för formateringsnummer:

• Klassen CultureInfo, som representerar en specifik kultur (eller ett specifikt språk i ett visst land/en viss region). I en numerisk formateringsåtgärd returnerar metoden CultureInfo.GetFormat det NumberFormatInfo objekt som är associerat med dess egenskap CultureInfo.NumberFormat.

• Klassen NumberFormatInfo , som innehåller information om formateringskonventionerna för dess associerade kultur. Metoden NumberFormatInfo.GetFormat returnerar en instans av sig själv.

Om en IFormatProvider implementering inte uttryckligen tillhandahålls till en formateringsmetod används ett CultureInfo objekt som returneras av egenskapen CultureInfo.CurrentCulture som representerar den aktuella kulturen.

I följande exempel visas relationen mellan IFormatProvider-gränssnittet och NumberFormatInfo-klassen i formateringsåtgärder genom att definiera en anpassad IFormatProvider implementering. Dess GetFormat-metod visar typnamnet på objektet som begärdes av formateringsåtgärden. Om gränssnittet begär ett NumberFormatInfo objekt tillhandahåller den här metoden det NumberFormatInfo objektet för den aktuella kulturen. Som utdata från exemplet visar att Decimal.ToString(IFormatProvider)-metoden begär ett NumberFormatInfo objekt för att tillhandahålla formateringsinformation, medan String.Format(IFormatProvider, String, Object[])-metoden begär NumberFormatInfo- och DateTimeFormatInfo-objekt samt en ICustomFormatter-implementering.

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

Om en IFormatProvider implementering inte uttryckligen anges i ett numeriskt formateringsmetodanrop anropar metoden metoden CultureInfo.CurrentCulture.GetFormat, som returnerar det NumberFormatInfo objekt som motsvarar den aktuella kulturen.

Formatera strängar och NumberFormatInfo-egenskaper

Varje formateringsåtgärd använder antingen en standardsträng eller en anpassad numerisk formatsträng för att skapa en resultatsträng från ett tal. I vissa fall är användningen av en formatsträng för att skapa en resultatsträng explicit, som i följande exempel. Den här koden anropar metoden Decimal.ToString(IFormatProvider) för att konvertera ett Decimal-värde till ett antal olika strängrepresentationer med hjälp av formateringskonventionerna i en-US kultur.

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

I andra fall är användningen av en formatsträng implicit. I följande metodanrop till standard- eller parameterlös Decimal.ToString()-metoden formateras värdet för Decimal-instansen med hjälp av allmän formatspecificeraren ("G") och konventionerna för den aktuella kulturen, som i det här fallet är en-US-kulturen.

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

Varje numerisk standardformatsträng använder en eller flera NumberFormatInfo egenskaper för att fastställa mönstret eller symbolerna som används i resultatsträngen. På samma sätt infogar varje anpassad numerisk formatspecificerare utom "0" och "#" symboler i resultatsträngen som definieras av NumberFormatInfo egenskaper. I följande tabell visas standard- och anpassade numeriska formatspecificerare och deras associerade NumberFormatInfo egenskaper. Information om hur du ändrar utseendet på resultatsträngen för en viss kultur finns i avsnittet Ändra NumberFormatInfo-egenskaper. Mer information om hur du använder dessa formatspecificerare finns i numeriska standardformatsträngar och numeriska anpassade formatsträngar.

Formatsspecifikator	Associerade egenskaper
"C" eller "c" (valutaformatsspecificerare)	CurrencyDecimalDigitsför att definiera standardantalet bråktal. CurrencyDecimalSeparator, för att definiera symbolen för decimalavgränsare. CurrencyGroupSeparator, för att definiera gruppen eller tusentalsavgränsaren. CurrencyGroupSizes, för att definiera storleken på integralgrupper. CurrencyNegativePatternför att definiera mönstret för negativa valutavärden. CurrencyPositivePatternför att definiera mönstret för positiva valutavärden. CurrencySymbolför att definiera valutasymbolen. NegativeSignför att definiera symbolen för negativa tecken.
"D" eller "d" (decimalformatsangivelse)	NegativeSignför att definiera symbolen för negativa tecken.
"E" eller "e" (exponentiell eller vetenskaplig formatspecifikation)	NegativeSignför att definiera minustecknet i mantissan och exponenten. NumberDecimalSeparator, för att definiera symbolen för decimalavgränsare. PositiveSign, för att definiera symbolen för det positiva tecknet i exponenten.
"F" eller "f" (fast punktformatsspecifikation)	NegativeSignför att definiera symbolen för negativa tecken. NumberDecimalDigitsför att definiera standardantalet bråktal. NumberDecimalSeparator, för att definiera symbolen för decimalavgränsare.
"G" eller "g" (allmän formatspecificerare)	NegativeSignför att definiera symbolen för negativa tecken. NumberDecimalSeparator, för att definiera symbolen för decimalavgränsare. PositiveSignför att definiera plustecknet för resultatsträngar i exponentiellt format.
"N" eller "n" (talformatsspecificerare)	NegativeSignför att definiera symbolen för negativa tecken. NumberDecimalDigitsför att definiera standardantalet bråktal. NumberDecimalSeparator, för att definiera symbolen för decimalavgränsare. NumberGroupSeparatorför att definiera gruppavgränssymbolen (tusentals). NumberGroupSizesför att definiera antalet heltalssiffror i en grupp. NumberNegativePatternför att definiera formatet för negativa värden.
"P" eller "p" (procentformatsbeteckning)	NegativeSignför att definiera symbolen för negativa tecken. PercentDecimalDigitsför att definiera standardantalet bråktal. PercentDecimalSeparator, för att definiera symbolen för decimalavgränsare. PercentGroupSeparatorför att definiera gruppavgränsarsymbolen. PercentGroupSizesför att definiera antalet heltalssiffror i en grupp. PercentNegativePatternför att definiera placeringen av procentsymbolen och den negativa symbolen för negativa värden. PercentPositivePatternför att definiera placeringen av procentsymbolen för positiva värden. PercentSymbolför att definiera procentsymbolen.
"R" eller "r" (returformatsspecifikator)	NegativeSignför att definiera symbolen för negativa tecken. NumberDecimalSeparator, för att definiera symbolen för decimalavgränsare. PositiveSignför att definiera symbolen för positivt tecken i en exponent.
"X" eller "x" (hexadecimal formatbeteckning)	None.
". (specifik formateringskod för decimalpunkt)"	NumberDecimalSeparator, för att definiera symbolen för decimalavgränsare.
"," (anpassad formatspecificerare för gruppavgränsare)	NumberGroupSeparatorför att definiera gruppavgränsarsymbolen (tusentals).
"%" (procentuell platshållarformatsspecificerare)	PercentSymbolför att definiera procentsymbolen.
"‰" (anpassat platshållarformat för per mille)	PerMilleSymbol, för att definiera symbolen per mille.
"E" (exponentiell notation anpassat formatspecifikator)	NegativeSignför att definiera minustecknet i mantissan och exponenten. PositiveSign, för att definiera symbolen för det positiva tecknet i exponenten.

Observera att klassen NumberFormatInfo innehåller en egenskap för NativeDigits som anger de grundläggande 10 siffrorna som används av en viss kultur. Egenskapen används dock inte i formateringsåtgärder. endast de grundläggande latinska siffrorna 0 (U+0030) till och med 9 (U+0039) används i resultatsträngen. För Single och Double värden för NaN, PositiveInfinityoch NegativeInfinitybestår resultatsträngen dessutom uteslutande av de symboler som definieras av egenskaperna NaNSymbol, PositiveInfinitySymboloch NegativeInfinitySymbol.

Ändra NumberFormatInfo-egenskaper

Du kan ändra egenskaperna för ett NumberFormatInfo objekt för att anpassa resultatsträngen som skapas i en numerisk formateringsåtgärd. Så här gör du:

1. Skapa en läs-/skrivkopia av ett NumberFormatInfo objekt vars formateringskonventioner du vill ändra. Mer information finns i avsnittet Instansiera ett NumberFormatInfo-objekt.

2. Ändra den egenskap eller de egenskaper som används för att skapa önskad resultatsträng. För information om hur formateringsmetoder använder NumberFormatInfo egenskaper för att definiera resultatsträngar, se avsnittet Formatsträngar och NumberFormatInfo-egenskaper.

3. Använd det anpassade NumberFormatInfo-objektet som argumentet IFormatProvider i anrop till formateringsmetoder.

Följande avsnitt innehåller några exempel.

Ändra valutasymbolen och mönstret

I följande exempel ändras ett NumberFormatInfo objekt som representerar formateringskonventionerna för en-US kultur. Den tilldelar valutasymbolen ISO-4217 till egenskapen CurrencySymbol och definierar ett mönster för valutavärden som består av valutasymbolen följt av ett blanksteg och ett numeriskt värde.

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

Formatera ett nationellt ID-nummer

Många nationella identifieringsnummer består uteslutande av siffror och kan därför enkelt formateras genom att ändra egenskaperna för ett NumberFormatInfo objekt. Ett personnummer i USA består till exempel av 9 siffror ordnade på följande sätt: XXX-XX-XXXX. I följande exempel förutsätts att personnummer lagras som heltalsvärden och formaterar dem på rätt sätt.

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

Parsa numeriska strängar

Parsning innebär att konvertera strängrepresentationen av ett tal till ett tal. Varje numerisk typ i .NET innehåller två överlagrade parsningsmetoder: Parse och TryParse. Metoden Parse konverterar en sträng till ett tal och genererar ett undantag om konverteringen misslyckas. Metoden TryParse konverterar en sträng till ett tal, tilldelar talet till ett out argument och returnerar ett Boolean värde som anger om konverteringen lyckades.

Parsningsmetoderna använder implicit eller explicit ett NumberStyles uppräkningsvärde för att avgöra vilka formatelement (till exempel gruppavgränsare, en decimalavgränsare eller en valutasymbol) som kan finnas i en sträng om parsningsåtgärden ska lyckas. Om ett NumberStyles värde inte anges i metodanropet är standardvärdet ett NumberStyles värde som innehåller flaggorna Float och AllowThousands, som anger att den parsade strängen kan innehålla gruppsymboler, decimaltecken, ett negativt tecken och blankstegstecken, eller så kan det vara strängrepresentationen av ett tal i exponentiell notation.

Parsningsmetoderna använder också implicit eller explicit ett NumberFormatInfo objekt som definierar de specifika symboler och mönster som kan förekomma i strängen som ska parsas. Om ett NumberFormatInfo objekt inte tillhandahålls är standardvärdet NumberFormatInfo för den aktuella kulturen. Mer information om parsning finns i de enskilda parsningsmetoderna, till exempel Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double)och BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

I följande exempel illustreras den kulturkänsliga karaktären hos tolkning av strängar. Den försöker parsa en sträng som innehåller tusentals avgränsare med hjälp av konventionerna i en-US, fr-FRoch invarianta kulturer. En sträng som innehåller kommatecken som gruppavgränsare och perioden som decimalavgränsare kan inte parsa i fr-FR kultur, och en sträng med blanksteg som gruppavgränsare och ett kommatecken som decimalavgränsare kan inte parsa i en-US och invarianta kulturer.

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)

Parsning sker vanligtvis i två kontexter:

• Som en åtgärd som är utformad för att konvertera användarindata till ett numeriskt värde.

• En operation som är utformad för att kunna konvertera ett numeriskt värde till en annan form och sedan tillbaka igen; det vill säga, för att deserialisera ett numeriskt värde som tidigare serialiserats som en sträng.

I följande avsnitt beskrivs dessa två åtgärder i detalj.

Parsa användarsträngar

När du parsar numeriska strängar som användaren anger bör du alltid instansiera ett NumberFormatInfo objekt som återspeglar användarens kulturella inställningar. Information om hur du instansierar ett NumberFormatInfo objekt som återspeglar användaranpassningar finns i avsnittet Dynamiska data.

I följande exempel visas skillnaden mellan en parsningsåtgärd som återspeglar användarens kulturella inställningar och en som inte gör det. I det här fallet är standardsystemkulturen en-US, men användaren har definierat "", som decimaltecknet och "." som gruppavgränsare på Kontrollpanelen, Region och Språk. Vanligtvis är dessa symboler omvända i standardkulturen en-US. När användaren anger en sträng som återspeglar användarinställningarna, och strängen parsas av ett NumberFormatInfo objekt som också återspeglar användarinställningar (åsidosättningar), returnerar parsningsåtgärden ett korrekt resultat. Men när strängen parsas av ett NumberFormatInfo objekt som återspeglar standardinställningar en-US kulturella inställningar, misstar den kommasymbolen för en gruppavgränsare och returnerar ett felaktigt resultat.

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

Serialisera och deserialisera numeriska data

När numeriska data serialiseras i strängformat och senare deserialiseras och parsas ska strängarna genereras och parsas med hjälp av konventionerna i den invarianta kulturen. Formaterings- och parsningsåtgärder bör aldrig återspegla konventionerna i en viss kultur. Om kulturspecifika inställningar används är dataportabiliteten strikt begränsad. Det kan endast deserialiseras på en tråd vars kulturspecifika inställningar är identiska med de för tråden där den serialiserades. I vissa fall innebär det att data inte ens kan deserialiseras på samma system som de serialiserades på.

I följande exempel visas vad som kan hända när den här principen överträds. Flyttalsvärden i en matris konverteras till strängar när den aktuella tråden använder kulturspecifika inställningar för en-US kultur. Data parsas sedan av en tråd som använder de kulturspecifika inställningarna för pt-BR kultur. I det här fallet, även om varje parsningsoperation lyckas, kan inte data återställas korrekt och datakorruption uppstår. I andra fall kan en parsningsoperation misslyckas, och ett FormatException-undantag kan kastas.

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

Example

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

Se även

• CultureInfo
• IFormatProvider
• Anpassade numeriska formatsträngar