NumberFormatInfo Třída

Definice

Poskytuje informace specifické pro jazykovou verzi pro formátování a analýzu číselných hodnot.

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
Dědičnost
NumberFormatInfo
Atributy
Implementuje

Příklady

Následující příklad ukazuje, jak načíst NumberFormatInfo objekt pro odpovídající CultureInfo objekt a použít načtený objekt k dotazování na informace formátování čísel pro konkrétní jazykovou verzi.

using namespace System;
using namespace System::Globalization;
using namespace System::Text;

int main()
{
    StringBuilder^ builder = gcnew StringBuilder();

    // Loop through all the specific cultures known to the CLR.
    for each(CultureInfo^ culture in 
        CultureInfo::GetCultures (CultureTypes::SpecificCultures)) 
    {
        // Only show the currency symbols for cultures 
        // that speak English.
        if (culture->TwoLetterISOLanguageName == "en")
        {
            // Display the culture name and currency symbol.
            NumberFormatInfo^ numberFormat = culture->NumberFormat;
            builder->AppendFormat("The currency symbol for '{0}'"+
                "is '{1}'",culture->DisplayName,
                numberFormat->CurrencySymbol);
            builder->AppendLine();
        }
    }
    Console::WriteLine(builder);
}

// This code produces the following output.
//
// The currency symbol for 'English (United States)' is '$'
// The currency symbol for 'English (United Kingdom)' is 'Ј'
// The currency symbol for 'English (Australia)' is '$'
// The currency symbol for 'English (Canada)' is '$'
// The currency symbol for 'English (New Zealand)' is '$'
// The currency symbol for 'English (Ireland)' is '?'
// The currency symbol for 'English (South Africa)' is 'R'
// The currency symbol for 'English (Jamaica)' is 'J$'
// The currency symbol for 'English (Caribbean)' is '$'
// The currency symbol for 'English (Belize)' is 'BZ$'
// The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
// The currency symbol for 'English (Zimbabwe)' is 'Z$'
// The currency symbol for 'English (Republic of the Philippines)' is 'Php'
using System;
using System.Globalization;
using System.Text;

public sealed class App
{
    static void Main()
    {
        StringBuilder sb = new StringBuilder();

        // Loop through all the specific cultures known to the CLR.
        foreach (CultureInfo ci in CultureInfo.GetCultures(CultureTypes.SpecificCultures))
        {
            // Only show the currency symbols for cultures that speak English.
            if (ci.TwoLetterISOLanguageName != "en") continue;

            // Display the culture name and currency symbol.
            NumberFormatInfo nfi = ci.NumberFormat;
            sb.AppendFormat("The currency symbol for '{0}' is '{1}'",
                ci.DisplayName, nfi.CurrencySymbol);
            sb.AppendLine();
        }
        Console.WriteLine(sb.ToString());
    }
}

// This code produces the following output.
//
// The currency symbol for 'English (United States)' is '$'
// The currency symbol for 'English (United Kingdom)' is '£'
// The currency symbol for 'English (Australia)' is '$'
// The currency symbol for 'English (Canada)' is '$'
// The currency symbol for 'English (New Zealand)' is '$'
// The currency symbol for 'English (Ireland)' is '?'
// The currency symbol for 'English (South Africa)' is 'R'
// The currency symbol for 'English (Jamaica)' is 'J$'
// The currency symbol for 'English (Caribbean)' is '$'
// The currency symbol for 'English (Belize)' is 'BZ$'
// The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
// The currency symbol for 'English (Zimbabwe)' is 'Z$'
// The currency symbol for 'English (Republic of the Philippines)' is 'Php'
Imports System.Globalization
Imports System.Text

Public Module Example
   Public Sub Main() 
      Dim sb As New StringBuilder()

      ' Loop through all the specific cultures known to the CLR.
      For Each ci In CultureInfo.GetCultures(CultureTypes.SpecificCultures) 
         ' Only show the currency symbols for cultures that speak English.
         If ci.TwoLetterISOLanguageName <> "en" Then Continue For

         ' Display the culture name and currency symbol.
         Dim nfi As NumberFormatInfo = ci.NumberFormat
         sb.AppendFormat("The currency symbol for '{0}' is '{1}'",
                         ci.DisplayName, nfi.CurrencySymbol)
         sb.AppendLine()
      Next
      Console.WriteLine(sb.ToString())
   End Sub
