Sdílet prostřednictvím

Třída NumberFormatInfo

  • Článek

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Třída NumberFormatInfo obsahuje informace specifické pro jazykovou verzi, které se používají při formátování a analýze číselných hodnot. Tyto informace zahrnují symbol měny, desetinný symbol, symbol oddělovače skupin a symboly pro kladné a záporné znaménka.

Vytvoření instance objektu NumberFormatInfo

Můžete vytvořit instanci objektu NumberFormatInfo , který představuje konvence formátování aktuální jazykové verze, invariantní jazykovou verzi, konkrétní jazykovou verzi nebo neutrální jazykovou verzi.

Vytvoření instance objektu NumberFormatInfo pro aktuální jazykovou verzi

K vytvoření instance objektu NumberFormatInfo pro aktuální jazykovou verzi můžete použít libovolný z následujících způsobů. V každém případě je vrácený NumberFormatInfo objekt jen pro čtení.

Následující příklad používá tyto tři způsoby vytvoření NumberFormatInfo objektů, které představují konvence formátování aktuální jazykové verze. Také načte hodnotu IsReadOnly vlastnosti, která ilustruje, že každý objekt je jen pro čtení.

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

Zapisovatelný NumberFormatInfo objekt, který představuje konvence aktuální jazykové verze, můžete vytvořit některým z následujících způsobů:

Následující příklad znázorňuje tyto dva způsoby vytvoření instance objektu NumberFormatInfo a zobrazí hodnotu jeho IsReadOnly vlastnosti, která ilustruje, že objekt není jen pro čtení.

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

