NumberFormatInfo NumberFormatInfo NumberFormatInfo NumberFormatInfo Class

Definice

Poskytuje informace specifické pro jazykovou verzi pro formátování a analýzu číselných hodnot.Provides culture-specific information for formatting and parsing numeric values.

public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements ICloneable, IFormatProvider
Dědičnost
NumberFormatInfoNumberFormatInfoNumberFormatInfoNumberFormatInfo
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 o formátování čísel pro konkrétní jazykovou verzi.The following example shows how to retrieve a NumberFormatInfo object for a corresponding CultureInfo object, and use the retrieved object to query number formatting information for the particular culture.

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

NumberFormatInfo Třída obsahuje informace specifické pro jazykovou verzi, které se používají při formátování a analýze číselných hodnot.The NumberFormatInfo class contains culture-specific information that is used when you format and parse numeric values. Tyto informace zahrnují symbol měny, symbol desetinné čárky, symbol oddělovače skupiny a symboly pro kladné a záporné znaménko.This information includes the currency symbol, the decimal symbol, the group separator symbol, and the symbols for positive and negative signs.

Vytvoření instance objektu NumberFormatInfoInstantiating a NumberFormatInfo object

Můžete vytvořit instanci NumberFormatInfo objektu, který představuje konvence formátování aktuální jazykové verze, invariantní jazykové verze, specifickou jazykovou verzi nebo neutrální jazykovou verzi.You can instantiate a NumberFormatInfo object that represents the formatting conventions of the current culture, the invariant culture, a specific culture, or a neutral culture.

Vytvoření instance objektu NumberFormatInfo pro aktuální jazykovou verziInstantiating a NumberFormatInfo object for the current culture

Můžete vytvořit instanci NumberFormatInfo objektu pro aktuální jazykovou verzi vlákna jedním z následujících způsobů.You can instantiate a NumberFormatInfo object for the current thread culture in any of the following ways. V každém případě je vrácený NumberFormatInfo objekt jen pro čtení.In each case, the returned NumberFormatInfo object is read-only.

Následující příklad používá tyto tři způsoby, jak vytvořit NumberFormatInfo objekty, které představují konvence formátování aktuální jazykové verze.The following example uses these three ways to create NumberFormatInfo objects that represent the formatting conventions of the current culture. Také načítá hodnotu IsReadOnly vlastnosti pro ilustraci, že každý objekt je určen jen pro čtení.It also retrieves the value of the IsReadOnly property to illustrate that each object is read-only.

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

Můžete vytvořit zapisovatelný NumberFormatInfo objekt, který představuje konvence aktuální jazykové verze vlákna, jedním z následujících způsobů:You can create a writable NumberFormatInfo object that represents the conventions of the current thread culture in any of the following ways:

Následující příklad znázorňuje tyto dva způsoby vytvoření instance NumberFormatInfo objektu a zobrazuje hodnotu IsReadOnly vlastnosti pro ilustraci, že objekt není určen jen pro čtení.The following example illustrates these two ways of instantiating a NumberFormatInfo object, and displays the value of its IsReadOnly property to illustrate that the object is not read-only.

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é NumberFormatInfo hodnoty vlastností používané při číselném formátování a analyzovat operace prostřednictvím položky oblast a jazyk v Ovládacích panelech.Note that the Windows operating system allows the user to override some of the NumberFormatInfo property values used in numeric formatting and parsing operations through the Region and Language item in Control Panel. Například uživatel, jehož jazyková verze je angličtina (USA), může zvolit zobrazení hodnot měny jako 1,1 USD namísto výchozí hodnoty $1,1.For example, a user whose culture is English (United States) might choose to display currency values as 1.1 USD instead of the default of $1.1. NumberFormatInfo Objekty načtené různými způsoby, které jsou popsány dříve, odrážejí tato přepsání uživatele.The NumberFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Pokud je to NumberFormatInfo nežádoucí, můžete vytvořit objekt, který neodráží přepsání uživatele (a je také pro čtení a zápis, nikoli jen pro čtení), CultureInfo.CultureInfo(String, Boolean) voláním konstruktoru a false zadáním hodnoty pro useUserOverride Argument.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and that is also read/write rather than read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. Následující příklad obsahuje obrázek pro systém, jehož aktuální jazyková verze je English (USA) a jejíž symbol měny byl změněn z výchozí hodnoty $ na USD.The following example provides an illustration for a system whose current culture is English (United States) and whose currency symbol has been changed from the default of $ to 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.DateTimeFormat CultureInfo.NumberFormat CultureInfo.TextInfo Pokud je truevlastnost nastavena na, vlastnosti, a jsou také načteny z uživatelského nastavení. CultureInfo.UseUserOverrideIf the CultureInfo.UseUserOverride property is set to true, the properties CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, and CultureInfo.TextInfo are also retrieved from the user settings. Pokud je nastavení uživatele nekompatibilní s jazykovou verzí přidruženou CultureInfo k objektu (například pokud vybraný kalendář není jedním z kalendářů uvedených OptionalCalendars vlastností), výsledky metod a hodnoty vlastností jsou nedefinované.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars listed by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Vytvoření instance objektu NumberFormatInfo pro invariantní jazykovou verziInstantiating a NumberFormatInfo object for the invariant culture

Invariantní jazyková verze představuje jazykovou verzi, která není závislá na jazykové verzi.The invariant culture represents a culture that is culture-insensitive. Vychází z anglického jazyka, ale ne z konkrétní země nebo oblasti hovořící v angličtině.It is based on the English language but not on any specific English-speaking country/region. I když mohou být data konkrétních kultur dynamická a mohou se změnit tak, aby odrážela nové kulturní konvence nebo uživatelské preference, data neutrální jazykové verze se nezmění.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. NumberFormatInfo Objekt, který představuje konvence formátování invariantní jazykové verze, lze použít k formátování operací, ve kterých se výsledné řetězce nesmí lišit podle jazykové verze.A NumberFormatInfo object that represents the formatting conventions of the invariant culture can be used for formatting operations in which result strings should not vary by culture.