End Module
' The example displays output like the following:
'       The currency symbol for 'English (United States)' is '$'
'       The currency symbol for 'English (United Kingdom)' is '£'
'       The currency symbol for 'English (Australia)' is '$'
'       The currency symbol for 'English (Canada)' is '$'
'       The currency symbol for 'English (New Zealand)' is '$'
'       The currency symbol for 'English (Ireland)' is '?'
'       The currency symbol for 'English (South Africa)' is 'R'
'       The currency symbol for 'English (Jamaica)' is 'J$'
'       The currency symbol for 'English (Caribbean)' is '$'
'       The currency symbol for 'English (Belize)' is 'BZ$'
'       The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
'       The currency symbol for 'English (Zimbabwe)' is 'Z$'
'       The currency symbol for 'English (Republic of the Philippines)' is 'Php'
'       The currency symbol for 'English (India)' is 'Rs.'
'       The currency symbol for 'English (Malaysia)' is 'RM'
'       The currency symbol for 'English (Singapore)' is '$'

Poznámky

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 skupiny a symboly pro kladné a záporné znaménka.

Vytvoření instance objektu NumberFormatInfo

Můžete vytvořit instanci NumberFormatInfo objektu, 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

Instanci objektu NumberFormatInfo pro aktuální jazykovou verzi můžete vytvořit některým 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 k 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 Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
      Console.WriteLine(current1.IsReadOnly)
      
      Dim current2 As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      Console.WriteLine(current2.IsReadOnly)
      
      Dim current3 As NumberFormatInfo = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture)
      Console.WriteLine(current3.IsReadOnly)
   End Sub
End Module
' 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 Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      current1 = CType(current1.Clone(), NumberFormatInfo)
      Console.WriteLine(current1.IsReadOnly)

      Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
      Dim current2 As NumberFormatInfo = culture2.NumberFormat
      Console.WriteLine(current2.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       False
'       False

Všimněte si, že 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 například angličtina (USA), může místo výchozí hodnoty 1,1 USD zobrazit hodnoty měny jako 1,1 USD. Objekty NumberFormatInfo načtené způsoby, které byly popsány dříve, odrážejí tyto přepsání uživatele. Pokud je to nežádoucí, můžete vytvořit NumberFormatInfo objekt, který neodráží přepsání uživatele (a to je také čtení/zápis místo jen pro čtení) voláním konstruktoru CultureInfo.CultureInfo(String, Boolean) a zadáním hodnoty false argumentu useUserOverride . Následující příklad obsahuje obrázek systému, jehož aktuální jazyková verze je angličtina (USA) a jehož symbol měny byl změněn z výchozí hodnoty $ na USD.

using System;
using System.Globalization;

public class Example
{
   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: $
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      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}", culture.NumberFormat.CurrencySymbol)
      Console.WriteLine()
            
      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)
   End Sub
End Module
' 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: $

CultureInfo.UseUserOverride Pokud je vlastnost 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 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 žádné konkrétní zemi nebo oblasti pro angličtinu. I když data konkrétních jazykových verzí mohou být dynamická a mohou 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.

Můžete vytvořit instanci NumberFormatInfo objektu, 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. Pak označuje, jestli je objekt jen pro čtení.

using System;
using System.Globalization;

public class Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nfi As NumberFormatInfo
      
      nfi = System.Globalization.NumberFormatInfo.InvariantInfo
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = CultureInfo.InvariantCulture.NumberFormat
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = New NumberFormatInfo()
      Console.WriteLine(nfi.IsReadOnly)               
   End Sub
End Module
' 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á kultura, která představuje anglický jazyk mluvený v USA a en-CA je specifická kultura, která představuje anglický jazyk mluvený v Kanadě. Můžete vytvořit instanci NumberFormatInfo objektu, 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 k 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 Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      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)
   End Sub
End Module
' 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 jazykovou verzi nebo jazyk, která je nezávislá na zemi nebo oblasti. Obvykle se jedná o nadřazenou jednu nebo více konkrétních jazykových verzí. Například fr je neutrální jazyková verze pro francouzský jazyk 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 jako NumberFormatInfo objekt, který představuje konvence formátování konkrétní jazykové verze.