Operační systém Windows umožňuje uživateli přepsat některé hodnoty NumberFormatInfo vlastností používané v číselném formátování a parsování operací prostřednictvím položky Oblast a jazyk v Ovládací panely. Uživatel, jehož jazyková verze je angličtina (USA), se může například rozhodnout zobrazit hodnoty měny jako 1,1 USD místo výchozí hodnoty 1,1 USD. Objekty NumberFormatInfo načtené způsoby, které jsme probírali dříve, odrážejí přepsání těchto uživatelů. Pokud je to nežádoucí, můžete vytvořit NumberFormatInfo objekt, který neodráží přepsání uživatele (a to je také pro čtení a zápis místo jen pro čtení) voláním konstruktoru CultureInfo.CultureInfo(String, Boolean) a zadáním hodnoty argumentu falseuseUserOverride . Následující příklad obsahuje ilustraci pro systém, jehož aktuální jazyková verze je angličtina (USA) a jejíž symbol měny byl změněn z výchozí hodnoty $ na 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:    {0}", culture.Name);
        Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
        Console.WriteLine("Currency Symbol: {0}\n", culture.NumberFormat.CurrencySymbol);

        culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
        Console.WriteLine("Culture Name:    {0}", culture.Name);
        Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
        Console.WriteLine("Currency Symbol: {0}", 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: $

Pokud je vlastnost nastavena CultureInfo.UseUserOverride na true, vlastnosti CultureInfo.DateTimeFormatCultureInfo.NumberFormat, a CultureInfo.TextInfo jsou také načteny z uživatelských nastavení. Pokud uživatelská nastavení nejsou kompatibilní s jazykovou verzí přidruženou k objektu CultureInfo (například pokud vybraný kalendář není jedním z kalendářů uvedených vlastností OptionalCalendars ), výsledky metod a hodnoty vlastností nejsou definovány.

Vytvoření instance objektu NumberFormatInfo pro invariantní jazykovou verzi

Invariantní jazyková verze představuje jazykovou verzi, která není závislá na jazykové verzi. Je založená na anglickém jazyce, ale ne na konkrétní zemi nebo oblasti pro angličtinu. I když data konkrétních jazykových verzí můžou být dynamická a můžou se měnit tak, aby odrážela nové kulturní konvence nebo uživatelské předvolby, data invariantní jazykové verze se nemění. Objekt NumberFormatInfo , který představuje konvence formátování invariantní jazykové verze lze použít pro operace formátování, ve kterých by se výsledné řetězce neměly lišit podle jazykové verze.

Vytvořit instanci objektu NumberFormatInfo , který představuje konvence formátování invariantní jazykové verze následujícími způsoby:

Následující příklad používá každou z těchto metod k vytvoření instance NumberFormatInfo objektu, který představuje invariantní jazykovou verzi. Potom určuje, jestli je objekt jen pro čtení.

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

Vytvoření instance objektu NumberFormatInfo pro konkrétní jazykovou verzi

Konkrétní jazyková verze představuje jazyk, který se mluví v konkrétní zemi nebo oblasti. En-US je například specifická jazyková verze, která představuje anglický jazyk mluvený v USA a en-CA je specifická jazyková verze, která představuje anglický jazyk mluvený v Kanadě. Můžete vytvořit instanci objektu NumberFormatInfo , který představuje konvence formátování konkrétní jazykové verze následujícími způsoby:

Následující příklad používá tyto čtyři způsoby vytvoření objektu NumberFormatInfo , který odráží konvence formátování indonéštiny (Indonésie). Označuje také, jestli je každý objekt jen pro čtení.

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: {0}", nfi.IsReadOnly);

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

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

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

Vytvoření instance objektu NumberFormatInfo pro neutrální jazykovou verzi

Neutrální jazyková verze představuje jazyk nebo jazyk, který je nezávislý na zemi/oblasti. Obvykle se jedná o nadřazenou jednu nebo více specifických jazykových verzí. Fr je například neutrální jazyková verze francouzského jazyka a nadřazená jazyková verze fr-FR. Vytvoříte NumberFormatInfo objekt, který představuje konvence formátování neutrální jazykové verze stejným způsobem, jakým vytvoříte NumberFormatInfo objekt, který představuje konvence formátování konkrétní jazykové verze.

Vzhledem k tomu, že je nezávislá na konkrétní zemi nebo oblasti, chybí neutrální jazyková verze informace o formátování specifické pro jazykovou verzi. Místo naplnění objektu NumberFormatInfo obecnými hodnotami vrátí NumberFormatInfo .NET objekt, který odráží konvence formátování konkrétní jazykové verze, která je podřízeným objektem neutrální jazykové verze. Například NumberFormatInfo objekt pro neutrální jazykovou verzi en-culture odráží konvence formátování jazykové verze en-US a NumberFormatInfo objekt pro jazykovou verzi fr-FR odráží konvence formátování jazykové verze fr-FR.

Kód podobný následujícímu kódu můžete použít k určení konvencí formátování konkrétní jazykové verze, které představují jednotlivé neutrální jazykové verze.

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 '{0}' matches '{1}'",
                                          name, ci.Name);
                hasOneMatch = true;
            }
        }
        if (!hasOneMatch)
            Console.WriteLine("NumberFormatInfo object for '{0}' --> No Match", name);

        Console.WriteLine();
    }
}

Dynamická data