Můžete vytvořit instanci NumberFormatInfo objektu, který představuje konvence formátování invariantní jazykové verze, následujícími způsoby:You can instantiate a NumberFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

Následující příklad používá každou z těchto metod pro vytvoření instance NumberFormatInfo objektu, který představuje invariantní jazykovou verzi.The following example uses each of these methods to instantiate a NumberFormatInfo object that represents the invariant culture. Pak indikuje, jestli je objekt jen pro čtení,It then indicates whether the object is read-only,

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 verziInstantiating a NumberFormatInfo object for a specific culture

Konkrétní jazyková verze představuje jazyk, který se používá v konkrétní zemi nebo oblasti.A specific culture represents a language that is spoken in a particular country/region. Například en-US je specifická jazyková verze, která představuje anglický jazyk používaný v USA a en-CA je specifická jazyková verze, která představuje anglický jazyk používaný v Kanadě.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. Můžete vytvořit instanci NumberFormatInfo objektu, který představuje konvence formátování konkrétní jazykové verze, a to následujícími způsoby:You can instantiate a NumberFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

Následující příklad používá tyto čtyři způsoby pro vytvoření NumberFormatInfo objektu, který odráží konvence formátování indonéských (Indonésie) jazykové verze.The following example uses these four ways to create a NumberFormatInfo object that reflects the formatting conventions of the Indonesian (Indonesia) culture. Označuje také, zda je každý objekt určen jen pro čtení.It also indicates whether each object is read-only.

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.Instantiating a NumberFormatInfo object for a neutral culture

Neutrální jazyková verze představuje jazykovou verzi nebo jazyk, který je nezávislý na zemi nebo oblasti.A neutral culture represents a culture or language that is independent of a country/region. Obvykle je nadřazeným prvkem jedné nebo více konkrétních kultur.It is typically the parent of one or more specific cultures. Například fr je neutrální jazyková verze pro francouzský jazyk a nadřazená jazyková verze fr-FR.For example, fr is a neutral culture for the French language and the parent of the fr-FR culture. 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.You create a NumberFormatInfo object that represents the formatting conventions of a neutral culture in the same way that you create a NumberFormatInfo object that represents the formatting conventions of a specific culture.

Poznámka

V dřívějších verzích NumberFormatInfo NotSupportedException a, které se pokoušejí načíst objekt, který odráží konvence formátování neutrální jazykové verze, vyvolá výjimku. .NET Framework 3.5.NET Framework 3.5In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, trying to retrieve a NumberFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Jelikož je však nezávislá na konkrétní zemi nebo oblasti, neutrální jazyková verze neobsahuje informace o formátování specifické pro jazykovou verzi.However, because it is independent of a specific country/region, a neutral culture lacks culture-specific formatting information. Místo vyplnění NumberFormatInfo objektu obecnými hodnotami .NET Framework NumberFormatInfo vrátí objekt, který odráží konvence formátování konkrétní jazykové verze, která je podřízenou neutrální jazykové verzi.Rather than populating the NumberFormatInfo object with generic values, the .NET Framework returns a NumberFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Například NumberFormatInfo objekt pro neutrální jazykovou verzi odráží konvence formátování jazykové verze en-US NumberFormatInfo a objekt pro jazykovou verzi fr odráží konvence formátování jazykové verze fr-fr.For example, the NumberFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the NumberFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

Můžete použít kód podobný následujícímu k určení, které konkrétní jazykové konvence formátování jednotlivé neutrální jazykové verze představují.You can use code like the following to determine which specific culture's formatting conventions each neutral culture represents.

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á dataNumberFormatInfo and dynamic 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.The culture-specific data for formatting numeric values provided by the NumberFormatInfo class is dynamic, just like the cultural data provided by the CultureInfo class. Neměli byste vytvářet předpoklady o stabilitě hodnot pro NumberFormatInfo objekty, které jsou spojeny s konkrétními CultureInfo objekty.You should not make any assumptions about the stability of values for NumberFormatInfo objects that are associated with particular CultureInfo objects. Pouze data poskytnutá neutrální jazykovou verzí a přidruženým NumberFormatInfo objektem jsou stabilní.Only the data provided by the invariant culture and its associated NumberFormatInfo object is stable. Další data se můžou měnit mezi relacemi aplikace nebo dokonce i v rámci jedné relace, a to z následujících důvodů:Other data can change between application sessions, or even within a single session, for the following reasons:

  • Aktualizace systému.System updates. Kulturní preference, jako je symbol měny nebo měnové formáty, se v průběhu času mění.Cultural preferences such as the currency symbol or currency formats change over time. Pokud k tomu dojde, web Windows Update obsahuje změny NumberFormatInfo hodnoty vlastnosti pro konkrétní jazykovou verzi.When this happens, Windows Update includes changes to the NumberFormatInfo property value for a particular culture.

  • Náhradní kultury.Replacement cultures. CultureAndRegionInfoBuilder Třídu lze použít k nahrazení dat stávající jazykové verze.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Kaskádové změny hodnot vlastností.Cascading changes to property values. Množství vlastností, které se týkají jazykové verze, se může v době běhu změnit, což naopak způsobí NumberFormatInfo změnu dat.A number of culture-related properties can change at run time, which, in turn, causes NumberFormatInfo data to change. Aktuální jazykovou verzi lze například změnit programově nebo prostřednictvím akce uživatele.For example, the current culture can be changed either programmatically or through user action. Pokud k tomu dojde, NumberFormatInfo objekt vrácený CurrentInfo vlastností se změní na objekt přidružený k aktuální jazykové verzi.When this happens, the NumberFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture.

  • Předvolby uživateleUser preferences. Uživatelé vaší aplikace mohou přepsat některé z hodnot přidružených k aktuální jazykové verzi systému prostřednictvím možností oblast a jazyk v Ovládacích panelech.Users of your application might override some of the values associated with the current system culture through the region and language options in Control Panel. Například uživatelé mohou zvolit jiný symbol měny nebo jiný symbol oddělovače desetinných míst.For example, users might choose a different currency symbol or a different decimal separator symbol. Pokud je true vlastnost nastavena na (výchozí hodnota) NumberFormatInfo , jsou vlastnosti objektu také načteny z uživatelského nastavení. CultureInfo.UseUserOverrideIf the CultureInfo.UseUserOverride property is set to true (its default value), the properties of the NumberFormatInfo object are also retrieved from the user settings.