Poznámka

V .NET Framework 3.5 a starších verzích se pokus o NumberFormatInfo načtení objektu, který odráží konvence formátování neutrální jazykové verze, NotSupportedException vyvolá výjimku.

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 Framework objekt, který odráží konvence formátování konkrétní jazykové verze, která je podřízenou neutrální jazykové verzi. NumberFormatInfo Například objekt pro neutrální jazykovou verzi en-culture odráží konvence formátování jazykové verze en-US a NumberFormatInfo objekt pro fr jazykovou verzi 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é každá neutrální jazyková verze představuje.

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

public class Example
{
   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();
   }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get all the neutral cultures
      Dim names As New List(Of String)
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    Sub(culture) names.Add(culture.Name))
      names.Sort()
      For Each name In names
         ' Ignore the invariant culture.
         If name = "" Then Continue For
         
         ListSimilarChildCultures(name)        
      Next
   End Sub

   Private Sub ListSimilarChildCultures(name As String)
      ' Create the neutral NumberFormatInfo object.
      Dim nfi As NumberFormatInfo = CultureInfo.GetCultureInfo(name).NumberFormat
      ' Retrieve all specific cultures of the neutral culture.
      Dim cultures() As CultureInfo = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures), 
                               Function(culture) culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase))
      ' Create an array of NumberFormatInfo properties
      Dim properties() As PropertyInfo = GetType(NumberFormatInfo).GetProperties(BindingFlags.Instance Or BindingFlags.Public)
      Dim hasOneMatch As Boolean = False

      For Each ci In cultures
         Dim match As Boolean = True     
         ' Get the NumberFormatInfo for a specific culture.
         Dim specificNfi As NumberFormatInfo = ci.NumberFormat
         ' Compare the property values of the two.
         For Each prop In properties
            ' We're not interested in the value of IsReadOnly.     
            If prop.Name = "IsReadOnly" Then Continue For
            
            ' For arrays, iterate the individual elements to see if they are the same.
            If prop.PropertyType.IsArray Then 
               Dim nList As IList = CType(prop.GetValue(nfi, Nothing), IList)
               Dim sList As IList = CType(prop.GetValue(specificNfi, Nothing), IList)
               If nList.Count <> sList.Count Then
                  match = false
                  Exit For
               End If 

               For ctr As Integer = 0 To nList.Count - 1
                  If Not nList(ctr).Equals(sList(ctr)) 
                     match = false
                     Exit For
                  End If     
               Next
            Else If Not prop.GetValue(specificNfi).Equals(prop.GetValue(nfi))
               match = false
               Exit For   
            End If        
         Next
         If match Then
            Console.WriteLine("NumberFormatInfo object for '{0}' matches '{1}'", 
                                      name, ci.Name)
            hasOneMatch = true
         End If                                       
      Next
      If Not hasOneMatch Then
         Console.WriteLine("NumberFormatInfo object for '{0}' --> No Match", name)            
      End If
      
      Console.WriteLine()
   End Sub
End Module

NumberFormatInfo a 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 aplikací 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 v průběhu času mění. V takovém případě služba Windows Update zahrnuje změny NumberFormatInfo hodnoty vlastnosti pro konkrétní 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ě NumberFormatInfo se 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 mohou přepsat některé hodnoty přidružené k aktuální systémové jazykové verzi 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 se také načtou z uživatelského nastavení.

Počínaje .NET Framework 2.0 se při vytvoření objektu inicializují všechny vlastnosti přepsané 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, jestli se přepsání uživatelů 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, jestli výsledný objekt odráží přepsání uživatele.