Data specifická pro jazykovou verzi pro formátování číselných hodnot poskytovaných NumberFormatInfo třídou jsou dynamická, stejně jako kulturní data poskytovaná CultureInfo třídou. Neměli byste provádět žádné předpoklady o stabilitě hodnot pro NumberFormatInfo objekty, které jsou přidruženy k určitým CultureInfo objektům. Stabilní jsou pouze data poskytovaná invariantní jazykovou verzí a přidruženým NumberFormatInfo objektem. Jiná data se můžou mezi relacemi aplikace nebo dokonce v rámci jedné relace měnit z následujících důvodů:

  • Aktualizace systému. Kulturní předvolby, jako je symbol měny nebo formáty měny, se mění v průběhu času. Pokud k tomu dojde, služba Windows Update zahrnuje změny NumberFormatInfo hodnoty vlastnosti pro určitou jazykovou verzi.

  • Náhradní jazykové verze. Třídu CultureAndRegionInfoBuilder lze použít k nahrazení dat existující jazykové verze.

  • Kaskádové změny hodnot vlastností V době běhu se může změnit řada vlastností souvisejících s jazykovou verzí, což zase způsobí NumberFormatInfo změnu dat. Aktuální jazykovou verzi můžete například změnit prostřednictvím kódu programu nebo prostřednictvím akce uživatele. V takovém případě se NumberFormatInfo objekt vrácený CurrentInfo vlastností změní na objekt přidružený k aktuální jazykové verzi.

  • Uživatelské předvolby. Uživatelé vaší aplikace můžou přepsat některé hodnoty spojené s aktuální jazykovou verzí systému prostřednictvím oblasti a jazykových možností v Ovládací panely. Uživatelé můžou například zvolit jiný symbol měny nebo jiný symbol oddělovače desetinných míst. CultureInfo.UseUserOverride Pokud je vlastnost nastavena na true (její výchozí hodnota), vlastnosti objektu NumberFormatInfo jsou také načteny z uživatelských nastavení.

Při vytváření objektu se inicializují všechny vlastnosti přepsatelné uživatelem NumberFormatInfo objektu. Stále existuje možnost nekonzistence, protože ani vytvoření objektu ani proces přepsání uživatelem není atomický a příslušné hodnoty se mohou během vytváření objektu změnit. Tyto nekonzistence by však měly být extrémně vzácné.

Můžete určit, zda se přepsání uživatele projeví v NumberFormatInfo objektech, které představují stejnou jazykovou verzi jako aktuální jazyková verze. Následující tabulka uvádí způsoby, kterými NumberFormatInfo lze objekt načíst, a označuje, zda výsledný objekt odráží přepsání uživatele.

Zdroj CultureInfo a NumberFormatInfo objektu Reflexe s user overrides
CultureInfo.CurrentCulture.NumberFormat Vlastnost Ano
NumberFormatInfo.CurrentInfo Vlastnost Ano
CultureInfo.CreateSpecificCulture Metoda Ano
CultureInfo.GetCultureInfo Metoda No
CultureInfo(String) Konstruktor Ano
CultureInfo.CultureInfo(String, Boolean) Konstruktor Závisí na hodnotě parametru useUserOverride .

Pokud neexistuje přesvědčivý důvod, proč byste jinak měli respektovat přepsání uživatelů při použití objektu NumberFormatInfo v klientských aplikacích k formátování a analýze uživatelského vstupu nebo k zobrazení číselných dat. U serverových aplikací nebo bezobslužných aplikací byste neměli respektovat přepsání uživatelů. Pokud však objekt používáte NumberFormatInfo explicitně nebo implicitně k zachování číselných dat ve formě řetězce, měli byste použít NumberFormatInfo objekt, který odráží konvence formátování invariantní jazykové verze, nebo byste měli zadat vlastní řetězec číselného formátu, který používáte bez ohledu na jazykovou verzi.

IFormatProvider, NumberFormatInfo a formátování čísel

Objekt NumberFormatInfo se používá implicitně nebo explicitně ve všech operacích číselného formátování. Patří mezi ně volání následujících metod:

Všechny operace číselného formátování využívají implementaci IFormatProvider . Rozhraní IFormatProvider obsahuje jednu metodu, GetFormat(Type). Jedná se o metodu zpětného volání, která je předána Type objekt, který představuje typ potřebný k poskytnutí informací o formátování. Metoda je zodpovědná za vrácení instance tohoto typu nebo null, pokud nemůže poskytnout instanci typu. .NET poskytuje dvě IFormatProvider implementace pro formátování čísel:

IFormatProvider Pokud implementace není k dispozici pro metodu formátování explicitně, CultureInfo je použit objekt vrácený CultureInfo.CurrentCulture vlastností, která představuje aktuální jazykovou verzi.