Počínaje .NET Framework 2,0 jsou všechny vlastnosti NumberFormatInfo objektu, které lze přepsat uživatelem, inicializovány při vytvoření objektu.Starting with the .NET Framework 2.0, all user-overridable properties of a NumberFormatInfo object are initialized when the object is created. Stále existuje možnost nekonzistence, protože ani vytvoření objektu ani proces přepsání uživatele není atomické a příslušné hodnoty se mohou během vytváření objektu změnit.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic, and the relevant values may change during object creation. Tyto nekonzistence by však měly být extrémně vzácné.However, these inconsistencies should be extremely rare.

Můžete určit, zda se přepisy uživatele odrazí v NumberFormatInfo objektech, které představují stejnou jazykovou verzi jako aktuální jazyková verze vlákna.You can control whether user overrides are reflected in NumberFormatInfo objects that represent the same culture as the current thread culture. V následující tabulce jsou uvedeny způsoby, kterými NumberFormatInfo lze objekt načíst, a určuje, zda výsledný objekt odráží přepsání uživatele.The following table lists the ways in which a NumberFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Zdroj objektu CultureInfo a NumberFormatInfoSource of CultureInfo and NumberFormatInfo object Odráží přepsání uživatelů.Reflects user overrides
CultureInfo.CurrentCulture.NumberFormatmajetekCultureInfo.CurrentCulture.NumberFormat property AnoYes
NumberFormatInfo.CurrentInfomajetekNumberFormatInfo.CurrentInfo property AnoYes
CultureInfo.CreateSpecificCultureMetodaCultureInfo.CreateSpecificCulture method AnoYes
CultureInfo.GetCultureInfoMetodaCultureInfo.GetCultureInfo method NeNo
CultureInfo(String)BeginRequestEventArgsCultureInfo(String) constructor AnoYes
CultureInfo.CultureInfo(String, Boolean)BeginRequestEventArgsCultureInfo.CultureInfo(String, Boolean) constructor Závisí na hodnotě useUserOverride parametruDepends on value of useUserOverride parameter

Pokud neexistují přesvědčivé důvody v jiném smyslu, měli byste respektovat přepsání uživatelů při použití NumberFormatInfo objektu v klientských aplikacích k formátování a analýze vstupu uživatele nebo k zobrazení číselných dat.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the NumberFormatInfo object in client applications to format and parse user input or to display numeric data. Pro serverové aplikace nebo bezobslužné aplikace byste neměli respektovat přepsání uživatelů.For server applications or unattended applications, you should not respect user overrides. Nicméně pokud NumberFormatInfo používáte objekt buď explicitně nebo implicitně k uchovávání číselných dat ve formě řetězce, měli byste buď NumberFormatInfo použít objekt, který odráží konvence formátování neutrální jazykové verze, nebo byste měli zadat vlastní řetězec číselného formátu, který použijete bez ohledu na jazykovou verzi.However, if you are using the NumberFormatInfo object either explicitly or implicitly to persist numeric data in string form, you should either use a NumberFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom numeric format string that you use regardless of culture.

IFormatProvider, NumberFormatInfo a formátování číselIFormatProvider, NumberFormatInfo, and numeric formatting

NumberFormatInfo Objekt se implicitně nebo explicitně používá v rámci všech operací s číselným formátováním.A NumberFormatInfo object is used implicitly or explicitly in all numeric formatting operations. Mezi ně patří volání následujících metod:These include calls to the following methods:

Všechny operace IFormatProvider číselného formátování využívají implementaci.All numeric formatting operations make use of an IFormatProvider implementation. Rozhraní obsahuje jedinou metodu, GetFormat(Type). IFormatProviderThe IFormatProvider interface includes a single method, GetFormat(Type). Toto je metoda zpětného volání, která je Type předána objektu, který představuje typ potřebný k zadání informací o formátování.This is a callback method that is passed a Type object that represents the type needed to provide formatting information. Metoda zodpovídá za vrácení buď instance daného typu, nebo null, pokud nemůže poskytnout instanci typu.The method is responsible for returning either an instance of that type or null, if it cannot provide an instance of the type. .NET Framework poskytuje dvě IFormatProvider implementace pro formátování čísel:The .NET Framework provides two IFormatProvider implementations for formatting numbers:

Pokud není CultureInfo CultureInfo.CurrentCulture implementována metoda formátování explicitně, je použit objekt vrácený vlastností, která představuje aktuální jazykovou verzi vlákna. IFormatProviderIf an IFormatProvider implementation is not provided to a formatting method explicitly, a CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

Následující příklad znázorňuje vztah mezi IFormatProvider rozhraním a třídou v rámci NumberFormatInfo formátování operací definováním vlastní IFormatProvider implementace.The following example illustrates the relationship between the IFormatProvider interface and the NumberFormatInfo class in formatting operations by defining a custom IFormatProvider implementation. Jeho GetFormat metoda zobrazí název typu objektu požadovaného operací formátování.Its GetFormat method displays the type name of the object requested by the formatting operation. Pokud rozhraní požaduje NumberFormatInfo objekt, tato metoda NumberFormatInfo poskytuje objekt pro aktuální jazykovou verzi vlákna.If the interface is requesting a NumberFormatInfo object, this method provides the NumberFormatInfo object for the current thread culture. Jak ukazuje výstup z příkladu, Decimal.ToString(IFormatProvider) metoda NumberFormatInfo požaduje objekt, který poskytuje informace o String.Format(IFormatProvider, String, Object[]) formátování, zatímco požadavky NumberFormatInfo ICustomFormatter metody a objekty a DateTimeFormatInfo také provádění.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a NumberFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

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