Zdroj objektu CultureInfo a NumberFormatInfo Odráží přepsání 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 tomu, abyste to udělali jinak, měli byste respektovat přepsání uživatelů při použití objektu NumberFormatInfo v klientských aplikacích k formátování a analýze vstupu uživatele 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 ale objekt používáte NumberFormatInfo explicitně nebo implicitně k zachování číselných dat ve formuláři řetězce, měli byste buď 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 číselné operace formátování využívají implementaci IFormatProvider . Rozhraní IFormatProvider zahrnuje jednu metodu, GetFormat(Type). Jedná se o metodu zpětného volání, která je předána Type objektu, 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 Framework poskytuje dvě IFormatProvider implementace pro formátování čísel:

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

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 zobrazuje 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, aby poskytoval informace o formátování, zatímco String.Format(IFormatProvider, String, Object[]) požadavky NumberFormatInfo metody a objekty a DateTimeFormatInfo 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 Example
{
   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
Imports System.Globalization

Public Class CurrentCultureFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      Console.WriteLine("Requesting an object of type {0}", 
                        formatType.Name)
      If formatType Is GetType(NumberFormatInfo) Then
         Return NumberFormatInfo.CurrentInfo
      Else If formatType Is GetType(DateTimeFormatInfo) Then
         Return DateTimeFormatInfo.CurrentInfo
      Else
         Return Nothing
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim amount As Decimal = 1203.541d
      Dim value As String = amount.ToString("C2", New CurrentCultureFormatProvider())
      Console.WriteLine(value)
      Console.WriteLine()
      Dim composite As String = String.Format(New CurrentCultureFormatProvider, 
                                              "Date: {0}   Amount: {1}   Description: {2}",
                                              Date.Now, 1264.03d, "Service Charge")
      Console.WriteLine(composite)
      Console.WriteLine()
   End Sub
End Module
' 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ě uvedena ve volání metody číselného formátování, metoda volá CultureInfo.CurrentCulture.GetFormat metoduNumberFormatInfo, 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í řetězce formátu 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 Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim formatStrings() As String = { "C2", "E1", "F", "G3", "N", 
                                        "#,##0.000", "0,000,000,000.0##" }
      Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim values() As Decimal = { 1345.6538d, 1921651.16d }
      
      For Each value In values
         For Each formatString In formatStrings
            Dim resultString As String = value.ToString(formatString, culture)
            Console.WriteLine("{0,-18} -->  {1}", formatString, resultString)
         Next
         Console.WriteLine()      
      Next   
   End Sub
End Module
' 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í řetězce formátu implicitní. Například v následující metodě volá výchozí nebo bez parametrů Decimal.ToString() , hodnota Decimal instance je 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 Example
{
   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
Module Example
   Public Sub Main()
      Dim values() As Decimal = { 1345.6538d, 1921651.16d }
      
      For Each value In values
         Dim resultString As String = value.ToString()
         Console.WriteLine(resultString)
         Console.WriteLine()      
      Next   
   End Sub
End Module
' 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ě symbolů "0" a "#" vloží do výsledného řetězce, 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 najdete 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.

CurrencyDecimalSeparatordefinujte symbol oddělovače desetinných míst.

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

CurrencyGroupSizesk definování velikostí integrálních skupin.

CurrencyNegativePatterndefinovat vzor záporných hodnot měny.

CurrencyPositivePatternk definování vzoru kladných hodnot měny.

CurrencySymbola definujte symbol měny.

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

NumberDecimalSeparatordefinujte symbol oddělovače desetinných míst.

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

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

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

NumberDecimalSeparatordefinujte symbol oddělovače desetinných míst.

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

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

NumberDecimalSeparatordefinujte symbol oddělovače desetinných míst.

NumberGroupSeparatork definování symbolu oddělovače skupiny (tisíce).

NumberGroupSizes, definovat počet integrálních číslic ve skupině.

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

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

PercentDecimalSeparatordefinujte symbol oddělovače desetinných míst.

PercentGroupSeparatora definujte symbol oddělovače skupiny.

PercentGroupSizes, definovat počet integrálních číslic ve skupině.

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

PercentPositivePatterndefinuje umístění symbolu procenta pro kladné hodnoty.

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

NumberDecimalSeparatordefinujte symbol 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) NumberDecimalSeparatordefinujte symbol oddělovače desetinných míst.
"," (specifikátor vlastního formátu oddělovače skupin) NumberGroupSeparatork definování symbolu oddělovače skupiny (tisíců).
"%" (specifikátor vlastního formátu v procentech) PercentSymbolk definování symbolu procenta.
"^" (specifikátor vlastního formátu podle mile) PerMilleSymbol, pro definování symbolu per mile.
"E" (specifikátor vlastního formátu exponenciální notace) NegativeSignk definování symbolu záporného znaménka v mantissa a exponentu.