Následující příklad znázorňuje vztah mezi IFormatProvider rozhraním a NumberFormatInfo třídou v operacích formátování definováním vlastní IFormatProvider implementace. Jeho GetFormat metoda zobrazí název typu objektu požadovaného operací formátování. Pokud rozhraní požaduje NumberFormatInfo objekt, tato metoda poskytuje NumberFormatInfo objekt pro aktuální jazykovou verzi. Jak ukazuje výstup z příkladu, Decimal.ToString(IFormatProvider) metoda požaduje NumberFormatInfo objekt k poskytnutí informací o formátování, zatímco String.Format(IFormatProvider, String, Object[]) požadavky NumberFormatInfo metody a DateTimeFormatInfo objekty i ICustomFormatter implementace.

using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
    public Object GetFormat(Type formatType)
    {
        Console.WriteLine("Requesting an object of type {0}",
                          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

IFormatProvider Pokud implementace není explicitně poskytnuta ve volání metody číselného formátování, metoda volá metodu CultureInfo.CurrentCulture.GetFormatNumberFormatInfo, která vrátí objekt, který odpovídá aktuální jazykové verzi.

Formátování řetězců a vlastností NumberFormatInfo

Každá operace formátování používá standardní nebo vlastní řetězec číselného formátu k vytvoření výsledného řetězce z čísla. V některých případech je použití formátového řetězce k vytvoření výsledného řetězce explicitní, jako v následujícím příkladu. Tento kód volá metodu Decimal.ToString(IFormatProvider) , která převede Decimal hodnotu na řadu různých řetězcových reprezentací pomocí konvencí formátování jazykové verze en-US.

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

V jiných případech je použití formátového řetězce implicitní. Například v následující metodě volání výchozí nebo bezparametrové Decimal.ToString() metody je hodnota Decimal instance formátována pomocí obecného specifikátoru formátu ("G") a konvencí aktuální jazykové verze, což je v tomto případě jazyková verze en-US.

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

Každý standardní řetězec číselného formátu používá jednu nebo více NumberFormatInfo vlastností k určení vzoru nebo symbolů použitých ve výsledném řetězci. Podobně každý specifikátor vlastního číselného formátu kromě "0" a "#" vloží symboly ve výsledném řetězci, které jsou definovány vlastnostmi NumberFormatInfo . Následující tabulka uvádí standardní a vlastní specifikátory číselného formátu a jejich přidružené NumberFormatInfo vlastnosti. Pokud chcete změnit vzhled výsledného řetězce pro konkrétní jazykovou verzi, přečtěte si část Upravit vlastnosti NumberFormatInfo. Podrobnosti o použití těchto specifikátorů formátu naleznete v tématu Standardní řetězce číselného formátu a vlastní řetězce číselného formátu.

Specifikátor formátu Přidružené vlastnosti
"C" nebo "c" (specifikátor formátu měny) CurrencyDecimalDigits, pro definování výchozího počtu desetinných číslic.

CurrencyDecimalSeparator, pro definování symbolu oddělovače desetinných míst.

CurrencyGroupSeparator, pro definování oddělovače skupin nebo tisíců.

CurrencyGroupSizesdefinovat velikosti integrálních skupin.

CurrencyNegativePattern, definovat vzor záporných hodnot měny.

CurrencyPositivePatterndefinovat vzor kladných hodnot měny.

CurrencySymbol, pro definování symbolu měny.

NegativeSign, pro definování symbolu záporného znaménka.
"D" nebo "d" (specifikátor formátu desetinných míst) NegativeSign, pro definování symbolu záporného znaménka.
"E" nebo "e" (exponenciální nebo vědecký specifikátor formátu) NegativeSign, definovat symbol záporného znaménka v mantisu a exponentu.

NumberDecimalSeparator, pro definování symbolu oddělovače desetinných míst.

PositiveSign, pro definování symbolu kladného znaménka v exponentu.
"F" nebo "f" (specifikátor formátu s pevným bodem) NegativeSign, pro definování symbolu záporného znaménka.

NumberDecimalDigits, pro definování výchozího počtu desetinných číslic.

NumberDecimalSeparator, pro definování symbolu oddělovače desetinných míst.
"G" nebo "g" (specifikátor obecného formátu) NegativeSign, pro definování symbolu záporného znaménka.

NumberDecimalSeparator, pro definování symbolu oddělovače desetinných míst.

PositiveSign, pro definování symbolu kladného znaménka pro výsledné řetězce v exponenciálním formátu.
"N" nebo "n" (specifikátor číselného formátu) NegativeSign, pro definování symbolu záporného znaménka.

NumberDecimalDigits, pro definování výchozího počtu desetinných číslic.

NumberDecimalSeparator, pro definování symbolu oddělovače desetinných míst.

NumberGroupSeparatora definujte oddělovač skupin (tisíce).

NumberGroupSizes, pro definování počtu integrálních číslic ve skupině.

NumberNegativePattern, definovat formát záporných hodnot.
"P" nebo "p" (specifikátor formátu procenta) NegativeSign, pro definování symbolu záporného znaménka.

PercentDecimalDigits, pro definování výchozího počtu desetinných číslic.

PercentDecimalSeparator, pro definování symbolu oddělovače desetinných míst.

PercentGroupSeparator, pro definování symbolu oddělovače skupin.

PercentGroupSizes, pro definování počtu integrálních číslic ve skupině.

PercentNegativePattern, pro definování umístění symbolu procenta a záporného symbolu pro záporné hodnoty.

PercentPositivePattern, pro definování umístění symbolu procenta pro kladné hodnoty.

PercentSymbol, pro definování symbolu procenta.
"R" nebo "r" (specifikátor formátu odezvy) NegativeSign, pro definování symbolu záporného znaménka.

NumberDecimalSeparator, pro definování symbolu oddělovače desetinných míst.

PositiveSign, definovat symbol kladného znaménka v exponentu.
"X" nebo "x" (specifikátor šestnáctkového formátu) Nezaokrouhlovat.
"." (specifikátor vlastního formátu desetinné čárky) NumberDecimalSeparator, pro definování symbolu oddělovače desetinných míst.
"," (specifikátor vlastního formátu oddělovače skupin) NumberGroupSeparatora definujte symbol oddělovače skupin (tisíců).
"%" (specifikátor vlastního formátu zástupného symbolu procenta) PercentSymbol, pro definování symbolu procenta.
"‰" (specifikátor vlastního formátu zástupného symbolu mile) PerMilleSymbol, pro definování symbolu mile.
"E" (specifikátor vlastního formátu exponenciální notace) NegativeSign, definovat symbol záporného znaménka v mantisu a exponentu.

PositiveSign, pro definování symbolu kladného znaménka v exponentu.

Všimněte si, že NumberFormatInfo třída obsahuje NativeDigits vlastnost, která určuje základní 10 číslice používané konkrétní jazykovou verzí. Vlastnost se však nepoužívá v operacích formátování; Ve výsledném řetězci se používají pouze číslice základní latinky 0 (U+0030) až 9 (U+0039). Kromě toho, pro Single a hodnoty NaN, PositiveInfinitya DoubleNegativeInfinity, výsledné řetězce se skládá výhradně ze symbolů definovaných NaNSymbol, PositiveInfinitySymbola NegativeInfinitySymbol vlastnosti, v uvedeném pořadí.

Úprava vlastností NumberFormatInfo

Vlastnosti objektu NumberFormatInfo můžete upravit tak, aby přizpůsobily výsledný řetězec vytvořený v číselné operaci formátování. Akce:

  1. Vytvořte kopii objektu NumberFormatInfo pro čtení a zápis, jehož konvence formátování chcete upravit. Další informace najdete v části Vytvoření instance objektu NumberFormatInfo.

  2. Upravte vlastnost nebo vlastnosti, které slouží k vytvoření požadovaného výsledného řetězce. Informace o tom, jak formátovací metody používají NumberFormatInfo vlastnosti k definování výsledných řetězců, naleznete v části Formát řetězců a NumberFormatInfo vlastnosti .

  3. NumberFormatInfo Vlastní objekt použijte jako IFormatProvider argument ve voláních metod formátování.

Poznámka:

Místo dynamické úpravy hodnot vlastností jazykové verze při každém spuštění aplikace můžete pomocí CultureAndRegionInfoBuilder třídy definovat vlastní jazykovou verzi (jazykovou verzi, která má jedinečný název a doplňuje existující jazykové verze) nebo náhradní jazykovou verzi (která se používá místo konkrétní jazykové verze).

V následujících částech najdete několik příkladů.

Změna symbolu a vzoru měny

Následující příklad upraví NumberFormatInfo objekt, který představuje konvence formátování jazykové verze en-US. Přiřadí vlastnost symbol CurrencySymbol měny ISO-4217 a definuje vzor hodnot měny, který se skládá ze symbolu měny následovaného mezerou a číselnou hodnotou.

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

Formátování národního identifikačního čísla

Mnoho národních identifikačních čísel se skládá výhradně z číslic a lze je tak snadno naformátovat úpravou vlastností objektu NumberFormatInfo . Například číslo sociálního pojištění v USA se skládá z 9 číslic uspořádaných takto: XXX-XX-XXXX. Následující příklad předpokládá, že čísla sociálního pojištění jsou uložena jako celočíselné hodnoty a formátují je odpovídajícím způsobem.

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

Parsování číselných řetězců

Analýza zahrnuje převod řetězcové reprezentace čísla na číslo. Každý číselný typ v .NET obsahuje dvě přetížené metody analýzy: Parse a TryParse. Metoda Parse převede řetězec na číslo a vyvolá výjimku, pokud převod selže. Metoda TryParse převede řetězec na číslo, přiřadí číslo argumentu out a vrátí Boolean hodnotu, která označuje, zda převod proběhl úspěšně.

Metody analýzy implicitně nebo explicitně používají NumberStyles hodnotu výčtu k určení, jaké stylové prvky (například oddělovače skupin, oddělovač desetinných míst nebo symbol měny) mohou být přítomny v řetězci, pokud je operace analýzy úspěšná. NumberStyles Pokud hodnota není zadána ve volání metody, výchozí hodnota je NumberStyles hodnota, která zahrnuje Float a AllowThousands příznaky, které určuje, že analyzovaný řetězec může obsahovat symboly skupiny, oddělovač desetinných míst, záporné znaménko a prázdné znaky, nebo může být řetězcovou reprezentací čísla v exponenciálním zápisu.

Metody analýzy také implicitně nebo explicitně používají NumberFormatInfo objekt, který definuje konkrétní symboly a vzory, které mohou nastat v řetězci, které se mají analyzovat. NumberFormatInfo Pokud objekt není zadaný, výchozí hodnota je NumberFormatInfo pro aktuální jazykovou verzi. Další informace o parsování naleznete v jednotlivých metodách analýzy, například Int16.Parse(String), , Int32.Parse(String, NumberStyles)Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double)a BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

Následující příklad znázorňuje povahu analýzy řetězců citlivých na jazykovou verzi. Snaží se analyzovat řetězec, který obsahuje oddělovače tisíců pomocí konvencí en-US, fr-FR a invariantních jazykových verzí. Řetězec, který obsahuje čárku jako oddělovač skupiny a tečka jako oddělovač desetinných míst se nepodaří parsovat v jazykové verzi fr-FR, a řetězec s prázdným znakem jako oddělovač skupiny a čárka jako oddělovač desetinných míst se nepodaří parsovat v en-US a invariantní jazykové verzi.

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("'{0}' --> {1} ({2})", value, amount, name);
                }
                catch (FormatException)
                {
                    Console.WriteLine("'{0}': FormatException ({1})",
                                      value, 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)

Analýza obvykle probíhá ve dvou kontextech:

  • Jako operace, která je navržená k převodu uživatelského vstupu na číselnou hodnotu.

  • Jako operace, která je navržena tak, aby zaokrouhluje číselnou hodnotu; to znamená, že chcete deserializovat číselnou hodnotu, která byla dříve serializována jako řetězec.

Tyto dvě operace jsou podrobněji popsány v následujících částech.

Analýza uživatelských řetězců

Když analyzujete číselné řetězce zadané uživatelem, měli byste vždy vytvořit instanci NumberFormatInfo objektu, který odráží kulturní nastavení uživatele. Informace o vytvoření instance objektu NumberFormatInfo , který odráží přizpůsobení uživatele, naleznete v části Dynamická data .

Následující příklad znázorňuje rozdíl mezi operací analýzy, která odráží kulturní nastavení uživatele a která neodpovídá. V tomto případě je výchozí systémová jazyková verze en-US, ale uživatel definoval ", jako oddělovač desetinných míst a "" jako oddělovač skupiny v Ovládací panely, oblasti a jazyku. Obvykle jsou tyto symboly v výchozí jazykové verzi en-US obrácené. Když uživatel zadá řetězec, který odráží nastavení uživatele a řetězec se analyzuje objektem NumberFormatInfo , který také odráží uživatelská nastavení (přepsání), vrátí operace analýzy správný výsledek. Pokud je však řetězec analyzován objektem NumberFormatInfo , který odráží standardní kulturní nastavení en-US, chybí symbol čárky pro oddělovač skupin a vrátí nesprávný výsledek.

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("{0} culture reflects user overrides: {1}",
                              stdCulture.Name, stdCulture.UseUserOverride);
            Decimal amount = Decimal.Parse(value, stdCulture);
            Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture));
        }
        catch (FormatException)
        {
            Console.WriteLine("Unable to parse '{0}'", value);
        }
        Console.WriteLine();

        try
        {
            Console.WriteLine("{0} culture reflects user overrides: {1}",
                              custCulture.Name, custCulture.UseUserOverride);
            Decimal amount = Decimal.Parse(value, custCulture);
            Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture));
        }
        catch (FormatException)
        {
            Console.WriteLine("Unable to parse '{0}'", 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

Serializace a deserializace číselných dat

Při serializaci číselných dat ve formátu řetězce a pozdější deserializaci a parsování by měly být řetězce generovány a analyzovány pomocí konvencí invariantní jazykové verze. Operace formátování a analýzy by nikdy neměly odrážet konvence konkrétní jazykové verze. Pokud se použijí nastavení specifická pro jazykovou verzi, přenositelnost dat je přísně omezená; může být úspěšně deserializován pouze ve vlákně, jehož nastavení specifické pro jazykovou verzi jsou identická s vláknem, na kterém byla serializována. V některých případech to znamená, že data nemohou být ani úspěšně deserializována ve stejném systému, na kterém byla serializována.

Následující příklad ukazuje, co se může stát, když je tento princip porušen. Hodnoty s plovoucí desetinnou čárkou v poli se převedou na řetězce, když aktuální vlákno používá nastavení specifické pro jazykovou verzi en-US. Data se pak analyzují vláknem, které používá nastavení jazykové verze jazykové verze jazykové verze pt-BR. V tomto případě i když každá operace analýzy proběhne úspěšně, data se úspěšně neprovádí a dojde k poškození dat. V jiných případech může operace analýzy selhat a může dojít k výjimce FormatException .

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