Pokud není CultureInfo.CurrentCulture.GetFormat NumberFormatInfo implementace explicitně k dispozici ve volání metody číselného formátování, metoda volá metodu, která vrátí objekt, který odpovídá aktuální jazykové verzi vlákna. IFormatProviderIf an IFormatProvider implementation is not explicitly provided in a numeric formatting method call, the method calls the CultureInfo.CurrentCulture.GetFormat method, which returns the NumberFormatInfo object that corresponds to the current thread culture.

Formátování řetězců a vlastností NumberFormatInfoFormat strings and NumberFormatInfo properties

Každá operace formátování používá buď standardní, nebo vlastní řetězec číselného formátu k vytvoření výsledného řetězce z čísla.Every formatting operation uses either a standard or a custom numeric format string to produce a result string from a number. V některých případech použití formátovacího řetězce k vytvoření výsledného řetězce je explicitní, jako v následujícím příkladu.In some cases, the use of a format string to produce a result string is explicit, as in the following example. Tento kód volá Decimal.ToString(IFormatProvider) metodu pro Decimal převod hodnoty na několik různých řetězcových reprezentací pomocí formátovacích úmluv jazykové verze en-US.This code calls the Decimal.ToString(IFormatProvider) method to convert a Decimal value to a number of different string representations by using the formatting conventions of the en-US culture.

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í formátovacího řetězce implicitní.In other cases, the use of a format string is implicit. Například v následující metodě volá metodu výchozí nebo bez parametrů Decimal.ToString() , hodnota Decimal instance je formátována pomocí specifikátoru obecného formátu ("G") a konvence aktuální jazykové verze, která je v tomto případě Jazyková verze en-US.For example, in the following method calls to the default or parameterless Decimal.ToString() method, the value of the Decimal instance is formatted by using the general ("G") format specifier and the conventions of the current culture, which in this case is the en-US culture.

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í číselný formátovací řetězec používá jednu nebo více NumberFormatInfo vlastností k určení vzoru nebo symbolů použitých ve výsledném řetězci.Each standard numeric format string uses one or more NumberFormatInfo properties to determine the pattern or the symbols used in the result string. Podobně každý vlastní číselný specifikátor formátu s výjimkou "0" a "#" vloží symboly ve výsledném řetězci, které jsou NumberFormatInfo definovány vlastnostmi.Similarly, each custom numeric format specifier except "0" and "#" insert symbols in the result string that are defined by NumberFormatInfo properties. V následující tabulce jsou uvedeny specifikátory standardního a vlastního číselného formátu a jejich NumberFormatInfo přidružené vlastnosti.The following table lists the standard and custom numeric format specifiers and their associated NumberFormatInfo properties. Chcete-li změnit vzhled výsledného řetězce pro konkrétní jazykovou verzi, přečtěte si část Úprava vlastností NumberFormatInfo .To change the appearance of the result string for a particular culture, see the Modifying NumberFormatInfo properties section. Podrobnosti o použití těchto specifikátorů formátu naleznete v tématu Standardní číselné formátovací řetězce a vlastní číselné formátovací řetězce.For details about the use of these format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

Specifikátor formátuFormat specifier Přidružené vlastnostiAssociated properties
"C" nebo "c" (specifikátor formátu měny)"C" or "c" (currency format specifier) CurrencyDecimalDigits, chcete-li definovat výchozí počet zlomkových číslic.CurrencyDecimalDigits, to define the default number of fractional digits.

CurrencyDecimalSeparator, chcete-li definovat symbol oddělovače desetinných míst.CurrencyDecimalSeparator, to define the decimal separator symbol.

CurrencyGroupSeparatorpro definování oddělovače skupin nebo tisíců.CurrencyGroupSeparator, to define the group or thousands separator.

CurrencyGroupSizespro definování velikosti integrálních skupin.CurrencyGroupSizes, to define the sizes of integral groups.

CurrencyNegativePatternpro definování vzoru záporných hodnot měny.CurrencyNegativePattern, to define the pattern of negative currency values.

CurrencyPositivePatternpro definování vzoru hodnot kladné měny.CurrencyPositivePattern, to define the pattern of positive currency values.

CurrencySymbol, chcete-li definovat symbol měny.CurrencySymbol, to define the currency symbol.

NegativeSign, chcete-li definovat symbol záporného znaménka.NegativeSign, to define the negative sign symbol.
"D" nebo "d" (specifikátor desítkového formátu)"D" or "d" (decimal format specifier) NegativeSign, chcete-li definovat symbol záporného znaménka.NegativeSign, to define the negative sign symbol.
"E" nebo "e" (specifikátor exponenciálního nebo vědeckého formátu)"E" or "e" (exponential or scientific format specifier) NegativeSign, chcete-li definovat symbol záporného znaménka v mantise a exponentu.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