PositiveSignk 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 číslic používaných 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 základní číslice latinky 0 (U+0030) až 9 (U+0039). Kromě toho pro Single a hodnoty , NaN``PositiveInfinitya NegativeInfinityDouble , výsledný řetězec se skládá výhradně ze symbolů definovaných NaNSymbolznakem , PositiveInfinitySymbola NegativeInfinitySymbol vlastnosti, v uvedeném pořadí.

Změna 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í. Použijte následující postup:

  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 použité k vytvoření požadovaného výsledného řetězce. Informace o tom, jak metody formátování používají NumberFormatInfo vlastnosti k definování výsledných řetězců, naleznete v části Formát řetězců a NumberFormatInfo vlastnosti .

  3. Jako argument použijte vlastní NumberFormatInfo objekt IFormatProvider 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ů.

Úpravy symbolu a vzorce měny

Následující příklad upraví NumberFormatInfo objekt, který představuje konvence formátování jazykové verze en-US. Přiřadí symbol CurrencySymbol měny ISO-4217 vlastnosti a definuje vzor hodnot měny, který se skládá z 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
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Retrieve a writable NumberFormatInfo object.
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim nfi As NumberFormatInfo = 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.
      Dim values() As Decimal = { 1065.23d, 19.89d, -.03d, -175902.32d }
      For Each value In values
         Console.WriteLine(value.ToString("C", enUS))
      Next      
      Console.WriteLine()
      
      ' Produce the result strings by calling a composite formatting method.
      For Each value In values
         Console.WriteLine(String.Format(enUS, "{0:C}", value))      
      Next
   End Sub
End Module
' 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, takže lze snadno formá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 Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Instantiate a read-only NumberFormatInfo object.
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim nfi As NumberFormatInfo = enUS.NumberFormat

      ' Modify the relevant properties.
      nfi.NumberGroupSeparator = "-"
      nfi.NumberGroupSizes = { 3, 2, 4}
      nfi.NumberDecimalDigits = 0
      
      Dim ids() As Integer = { 111223333, 999776666 }
      
      ' Produce the result string by calling ToString.
      For Each id In ids
         Console.WriteLine(id.ToString("N", enUS))
      Next 
      Console.WriteLine()
      
      ' Produce the result string using composite formatting.
      For Each id In ids
         Console.WriteLine(String.Format(enUS, "{0:N}", id))
      Next
   End Sub
End Module
' The example displays the following output:
'       1112-23-333
'       9997-76-666
'       
'       1112-23-333
'       9997-76-666

Analýza číselných řetězců

Analýza zahrnuje převod řetězcové reprezentace čísla na číslo. Každý číselný typ v .NET Framework zahrnuje 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í, které prvky stylu (například oddělovače skupin, oddělovač desetinných míst nebo symbol měny) mohou být přítomné v řetězci, pokud je analýza úspěšná. NumberStyles Pokud není ve volání metody zadána hodnota, je NumberStyles výchozí hodnota, která obsahuje Float a AllowThousands příznaky, která určuje, že parsovaný ř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ězcová reprezentace čí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, jako Int16.Parse(String)jsou , , 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 parsovat ř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čku jako oddělovač desetinných míst se nepodaří analyzovat v jazykové verzi fr-FR, a řetězec s prázdným mezerou jako oddělovač skupiny a čárka jako oddělovač desetinných míst se nepodaří parsovat v en-US a invariantní jazykové verze.

using System;
using System.Globalization;

public class Example
{
   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)
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { "1,034,562.91", "9 532 978,07" }
      Dim cultureNames() As String = { "en-US", "fr-FR", "" }
      
      For Each value In values
         For Each cultureName In cultureNames
            Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
            Dim name As String = If(culture.Name = "", "Invariant", culture.Name)
            Try
               Dim amount As Decimal = Decimal.Parse(value, culture)
               Console.WriteLine("'{0}' --> {1} ({2})", value, amount, name)
            Catch e As FormatException
               Console.WriteLine("'{0}': FormatException ({1})",
                                 value, name)
            End Try   
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' 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)

