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 kulturu, které se používají při formátování a parsování čí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řit instanci objektu NumberFormatInfo pro aktuální kulturu

Instanciovat objekt NumberFormatInfo pro aktuální kulturu můžete některým z následujících způsobů. V každém případě je vrácený objekt NumberFormatInfo 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í kultury. Také načte hodnotu vlastnosti IsReadOnly, 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

Zápisný NumberFormatInfo objekt, který představuje konvence aktuální kultury, můžete vytvořit jedním z následujících způsobů:

Následující příklad ukazuje dva způsoby vytvoření instance objektu NumberFormatInfo a zobrazuje hodnotu jeho vlastnosti IsReadOnly, aby ilustrovala, že objekt není pouze 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 vlastností NumberFormatInfo používané v numerickém formátování a parsování operací prostřednictvím položky Oblast a jazyk v Ovládacích panelech. Uživatel, jehož jazyková verze je angličtina (Spojené státy), 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é byly diskutovány dříve, odrážejí uživatelská přepsání. Pokud je to nežádoucí, můžete vytvořit objekt NumberFormatInfo, který neodráží uživatelská přepsání (a který je určen pro čtení i zápis na rozdíl od pouze pro čtení) voláním konstruktoru CultureInfo.CultureInfo(String, Boolean) a zadáním hodnoty false pro argument useUserOverride. Následující příklad obsahuje ilustraci pro systém, jehož aktuální jazyková verze je Angličtina (Spojené státy) a jehož 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:    {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: $

Pokud je vlastnost CultureInfo.UseUserOverride nastavena na true, vlastnosti CultureInfo.DateTimeFormat, CultureInfo.NumberFormata 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 hodnot vlastností nejsou definovány.

Inicializujte objekt NumberFormatInfo pro invariantní kulturu

Invariantní kultura představuje kulturu, která není závislá na kulturních rozdílech. 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.

Objekt NumberFormatInfo, který představuje konvence formátování invariantní jazykové verze, můžete vytvořit následujícími způsoby:

Následující příklad používá každou z těchto metod k vytvoření instance objektu NumberFormatInfo, 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řte instanci objektu NumberFormatInfo pro konkrétní jazykovou verzi

Konkrétní kulturní prostředí představuje jazyk, kterým se mluví v určité zemi nebo regionu. 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, který představuje konvence formátování konkrétní kultury, následujícími způsoby:

Následující příklad používá tyto čtyři způsoby vytvoření NumberFormatInfo objektu, 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: {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

Vytvoření nové instance objektu NumberFormatInfo pro neutrální kulturu

Neutrální kultura představuje kulturu nebo jazyk, který je nezávislý na zemi/regionu. Obvykle je mateřskou jedné nebo více konkrétních kultur. Například "fr" je neutrální kultura pro francouzský jazyk a je nadřazenou kulturou pro kulturu fr-FR. Vytvoříte objekt NumberFormatInfo, který představuje konvence formátování neutrální jazykové verze stejným způsobem, jakým vytvoříte objekt NumberFormatInfo, 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í kultuře informace o formátování specifické pro kulturu. Místo naplnění objektu NumberFormatInfo obecnými hodnotami vrátí .NET objekt NumberFormatInfo, který odráží konvence formátování konkrétní kultury, jež je potomkem neutrální kultury. 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.

Můžete použít následující kód, podobný tomuto, k určení konvencí formátování konkrétní kulturní verze, kterou jednotlivé neutrální kulturní verze představují.

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

Dynamická data

Kultuře specifická data pro formátování číselných hodnot poskytovaná třídou NumberFormatInfo je dynamická, stejně jako data poskytovaná třídou CultureInfo. 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í kulturou 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. Když k tomu dojde, služba Windows Update zahrnuje změny hodnoty vlastnosti NumberFormatInfo pro konkrétní jazykovou verzi.

  • Náhradní kultury. Třídu CultureAndRegionInfoBuilder lze použít k nahrazení dat stávající kultury.

  • Kaskádové změny hodnot vlastností Za běhu se mohou některé vlastnosti související s nastavením jazykové oblasti změnit, což zase způsobí změnu dat NumberFormatInfo. Aktuální kulturní nastavení můžete například změnit programově nebo uživatelskou akcí. V takovém případě se NumberFormatInfo objekt vrácený CurrentInfo vlastností změní na objekt přidružený k aktuální kultuře.

  • Uživatelské předvolby. Uživatelé vaší aplikace mohou přepsat některé hodnoty přidružené k aktuální systémové kulturní verzi pomocí možností oblasti a jazyka v Ovládacím panelu. Uživatelé můžou například zvolit jiný symbol měny nebo jiný symbol oddělovače desetinných míst. Pokud je vlastnost CultureInfo.UseUserOverride nastavena na true (její výchozí hodnota), vlastnosti objektu NumberFormatInfo jsou také načteny z nastavení uživatele.

Při vytváření objektu se inicializují všechny uživatelsky přepisovatelné vlastnosti objektu NumberFormatInfo. 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, jestli se přepsání uživatelů projeví v NumberFormatInfo objektech, které představují stejnou kulturu jako aktuální kultura. Následující tabulka uvádí způsoby, jak lze NumberFormatInfo objekt načíst, a označuje, zda výsledný objekt odráží uživatelské přepsání.

Zdroj objektu CultureInfo a objektu NumberFormatInfo Odráží přednostní nastavení uživatelů.
CultureInfo.CurrentCulture.NumberFormat vlastnost Ano
NumberFormatInfo.CurrentInfo vlastnost Ano
metoda CultureInfo.CreateSpecificCulture Ano
metoda CultureInfo.GetCultureInfo Ne
CultureInfo(String) konstruktor Ano
CultureInfo.CultureInfo(String, Boolean) konstruktor Závisí na hodnotě parametru useUserOverride .

Pokud neexistuje přesvědčivý důvod k jinému postupu, měli byste respektovat uživatelská nastavení při použití objektu NumberFormatInfo v klientských aplikacích k formátování a analýze uživatelských dat nebo k zobrazování číselných dat. U serverových aplikací nebo bezobslužných aplikací byste neměli zohledňovat uživatelská nastavení. Pokud však používáte objekt NumberFormatInfo explicitně nebo implicitně k zachování číselných dat ve formě řetězce, měli byste použít objekt NumberFormatInfo, který odráží konvence formátování neutrální jazykové verze, nebo byste měli zadat vlastní číselný formátovací řetězec, který používáte bez ohledu na jazykovou verzi.

IFormatProvider, NumberFormatInfo a číselné formátování

Objekt NumberFormatInfo se implicitně nebo explicitně používá 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). Toto je metoda zpětného volání, které je předán objekt Type, reprezentující 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 instanci tohoto typu poskytnout. .NET poskytuje dvě IFormatProvider implementace pro formátování čísel:

Pokud není implementace IFormatProvider explicitně poskytnuta metodě formátování, použije se objekt CultureInfo vrácený vlastností CultureInfo.CurrentCulture, která představuje aktuální kulturu.

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

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

Pokud není implementace IFormatProvider explicitně uvedena při volání metody číselného formátování, metoda volá metodu CultureInfo.CurrentCulture.GetFormat, která vrátí objekt NumberFormatInfo, 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 hodnotu Decimal 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 při následujících voláních metody Decimal.ToString() bez parametrů (nebo výchozí) je hodnota instance Decimal formátována pomocí obecného specifikátoru formátu ("G") a konvencí aktuální jazykové verze, která je v tomto případě kultura 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 vlastností NumberFormatInfo 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 NumberFormatInfo vlastnostmi. Následující tabulka uvádí standardní a vlastní specifikátory číselného formátu a jejich přidružené vlastnosti NumberFormatInfo. Aby jste změnili vzhled výsledného řetězce pro konkrétní kulturní prostředí, odkažte se na sekci Modify NumberFormatInfo properties. 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, definovat výchozí počet desetinných číslic.

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

CurrencyGroupSeparatordefinovat oddělovač skupin nebo tisíců.

CurrencyGroupSizes, aby se definovaly velikosti integrálních skupin.

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

CurrencyPositivePatterndefinovat vzor kladných hodnot měny.

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

NegativeSign, definovat symbol záporného znaménka.
"D" nebo "d" (specifikátor desetinného formátu) NegativeSign, definovat symbol záporného znaménka.
"E" nebo "e" (exponenciální nebo vědecký specifikátor formátu) NegativeSign, definuje symbol záporného znaménka v mantise a exponentu.

NumberDecimalSeparatork 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, definovat symbol záporného znaménka.

NumberDecimalDigits, definovat výchozí počet desetinných číslic.

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

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

PositiveSign, definovat symbol 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, definovat symbol záporného znaménka.

NumberDecimalDigits, definovat výchozí počet desetinných číslic.

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

NumberGroupSeparator, pro definování symbolu oddělovače skupin (tisíce).

NumberGroupSizesdefinovat počet integrálních číslic ve skupině.

NumberNegativePatterndefinovat formát záporných hodnot.
"P" nebo "p" (specifikátor formátu procenta) NegativeSign, definovat symbol záporného znaménka.

PercentDecimalDigits, definovat výchozí počet desetinných číslic.

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

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

PercentGroupSizesdefinovat počet 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, definovat umístění symbolu procenta pro kladné hodnoty.

PercentSymbol, pro definování symbolu procenta.
"R" nebo "r" (specifikátor formátu tam a zpět) NegativeSign, definovat symbol záporného znaménka.

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

PositiveSignk definování symbolu kladného znaménka v exponentu.
"X" nebo "x" (specifikátor šestnáctkového formátu) Žádné.
"." (specifikátor vlastního formátu desetinné čárky) NumberDecimalSeparatork definování symbolu oddělovače desetinných míst.
"," (specifikátor vlastního formátu oddělovače skupin) NumberGroupSeparatorpro definování symbolu oddělovače skupiny (tisíce).
"%" (specifikátor vlastního formátu zástupného symbolu procent) PercentSymbol, pro definování symbolu procenta.
"‰" (specifikátor vlastního formátu zástupného symbolu promile) PerMilleSymbol, k definování symbolu promile.
"E" (specifikátor vlastního formátu exponenciální notace) NegativeSign, definuje symbol záporného znaménka v mantise a exponentu.

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

Všimněte si, že třída NumberFormatInfo obsahuje vlastnost NativeDigits, která určuje desítkovou soustavu používanou určitou kulturou. 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 Double hodnoty NaN, PositiveInfinitya NegativeInfinityse výsledný řetězec skládá výhradně ze symbolů definovaných NaNSymbol, PositiveInfinitySymbola NegativeInfinitySymbol vlastností.

Úprava vlastností NumberFormatInfo

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

  1. Vytvořte kopii objektu NumberFormatInfo pro čtení a zápis, jehož konvence formátování chcete upravit. Další informace najdete v oddílu Instanciace 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í vlastnosti NumberFormatInfo k definování výsledných řetězců, naleznete v oddílu Formát řetězců a v oddílu Vlastnosti NumberFormatInfo.

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

Poznámka:

Místo dynamické úpravy hodnot vlastností jazykové verze při každém spuštění aplikace můžete pomocí třídy CultureAndRegionInfoBuilder definovat vlastní jazykovou verzi (jazykovou verzi, která má jedinečný název a který 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í objekt NumberFormatInfo, který představuje formátovací konvence kultury en-US. Přiřadí symbol měny ISO-4217 vlastnosti CurrencySymbol 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átovat národní identifikační číslo

Mnoho národních identifikačních čísel se skládá výhradně z číslic, a tak lze snadno formátovat úpravou vlastností objektu NumberFormatInfo. Například číslo sociálního pojištění ve Spojených státech 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 out argumentu a vrátí hodnotu Boolean, která označuje, zda převod proběhl úspěšně.

Metody analýzy implicitně nebo explicitně používají hodnotu NumberStyles výčtu k určení, jaké prvky stylu (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á. Pokud NumberStyles hodnota není zadána ve volání metody, výchozí hodnota je NumberStyles hodnota, která obsahuje příznaky Float a AllowThousands, což 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. Pokud objekt NumberFormatInfo není zadaný, je výchozí NumberFormatInfo pro aktuální kulturní prostředí. Další informace o analýze naleznete v jednotlivých metodách analýzy, jako jsou 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 ilustruje kulturně citlivou povahu syntaktické analýzy řetězců. Snaží se analyzovat řetězec, který obsahuje oddělovače tisíců pomocí konvencí en-US, fr-FRa invariantních jazykových verzí. Řetězec, který obsahuje čárku jako oddělovač skupin a tečku jako oddělovač desetinných míst, se nepodaří analyzovat v jazykové verzi fr-FR, a řetězec s prázdným znakem jako oddělovačem skupin a čárkou jako oddělovačem desetinných míst se nepodaří analyzovat v jazykové verzi en-US a v 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($"'{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)

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 zaokrouhlila číselnou hodnotu; a to znamená deserializaci stejné číselné hodnoty, 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 objektu NumberFormatInfo, který odráží kulturní nastavení uživatele. Informace o tom, jak vytvořit instanci objektu NumberFormatInfo, který zohledňuje uživatelská přizpůsobení, najdete v části Dynamické datové.

Následující příklad znázorňuje rozdíl mezi operací analýzy, která odráží kulturní nastavení uživatele, a operací, která nikoli. V tomto případě je výchozí systémová kultura en-US, ale uživatel definoval "," jako oddělovač desetinných míst a "." jako oddělovač skupin v Ovládacích panelech, Oblast a jazyk. Tyto symboly jsou obvykle obrácené ve výchozí kultuře en-US. Když uživatel zadá řetězec, který odráží uživatelská nastavení, a tento řetězec se analyzuje objektem NumberFormatInfo, který také odráží (případně přepisuje) uživatelská nastavení, vrátí operace analýzy správný výsledek. Pokud je však řetězec analyzován objektem NumberFormatInfo, který odráží standardní en-US kulturní nastavení, zaměňuje symbol čárky za 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($"{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

Serializace a deserializace číselných dat

Když jsou číselná data serializována ve formátu řetězce a následně deserializována a analyzována, měly by být řetězce generovány a zpracovány s použitím konvencí invariantní kultury. 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 kulturu en-US. Data se pak zpracovávají pomocí vlákna, které používá nastavení specifické pro kulturu pt-BR. V tomto případě, i když každá analýza proběhne úspěšně, data se úspěšně neobnovují a dojde k poškození dat. V jiných případech může operace analýzy selhat a vyvolá se výjimka 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