NumberDecimalSeparator, chcete-li definovat symbol oddělovače desetinných míst.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, chcete-li v exponentu definovat symbol kladného znaménka.PositiveSign, to define the positive sign symbol in the exponent.
"F" nebo "f" (specifikátor formátu s pevnou desetinnou čárkou)"F" or "f" (fixed-point format specifier) NegativeSign, chcete-li definovat symbol záporného znaménka.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, chcete-li definovat výchozí počet zlomkových číslic.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, chcete-li definovat symbol oddělovače desetinných míst.NumberDecimalSeparator, to define the decimal separator symbol.
"G" nebo "g" (obecný specifikátor formátu)"G" or "g" (general format specifier) NegativeSign, chcete-li definovat symbol záporného znaménka.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, chcete-li definovat symbol oddělovače desetinných míst.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, chcete-li definovat symbol kladného znaménka pro výsledné řetězce v exponenciálním formátu.PositiveSign, to define the positive sign symbol for result strings in exponential format.
"N" nebo "n" (specifikátor číselného formátu)"N" or "n" (number format specifier) NegativeSign, chcete-li definovat symbol záporného znaménka.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, chcete-li definovat výchozí počet zlomkových číslic.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, chcete-li definovat symbol oddělovače desetinných míst.NumberDecimalSeparator, to define the decimal separator symbol.

NumberGroupSeparator, chcete-li definovat symbol oddělovače skupin (tisíců).NumberGroupSeparator, to define the group separator (thousands) symbol.

NumberGroupSizes, chcete-li definovat počet integrálních číslic ve skupině.NumberGroupSizes, to define the number of integral digits in a group.

NumberNegativePattern, chcete-li definovat formát záporných hodnot.NumberNegativePattern, to define the format of negative values.
"P" nebo "p" (specifikátor formátu procent)"P" or "p" (percent format specifier) NegativeSign, chcete-li definovat symbol záporného znaménka.NegativeSign, to define the negative sign symbol.

PercentDecimalDigits, chcete-li definovat výchozí počet zlomkových číslic.PercentDecimalDigits, to define the default number of fractional digits.

PercentDecimalSeparator, chcete-li definovat symbol oddělovače desetinných míst.PercentDecimalSeparator, to define the decimal separator symbol.

PercentGroupSeparator, chcete-li definovat symbol oddělovače skupiny.PercentGroupSeparator, to define the group separator symbol.

PercentGroupSizes, chcete-li definovat počet integrálních číslic ve skupině.PercentGroupSizes, to define the number of integral digits in a group.

PercentNegativePatternpro definování umístění symbolu procenta a záporného symbolu pro záporné hodnoty.PercentNegativePattern, to define the placement of the percent symbol and the negative symbol for negative values.

PercentPositivePatternpro definování umístění symbolu procenta pro kladné hodnoty.PercentPositivePattern, to define the placement of the percent symbol for positive values.

PercentSymbol, chcete-li definovat symbol procenta.PercentSymbol, to define the percent symbol.
"R" nebo "r" (specifikátor formátu Round-Trip)"R" or "r" (round-trip format specifier) NegativeSign, chcete-li definovat symbol záporného znaménka.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, chcete-li definovat symbol oddělovače desetinných míst.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, k definování symbol kladného znaménka v exponentu.PositiveSign, to define the positive sign symbol in an exponent.
"X" nebo "x" (specifikátor šestnáctkového formátu)"X" or "x" (hexadecimal format specifier) ŽádnéNone.
"." (specifikátor vlastního formátu desetinné čárky)"." (decimal point custom format specifier) NumberDecimalSeparator, chcete-li definovat symbol oddělovače desetinných míst.NumberDecimalSeparator, to define the decimal separator symbol.
"," (specifikátor vlastního formátu oddělovače skupin)"," (group separator custom format specifier) NumberGroupSeparator, chcete-li definovat symbol oddělovače skupiny (tisíc).NumberGroupSeparator, to define the group (thousands) separator symbol.
"%" (specifikátor vlastního formátu procentního symbolu)"%" (percentage placeholder custom format specifier) PercentSymbol, chcete-li definovat symbol procenta.PercentSymbol, to define the percent symbol.
"‰" (specifikátor vlastního formátu zástupného textu na promile)"‰" (per mille placeholder custom format specifier) PerMilleSymbol, k definování symbolu na promile.PerMilleSymbol, to define the per mille symbol.
"E" (specifikátor vlastního formátu exponenciálního zápisu)"E" (exponential notation custom format specifier) NegativeSign, chcete-li definovat symbol záporného znaménka v mantise a exponentu.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

PositiveSign, chcete-li v exponentu definovat symbol kladného znaménka.PositiveSign, to define the positive sign symbol in the exponent.

Všimněte si, NumberFormatInfo že třída NativeDigits obsahuje vlastnost, která určuje základní 10 číslic používaných specifickou jazykovou verzí.Note that the NumberFormatInfo class includes a NativeDigits property that specifies the base 10 digits used by a specific culture. Tato vlastnost se však nepoužívá při formátování operací. ve výsledném řetězci je použita pouze základní Latinská číslice 0 (U + 0030) až 9 (U + 0039).However, the property is not used in formatting operations; only the Basic Latin digits 0 (U+0030) through 9 (U+0039) are used in the result string. Kromě Single toho pro a Double NaN PositiveInfinitySymbol NegativeInfinitySymbol NaNSymbolhodnoty, PositiveInfinitya se výsledný řetězec skládá výhradně z symbolů definovaných vlastnostmi, a. NegativeInfinity přestup.In addition, for Single and Double values of NaN, PositiveInfinity, and NegativeInfinity, the result string consists exclusively of the symbols defined by the NaNSymbol, PositiveInfinitySymbol, and NegativeInfinitySymbol properties, respectively.

Změna vlastností NumberFormatInfoModifying NumberFormatInfo properties

Můžete upravit vlastnosti NumberFormatInfo objektu pro přizpůsobení výsledného řetězce vytvořeného v rámci operace formátování čísel.You can modify the properties of a NumberFormatInfo object to customize the result string produced in a numeric formatting operation. Použijte následující postup:To do this:

  1. Vytvořte kopii NumberFormatInfo objektu pro čtení a zápis, jejíž konvence formátování chcete upravit.Create a read/write copy of a NumberFormatInfo object whose formatting conventions you want to modify. Další informace naleznete v části vytvoření instance objektu NumberFormatInfo .For more information, see the Instantiating a NumberFormatInfo object section.

  2. Upravte vlastnost nebo vlastnosti, které se používají k výrobě požadovaného výsledného řetězce.Modify the property or properties that are used to produce the desired result string. Informace o tom, jak metody formátování NumberFormatInfo používají vlastnosti k definování výsledných řetězců, naleznete v části formátovací řetězce a vlastnosti NumberFormatInfo .For information about how formatting methods use NumberFormatInfo properties to define result strings, see the Format strings and NumberFormatInfo properties section.

  3. Použijte vlastní NumberFormatInfo objekt IFormatProvider jako argument v volání metody formátování.Use the custom NumberFormatInfo object as the IFormatProvider argument in calls to formatting methods.