K analýze obvykle dochází ve dvou kontextech:

  • Jako operace, která je navržená pro převod vstupu uživatele 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.

Následující části podrobněji probírají tyto dvě operace.

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, najdete v části NumberFormatInfo a dynamická data .

Následující příklad znázorňuje rozdíl mezi operací analýzy, která odráží uživatelská kulturní nastavení a která ne. V tomto případě je výchozí systémová jazyková verze en-US, ale uživatel definoval "," jako desetinný symbol 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 parsuje objektem NumberFormatInfo , který odráží také uživatelská nastavení (přepsání), vrátí operace analýzy správný výsledek. Pokud je ale řetězec parsován objektem NumberFormatInfo , který odráží standardní kulturní nastavení en-US, chybí symbol čárky pro oddělovač skupiny a vrátí nesprávný výsledek.

using System;
using System.Globalization;

public class Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim stdCulture As CultureInfo = CultureInfo.GetCultureInfo("en-US")
      Dim custCulture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US") 
            
      Dim value As String = "310,16"
      Try
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           stdCulture.Name, stdCulture.UseUserOverride)
         Dim amount As Decimal = Decimal.Parse(value, stdCulture)
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture))                                                                                        
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'", value)
      End Try   
      Console.WriteLine()
                                            
      Try
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           custCulture.Name, custCulture.UseUserOverride)
         Dim amount As Decimal = Decimal.Parse(value, custCulture)
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture))                                                                                        
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'", value)
      End Try   
   End Sub
End Module
' 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

Pokud jsou číselná data serializována ve formátu řetězce a později deserializována a analyzována, měly by se řetězce generovat a analyzovat 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 na vlákně, jehož nastavení specifické pro jazykovou verzi jsou identické s vláknem, na kterém bylo serializováno. V některých případech to znamená, že data nemohou být ú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í specifické pro jazykovou verzi jazykové verze pt-BR. V tomto případě, i když každá operace parsování proběhne úspěšně, data se úspěšně neprovádí a dojde k poškození dat. V jiných případech může dojít k selhání operace analýzy a FormatException vyvolá se výjimka.

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

public class Example
{
   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
Imports System.Collections.Generic
Imports System.Globalization
Imports System.IO
Imports System.Threading

Module Example
   Public Sub Main()
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      PersistData()
      
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("pt-BR")
      RestoreData()
   End Sub
   
   Private Sub PersistData()
      ' Define an array of floating-point values.
      Dim values() As Double = { 160325.972, 8631.16, 1.304e5, 98017554.385, 
                                 8.5938287084321676e94 }
      Console.WriteLine("Original values: ")
      For Each value In values
         Console.WriteLine(value.ToString("R", CultureInfo.InvariantCulture))
      Next
         
      ' Serialize an array of doubles to a file 
      Dim sw As New StreamWriter(".\NumericData.bin")
      For ctr As Integer = 0 To values.Length - 1
         sw.Write(values(ctr).ToString("R"))
         If ctr < values.Length - 1 Then sw.Write("|")
      Next
      sw.Close()
      Console.WriteLine()
   End Sub
   
   Private Sub RestoreData()   
      ' Deserialize the data
      Dim sr AS New StreamReader(".\NumericData.bin")
      Dim data As String = sr.ReadToEnd()
      sr.Close()
      
      Dim stringValues() As String = data.Split("|"c)
      Dim newValueList As New List(Of Double)
      
      For Each stringValue In stringValues
         Try
            newValueList.Add(Double.Parse(stringValue))
         Catch e As FormatException
            newValueList.Add(Double.NaN)
         End Try   
      Next                                   