Poznámka

Namísto dynamické úpravy hodnot vlastností jazykové verze pokaždé, když je aplikace spuštěná, můžete CultureAndRegionInfoBuilder třídu použít k definování vlastní jazykové verze (jazykové verze, která má jedinečný název a doplňuje stávající jazykové verze), nebo nahrazení. Jazyková verze (ta, která se používá místo konkrétní jazykové verze).Instead of dynamically modifying a culture's property values each time an application is started, you can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture).

V následujících částech jsou uvedeny některé příklady.The following sections provide some examples.

Úpravy symbolu a vzorce měnyModifying the currency symbol and pattern

Následující příklad upravuje NumberFormatInfo objekt, který představuje konvence formátování jazykové verze en-US.The following example modifies a NumberFormatInfo object that represents the formatting conventions of the en-US culture. Přiřadí k CurrencySymbol vlastnosti symbol měny ISO-4217 a definuje vzor pro hodnoty měny, který se skládá z symbolu měny následovaného mezerou a číselnou hodnotou.It assigns the ISO-4217 currency symbol to the CurrencySymbol property and defines a pattern for currency values that consists of the currency symbol followed by a space and a numeric value.

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 číslaFormatting a national identification number

Mnoho národních identifikačních čísel se skládá výhradně z číslic, takže je lze snadno formátovat úpravou vlastností NumberFormatInfo objektu.Many national identification numbers consist exclusively of digits and so can easily be formatted by modifying the properties of a NumberFormatInfo object. Například číslo sociálního pojištění v USA sestává z 9 číslic seřazených takto: XXX-XX-XXXX.For example, a social security number in the United States consists of 9 digits arranged as follows: XXX-XX-XXXX. Následující příklad předpokládá, že čísla sociálních zabezpečení jsou ukládána jako celočíselné hodnoty a odpovídajícím způsobem jejich formátování.The following example assumes that social security numbers are stored as integer values and formats them appropriately.

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ůParsing numeric strings

Analýza zahrnuje převod řetězcové reprezentace čísla na číslo.Parsing involves converting the string representation of a number to a number. Každý číselný typ v .NET Framework zahrnuje dvě přetížené metody analýzy: Parse a. TryParseEach numeric type in the .NET Framework includes two overloaded parsing methods: Parse and TryParse. Parse Metoda převede řetězec na číslo a vyvolá výjimku, pokud se převod nezdařil.The Parse method converts a string to a number and throws an exception if the conversion fails. Metoda převede řetězec na číslo, přiřadí číslo out k Boolean argumentu a vrátí hodnotu, která označuje, zda byl převod úspěšný. TryParseThe TryParse method converts a string to a number, assigns the number to an out argument, and returns a Boolean value that indicates whether the conversion succeeded.

Metody analýzy implicitně nebo explicitně používají NumberStyles hodnotu 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 k dispozici v řetězci, pokud je operace analýzy úspěšná.The parsing methods implicitly or explicitly use a NumberStyles enumeration value to determine what style elements (such as group separators, a decimal separator, or a currency symbol) can be present in a string if the parsing operation is to succeed. Pokud ve volání metody není zadána NumberStyles Float AllowThousands hodnota, výchozí hodnota je hodnota, která zahrnuje příznaky a, které určují, že analyzovaný řetězec může zahrnovat skupinové symboly, oddělovač desetinných míst, záporné znaménko, NumberStyles a prázdné znaky, nebo může být řetězcové vyjádření čísla v exponenciálním zápisu.If a NumberStyles value is not provided in the method call, the default is a NumberStyles value that includes the Float and AllowThousands flags, which specifies that the parsed string can include group symbols, a decimal separator, a negative sign, and white-space characters, or it can be the string representation of a number in exponential notation.

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ý má být analyzován.The parsing methods also implicitly or explicitly use a NumberFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. Pokud není NumberFormatInfo objekt zadán, výchozí hodnota je pro aktuální jazykovou verzi vlákna. NumberFormatInfoIf a NumberFormatInfo object is not provided, the default is the NumberFormatInfo for the current thread culture. Další informace o analýze naleznete v tématu jednotlivé metody Int16.Parse(String)analýzy, jako například Int64.Parse(String, IFormatProvider), Int32.Parse(String, NumberStyles) Decimal.Parse(String, NumberStyles, IFormatProvider),,, Double.TryParse(String, Double)a BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).For more information about parsing, see the individual parsing methods, such as Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double), and BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

Následující příklad ukazuje povahu pro analýzu řetězců závislých na jazykové verzi.The following example illustrates the culture-sensitive nature of parsing strings. Pokusí se analyzovat řetězec, který obsahuje oddělovače tisíců, pomocí konvencí en-US, fr-FR a neutrálních kultur.It tries to parse a string that include thousands separators by using the conventions of the en-US, fr-FR, and invariant cultures. Řetězec, který obsahuje čárku jako oddělovač skupiny a tečku jako oddělovač desetinných míst, se nedokáže analyzovat v jazykové verzi fr-FR a řetězec s prázdným znakem jako oddělovač skupin a čárka jako oddělovač desetinných míst se nedokáže analyzovat v EN-US a neutrální jazykové verzi.A string that includes the comma as a group separator and the period as a decimal separator fails to parse in the fr-FR culture, and a string with white space as a group separator and a comma as a decimal separator fails to parse in the en-US and invariant cultures.

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:Parsing generally occurs in two contexts:

  • Jako operace, která je navržena pro převod vstupu uživatele na číselnou hodnotu.As an operation that is designed to convert user input into a numeric value.

  • Jako operace, která je určená k přenosu číselné hodnoty; To znamená, že k deserializaci číselné hodnoty, která byla dříve serializována jako řetězec.As an operation that is designed to round-trip a numeric value; that is, to deserialize a numeric value that was previously serialized as a string.

Následující části podrobněji popisují tyto dvě operace.The following sections discuss these two operations in greater detail.

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

Při analýze vstupu číselných řetězců uživatelem byste vždy měli vytvořit instanci NumberFormatInfo objektu, který odráží kulturní nastavení uživatele.When you are parsing numeric strings input by the user, you should always instantiate a NumberFormatInfo object that reflects the user's cultural settings. Informace o tom, jak vytvořit instanci NumberFormatInfo objektu, který odráží uživatelské přizpůsobení, najdete v části NumberFormatInfo a dynamická data .For information about how to instantiate a NumberFormatInfo object that reflects user customizations, see the NumberFormatInfo and dynamic data section.

Následující příklad znázorňuje rozdíl mezi operací analýzy, která odráží nastavení kultury uživatele a druhý, který ne.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. V tomto případě je výchozí jazyková verze systému en-US, ale uživatel definoval "", "jako oddělovač skupiny v Ovládacích panelech, oblasti a jazyk". ".In this case, the default system culture is en-US, but the user has defined "," as the decimal symbol and "." as the group separator in Control Panel, Region and Language. Obvykle jsou tyto symboly vráceny ve výchozí jazykové verzi en-US.Ordinarily, these symbols are reversed in the default en-US culture. Když uživatel zadá řetězec, který odráží uživatelská nastavení, a řetězec je analyzován pomocí NumberFormatInfo objektu, který také odráží uživatelská nastavení (přepsání), operace analýzy vrátí správný výsledek.When the user enters a string that reflects user settings, and the string is parsed by a NumberFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. Nicméně, pokud je řetězec analyzován pomocí NumberFormatInfo objektu, který odráží standardní kulturní nastavení en-US, vyhodnotí symbol čárky pro oddělovač skupin a vrátí nesprávný výsledek.However, when the string is parsed by a NumberFormatInfo object that reflects standard en-US cultural settings, it mistakes the comma symbol for a group separator and returns an incorrect result.

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 datSerializing and deserializing numeric data

Pokud jsou číselná data serializována ve formátu řetězce a později deserializovaná a analyzovaná, řetězce by se měly vygenerovat a analyzovat pomocí konvencí invariantní jazykové verze.When numeric data is serialized in string format and later deserialized and parsed, the strings should be generated and parsed by using the conventions of the invariant culture. Operace formátování a analýzy by nikdy neměly odrážet konvence konkrétní jazykové verze.The formatting and parsing operations should never reflect the conventions of a specific culture. Pokud se použije nastavení specifická pro jazykovou verzi, přenositelnost dat je striktně omezené; lze ji úspěšně deserializovat pouze v vlákně, jejíž nastavení specifické pro jazykovou verzi je identické s hodnotami vlákna, na kterých byla serializována.If culture-specific settings are used, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose culture-specific settings are identical to those of the thread on which it was serialized. V některých případech to znamená, že data nelze dokonce úspěšně deserializovat ve stejném systému, na kterém byla serializována.In some cases, this means that the data cannot even be successfully deserialized on the same system on which it was serialized.

Následující příklad ukazuje, co se může stát, když je tento princip porušení.The following example illustrates what can happen when this principle is violated. Hodnoty s plovoucí desetinnou čárkou v poli jsou převedeny na řetězce v případě, že aktuální vlákno používá nastavení kultury en-US specifické pro jazykovou verzi.Floating-point values in an array are converted to strings when the current thread uses the culture-specific settings of the en-US culture. Data jsou poté analyzována vláknem, které používá nastavení specifické jazykové verze jazykové verze en-GB.The data is then parsed by a thread that uses the culture-specific settings of the en-GB culture. V takovém případě, i když každá operace analýzy proběhne úspěšně, nedochází k úspěšnému zpoždění dat a dojde k poškození dat.In this case, although each parsing operation succeeds, the data does not round-trip successfully and data corruption occurs. V jiných případech může být operace analýzy neúspěšná a FormatException mohla by být vyvolána výjimka.In other cases, a parsing operation could fail and a FormatException exception could be thrown.

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

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      PersistData();
      
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      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()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      PersistData()
      
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
      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() NumberFormatInfo() NumberFormatInfo() NumberFormatInfo()

Inicializuje novou zapisovatelnou instanci NumberFormatInfo třídy, která je nezávislé na jazykové verzi (invariantní).Initializes a new writable instance of the NumberFormatInfo class that is culture-independent (invariant).

Vlastnosti

CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits

Získá nebo nastaví počet desetinných míst, která se mají použít v hodnotách měny.Gets or sets the number of decimal places to use in currency values.

CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator

Získá nebo nastaví řetězec, který má být použit jako oddělovač desetinných míst v hodnotách měny.Gets or sets the string to use as the decimal separator in currency values.

CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator

Získá nebo nastaví řetězec, který odděluje skupiny číslic nalevo od desetinné čárky v hodnotách měny.Gets or sets the string that separates groups of digits to the left of the decimal in currency values.

CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes

Získá nebo nastaví počet číslic v každé skupině vlevo od desetinné čárky v hodnotách měny.Gets or sets the number of digits in each group to the left of the decimal in currency values.

CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern

Získá nebo nastaví vzor formátu pro záporné hodnoty měny.Gets or sets the format pattern for negative currency values.

CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern

Získá nebo nastaví vzor formátu pro kladné hodnoty měny.Gets or sets the format pattern for positive currency values.

CurrencySymbol CurrencySymbol CurrencySymbol CurrencySymbol

Získá nebo nastaví řetězec, který má být použit jako symbol měny.Gets or sets the string to use as the currency symbol.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Získá pouze NumberFormatInfo pro čtení, které formátuje hodnoty na základě aktuální jazykové verze.Gets a read-only NumberFormatInfo that formats values based on the current culture.

DigitSubstitution DigitSubstitution DigitSubstitution DigitSubstitution

Získává nebo nastavuje hodnotu, která určuje, jak grafické uživatelské rozhraní zobrazuje tvar číslice.Gets or sets a value that specifies how the graphical user interface displays the shape of a digit.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Získá objekt jen NumberFormatInfo pro čtení, který je nezávislý na jazykové verzi (invariantní).Gets a read-only NumberFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Získá hodnotu, která označuje, zda NumberFormatInfo je tento objekt určen jen pro čtení.Gets a value that indicates whether this NumberFormatInfo object is read-only.

NaNSymbol NaNSymbol NaNSymbol NaNSymbol

Získá nebo nastaví řetězec, který představuje hodnotu IEEE NaN (není číslo).Gets or sets the string that represents the IEEE NaN (not a number) value.

NativeDigits NativeDigits NativeDigits NativeDigits

Získá nebo nastaví pole řetězce nativních číslic, které odpovídají západním číslicím 0 až 9.Gets or sets a string array of native digits equivalent to the Western digits 0 through 9.

NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol

Získá nebo nastaví řetězec, který představuje záporné nekonečno.Gets or sets the string that represents negative infinity.

NegativeSign NegativeSign NegativeSign NegativeSign

Získá nebo nastaví řetězec, který označuje, že přidružené číslo je záporné.Gets or sets the string that denotes that the associated number is negative.

NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits

Získá nebo nastaví počet desetinných míst, která se mají použít v numerických hodnotách.Gets or sets the number of decimal places to use in numeric values.

NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator

Získá nebo nastaví řetězec, který má být použit jako oddělovač desetinných míst v numerických hodnotách.Gets or sets the string to use as the decimal separator in numeric values.

NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator

Získá nebo nastaví řetězec, který odděluje skupiny číslic nalevo od desetinné čárky v numerických hodnotách.Gets or sets the string that separates groups of digits to the left of the decimal in numeric values.

NumberGroupSizes NumberGroupSizes NumberGroupSizes NumberGroupSizes

Získá nebo nastaví počet číslic v každé skupině nalevo od desetinné čárky v numerických hodnotách.Gets or sets the number of digits in each group to the left of the decimal in numeric values.

NumberNegativePattern NumberNegativePattern NumberNegativePattern NumberNegativePattern

Získá nebo nastaví vzor formátu pro záporné číselné hodnoty.Gets or sets the format pattern for negative numeric values.

PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits

Získá nebo nastaví počet desetinných míst, která se mají použít v procentuálních hodnotách.Gets or sets the number of decimal places to use in percent values.

PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator

Získá nebo nastaví řetězec, který má být použit jako oddělovač desetinných míst v procentuálních hodnotách.Gets or sets the string to use as the decimal separator in percent values.

PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator

Získá nebo nastaví řetězec, který odděluje skupiny číslic nalevo od desetinné hodnoty v procentech.Gets or sets the string that separates groups of digits to the left of the decimal in percent values.

PercentGroupSizes PercentGroupSizes PercentGroupSizes PercentGroupSizes

Získá nebo nastaví počet číslic v každé skupině nalevo od desetinné hodnoty v procentech.Gets or sets the number of digits in each group to the left of the decimal in percent values.

PercentNegativePattern PercentNegativePattern PercentNegativePattern PercentNegativePattern

Získá nebo nastaví vzor formátu pro záporné procentuální hodnoty.Gets or sets the format pattern for negative percent values.

PercentPositivePattern PercentPositivePattern PercentPositivePattern PercentPositivePattern

Získá nebo nastaví vzorek formátu pro kladné procentuální hodnoty.Gets or sets the format pattern for positive percent values.

PercentSymbol PercentSymbol PercentSymbol PercentSymbol

Získá nebo nastaví řetězec, který má být použit jako symbol procenta.Gets or sets the string to use as the percent symbol.

PerMilleSymbol PerMilleSymbol PerMilleSymbol PerMilleSymbol

Získá nebo nastaví řetězec, který má být použit jako symbol na promile.Gets or sets the string to use as the per mille symbol.

PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol

Získá nebo nastaví řetězec, který představuje kladné nekonečno.Gets or sets the string that represents positive infinity.

PositiveSign PositiveSign PositiveSign PositiveSign

Získá nebo nastaví řetězec, který označuje, že přidružené číslo je kladné.Gets or sets the string that denotes that the associated number is positive.

Metody

Clone() Clone() Clone() Clone()

Vytvoří kopii NumberFormatInfo objektu bez podstruktury.Creates a shallow copy of the NumberFormatInfo object.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetFormat(Type) GetFormat(Type) GetFormat(Type) GetFormat(Type)

Získá objekt zadaného typu, který poskytuje službu formátování čísel.Gets an object of the specified type that provides a number formatting service.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Inherited from Object)
GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider)

Získá přidružený k určenému IFormatProvider. NumberFormatInfoGets the NumberFormatInfo associated with the specified IFormatProvider.

GetType() GetType() GetType() GetType()

Type Získá aktuální instanci.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Vytvoří kopii aktuálního Objectseznamu.Creates a shallow copy of the current Object.

(Inherited from Object)
ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo)

Vrátí obálku určenou jen NumberFormatInfo pro čtení.Returns a read-only NumberFormatInfo wrapper.

ToString() ToString() ToString() ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Inherited from Object)

Platí pro

Viz také