      Console.WriteLine("Restored values:")
      For Each newValue In newValueList
         Console.WriteLine(newValue.ToString("R", NumberFormatInfo.InvariantInfo))
      Next
   End Sub
End Module
' 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

Konstruktory

NumberFormatInfo()

Inicializuje novou zapisovatelnou instanci NumberFormatInfo třídy, která je nezávislá na jazykové verzi (invariantní).

Vlastnosti

CurrencyDecimalDigits

Získá nebo nastaví počet desetinných míst, která se mají použít v hodnotách měny.

CurrencyDecimalSeparator

Získá nebo nastaví řetězec, který se má použít jako oddělovač desetinných míst v hodnotách měny.

CurrencyGroupSeparator

Získá nebo nastaví řetězec, který odděluje skupiny číslic vlevo od desetinných míst v hodnotách měny.

CurrencyGroupSizes

Získá nebo nastaví počet číslic v každé skupině vlevo od desetinných míst v hodnotách měny.

CurrencyNegativePattern

Získá nebo nastaví formát pro záporné hodnoty měny.

CurrencyPositivePattern

Získá nebo nastaví formát pro kladné hodnoty měny.

CurrencySymbol

Získá nebo nastaví řetězec, který se má použít jako symbol měny.

CurrentInfo

Získá jen NumberFormatInfo pro čtení, který formátuje hodnoty na základě aktuální jazykové verze.

DigitSubstitution

Získá nebo nastaví hodnotu, která určuje, jak grafické uživatelské rozhraní zobrazuje tvar číslice.

InvariantInfo

Získá objekt jen NumberFormatInfo pro čtení, který je nezávislá na jazykové verzi (invariantní).

IsReadOnly

Získá hodnotu, která označuje, zda je tento NumberFormatInfo objekt jen pro čtení.

NaNSymbol

Získá nebo nastaví řetězec, který představuje hodnotu IEEE NaN (nikoli číslo).

NativeDigits

Získá nebo nastaví řetězcové pole nativních číslic ekvivalentních západních číslic 0 až 9.

NegativeInfinitySymbol

Získá nebo nastaví řetězec, který představuje záporné nekonečno.

NegativeSign

Získá nebo nastaví řetězec, který označuje, že přidružené číslo je záporné.

NumberDecimalDigits

Získá nebo nastaví počet desetinných míst, která se mají použít v číselných hodnotách.

NumberDecimalSeparator

Získá nebo nastaví řetězec, který se má použít jako oddělovač desetinných míst v číselných hodnotách.

NumberGroupSeparator

Získá nebo nastaví řetězec, který odděluje skupiny číslic vlevo od desetinných míst v číselných hodnotách.

NumberGroupSizes

Získá nebo nastaví počet číslic v každé skupině vlevo od desetinné čárky v číselných hodnotách.

NumberNegativePattern

Získá nebo nastaví formát pro záporné číselné hodnoty.

PercentDecimalDigits

Získá nebo nastaví počet desetinných míst, která se mají použít v procentech hodnot.

PercentDecimalSeparator

Získá nebo nastaví řetězec, který se má použít jako oddělovač desetinných míst v procentech hodnot.

PercentGroupSeparator

Získá nebo nastaví řetězec, který odděluje skupiny číslic nalevo od desetinných míst v procentech hodnot.

PercentGroupSizes

Získá nebo nastaví počet číslic v každé skupině vlevo od desetinných míst v procentech.

PercentNegativePattern

Získá nebo nastaví formát pro záporné procentuální hodnoty.

PercentPositivePattern

Získá nebo nastaví formát pro kladné procentuální hodnoty.

PercentSymbol

Získá nebo nastaví řetězec, který se má použít jako symbol procenta.

PerMilleSymbol

Získá nebo nastaví řetězec, který se má použít jako symbol per mile.

PositiveInfinitySymbol

Získá nebo nastaví řetězec, který představuje kladné nekonečno.

PositiveSign

Získá nebo nastaví řetězec, který označuje, že přidružené číslo je kladné.

Metody

Clone()

Vytvoří použádnou kopii objektu NumberFormatInfo .

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetFormat(Type)

Získá objekt zadaného typu, který poskytuje službu formátování čísel.

GetHashCode()

Slouží jako výchozí funkce hash.

(Zděděno od Object)
GetInstance(IFormatProvider)

NumberFormatInfo Získá přidružené k zadané IFormatProvider.

GetType()

Type Získá aktuální instanci.

(Zděděno od Object)
MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru Object.

(Zděděno od Object)
ReadOnly(NumberFormatInfo)

Vrátí obálku jen NumberFormatInfo pro čtení.

ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)

Platí pro

Viz také