NumberFormatInfo NumberFormatInfo NumberFormatInfo NumberFormatInfo Class

Definicja

Specyficzne dla kultury informacje dotyczące formatowania i analizowania wartości liczbowych.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
Dziedziczenie
NumberFormatInfoNumberFormatInfoNumberFormatInfoNumberFormatInfo
Atrybuty
Implementuje

Przykłady

Poniższy przykład pokazuje, jak pobrać NumberFormatInfo obiekt odpowiadający CultureInfo obiektu, a następnie użyj pobrano obiekt do zapytania numeru formatowania informacje dotyczące określonej kultury.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 '$'

Uwagi

NumberFormatInfo Klasa zawiera informacje specyficzne dla kultury, która jest używana podczas formatowania i analizowania wartości liczbowych.The NumberFormatInfo class contains culture-specific information that is used when you format and parse numeric values. Informacje te obejmują symbol waluty, symbol dziesiętny, symbol separatora grupy i symboli dla znaków pozytywnych i negatywnych.This information includes the currency symbol, the decimal symbol, the group separator symbol, and the symbols for positive and negative signs.

Utworzenie wystąpienia obiektu NumberFormatInfoInstantiating a NumberFormatInfo object

Można utworzyć wystąpienie NumberFormatInfo obiekt, który reprezentuje konwencje formatowania bieżącej kultury niezmiennej kultury, określonej kultury i kultury neutralnej.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.

Utworzenie wystąpienia obiektu NumberFormatInfo dla bieżącej kulturyInstantiating a NumberFormatInfo object for the current culture

Można utworzyć wystąpienie NumberFormatInfo obiektu dla bieżącej kultury wątku w dowolnym z następujących sposobów.You can instantiate a NumberFormatInfo object for the current thread culture in any of the following ways. W każdym przypadku zwracanego NumberFormatInfo obiekt jest tylko do odczytu.In each case, the returned NumberFormatInfo object is read-only.

W poniższym przykładzie użyto te trzy sposoby tworzenia NumberFormatInfo obiekty reprezentujące konwencje formatowania bieżącej kultury.The following example uses these three ways to create NumberFormatInfo objects that represent the formatting conventions of the current culture. Pobiera również wartość IsReadOnly właściwości, aby zilustrować, że każdy obiekt jest tylko do odczytu.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

Możesz utworzyć zapisywalnego NumberFormatInfo obiekt, który reprezentuje konwencje bieżącej kultury wątku w dowolnym z następujących sposobów:You can create a writable NumberFormatInfo object that represents the conventions of the current thread culture in any of the following ways:

Poniższy przykład ilustruje te dwa sposoby tworzenia wystąpienia NumberFormatInfo obiektu, a następnie wyświetla wartość jego IsReadOnly właściwości, aby zilustrować, że obiekt nie jest tylko do odczytu.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

Należy zauważyć, że system operacyjny Windows pozwala użytkownikowi zastąpić niektóre NumberFormatInfo wartości właściwości używane w liczbowych formatowania i analizowania operacji za pomocą Region i język w Panelu sterowania.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. Na przykład wybrać użytkownika, którego kultura jest angielski (Stany Zjednoczone) do wyświetlania wartości waluty USD 1.1 zamiast domyślnego $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 Obiektów, pobrać w sposób omówionych wcześniej wszystkie odzwierciedlać te zastąpienia użytkownika.The NumberFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Jeśli jest to niepożądane, możesz utworzyć NumberFormatInfo obiektu, który nie będzie odzwierciedlał napisanie użytkownika (, a ponadto odczytu/zapisu, a nie tylko do odczytu) przez wywołanie metody CultureInfo.CultureInfo(String, Boolean) Konstruktor i podanie wartości false dla 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. W poniższym przykładzie przedstawiono ilustracja dla systemu, którego bieżącą kulturą jest angielski (Stany Zjednoczone) i którego symbol waluty została zmieniona z domyślnego $ do 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: $

Jeśli CultureInfo.UseUserOverride właściwość jest ustawiona na true, właściwości CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, i CultureInfo.TextInfo są również pobierane z ustawień użytkownika.If the CultureInfo.UseUserOverride property is set to true, the properties CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, and CultureInfo.TextInfo are also retrieved from the user settings. Jeśli ustawienia użytkownika są niezgodne z kulturą skojarzoną z CultureInfo obiektu (na przykład, jeśli wybrany kalendarz nie jest jednym z kalendarzy rozbiciu OptionalCalendars właściwości), wyniki metod i wartości właściwości nie zdefiniowano.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.

Utworzenie wystąpienia obiektu NumberFormatInfo dla niezmiennej kulturyInstantiating a NumberFormatInfo object for the invariant culture

Niezmienna kultura reprezentuje kulturę, w której nie uwzględnia się ustawień kulturowych.The invariant culture represents a culture that is culture-insensitive. Jest ona oparta na język angielski, ale nie na dowolnym określonym anglojęzycznego kraju/regionie.It is based on the English language but not on any specific English-speaking country/region. Mimo że danych określonych kultur może być dynamiczny i można zmieniać, aby odzwierciedlić nowe konwencje kultury lub preferencje użytkownika, danych o niezmiennej kultury nie zmienia się.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. A NumberFormatInfo obiekt, który reprezentuje konwencje formatowania niezmiennej kultury może służyć do formatowania operacje, w wyniku której parametry nie powinny zmieniać przez kulturę.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.

Można utworzyć wystąpienie NumberFormatInfo obiekt, który reprezentuje konwencje formatowania niezmiennej kultury w następujący sposób:You can instantiate a NumberFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

W poniższym przykładzie użyto, każda z tych metod do utworzenia wystąpienia NumberFormatInfo obiekt, który reprezentuje niezmienną kulturę.The following example uses each of these methods to instantiate a NumberFormatInfo object that represents the invariant culture. Następnie wskazuje, czy obiekt jest tylko do odczytuIt 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

Utworzenie wystąpienia obiektu NumberFormatInfo dla określonej kulturyInstantiating a NumberFormatInfo object for a specific culture

Określonej kultury reprezentuje język, który jest używany w danym kraju/regionie.A specific culture represents a language that is spoken in a particular country/region. Na przykład en US jest określoną kulturę, która reprezentuje język angielski, używany w Stanach Zjednoczonych i en-urząd certyfikacji jest określoną kulturę, która reprezentuje język angielski, używany w Kanadzie.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. Można utworzyć wystąpienie NumberFormatInfo obiekt, który reprezentuje konwencje formatowania określonej kultury w następujący sposób:You can instantiate a NumberFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

W poniższym przykładzie użyto tych czterech sposobów tworzenia NumberFormatInfo obiekt, który odzwierciedla konwencje formatowania kultury indonezyjski (Indonezja).The following example uses these four ways to create a NumberFormatInfo object that reflects the formatting conventions of the Indonesian (Indonesia) culture. Wskazuje także, czy każdy obiekt jest tylko do odczytu.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

Utworzenie wystąpienia obiektu NumberFormatInfo dla kultury neutralnejInstantiating a NumberFormatInfo object for a neutral culture

Kultury neutralnej reprezentuje kultury lub języka, który jest niezależny od kraju/regionu.A neutral culture represents a culture or language that is independent of a country/region. Zwykle jest elementem nadrzędnym jeden lub więcej określonych kultur.It is typically the parent of one or more specific cultures. Na przykład fr jest kultury neutralnej dla języka francuskiego i element nadrzędny kultury fr-FR.For example, fr is a neutral culture for the French language and the parent of the fr-FR culture. Możesz utworzyć NumberFormatInfo obiekt, który reprezentuje konwencje formatowania kultury neutralnej w taki sam sposób, którą tworzysz NumberFormatInfo obiekt, który reprezentuje konwencje formatowania określonej kultury.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.

Uwaga

W Program .NET Framework 3,5.NET Framework 3.5 i wcześniejszymi wersjami, próby pobrania NumberFormatInfo wyrzuca obiekt, który odzwierciedla konwencje formatowania kultury neutralnej NotSupportedException wyjątku.In the Program .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.

Jednak ponieważ jest ono niezależne od określonego kraju/regionu, kultury neutralnej nie posiada informacje o formatowaniu specyficzne dla kultury.However, because it is independent of a specific country/region, a neutral culture lacks culture-specific formatting information. Zamiast wypełnianie NumberFormatInfo obiekt z ogólnych wartości, zwraca programu .NET Framework NumberFormatInfo obiekt, który odzwierciedla konwencje formatowania określonej kultury, która jest elementem podrzędnym kultury neutralnej.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. Na przykład NumberFormatInfo obiektu dla kultury neutralnej en odzwierciedla konwencje formatowania kultury en US i NumberFormatInfo obiektu dla kultury fr odzwierciedla konwencje formatowania kultury 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.

Aby określić, które określonej kultury konwencje formatowania reprezentuje każdej kultury neutralnej, można użyć kodu, jak pokazano poniżej.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
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 i dane dynamiczneNumberFormatInfo and dynamic data

Formatowanie wartości numerycznych, dostarczone przez dane specyficzne dla kultury NumberFormatInfo klasa jest dynamiczny, podobnie jak dane dotyczące kultury, dostarczone przez CultureInfo klasy.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. Nie należy czynić żadnych założeń o stabilności wartości dla NumberFormatInfo obiekty, które są skojarzone z określonego CultureInfo obiektów.You should not make any assumptions about the stability of values for NumberFormatInfo objects that are associated with particular CultureInfo objects. Tylko dane dostarczane przez niezmiennej kultury i związanych z nią NumberFormatInfo obiektu jest stabilna.Only the data provided by the invariant culture and its associated NumberFormatInfo object is stable. Zmienić inne dane między sesjami aplikacji lub nawet w ramach jednej sesji z następujących powodów:Other data can change between application sessions, or even within a single session, for the following reasons:

  • Aktualizacje systemu.System updates. Zmień preferencje kultury, takich jak symbol waluty lub formaty waluty z wartościami wraz z upływem czasu.Cultural preferences such as the currency symbol or currency formats change over time. W takiej sytuacji aktualizacja Windows obejmuje zmiany NumberFormatInfo wartości właściwości dla określonej kultury.When this happens, Windows Update includes changes to the NumberFormatInfo property value for a particular culture.

  • Zamienne.Replacement cultures. CultureAndRegionInfoBuilder Klasa może być używana, aby zamienić dane istniejące kultury.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Kaskadowe zmiany wartości właściwości.Cascading changes to property values. Wiele właściwości związane z kulturą można zmieniać w czasie wykonywania, co z kolei powoduje, że NumberFormatInfo dane, aby zmienić.A number of culture-related properties can change at run time, which, in turn, causes NumberFormatInfo data to change. Na przykład bieżąca kultura można zmienić programowo lub za pomocą akcji przez użytkownika.For example, the current culture can be changed either programmatically or through user action. W takim przypadku NumberFormatInfo obiektu zwróconego przez CurrentInfo zmienia właściwość do obiektu, który został skojarzony z bieżącą kulturą.When this happens, the NumberFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture.

  • Preferencje użytkownika.User preferences. Użytkownicy aplikacji mogą zastąpić niektóre wartości skojarzone z bieżącą kulturą systemu za pośrednictwem Opcje regionalne i językowe w Panelu sterowania.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. Na przykład użytkownicy mogą używać innego symbolu waluty lub symbol separatora dziesiętnego w innej.For example, users might choose a different currency symbol or a different decimal separator symbol. Jeśli CultureInfo.UseUserOverride właściwość jest ustawiona na true (wartość domyślna), właściwości NumberFormatInfo obiektu są również pobierane z ustawień użytkownika.If the CultureInfo.UseUserOverride property is set to true (its default value), the properties of the NumberFormatInfo object are also retrieved from the user settings.

Począwszy od programu .NET Framework 2.0, wszystkich użytkowników do przesłonięcia właściwości NumberFormatInfo obiektu są inicjowane, gdy obiekt jest tworzony.Starting with the .NET Framework 2.0, all user-overridable properties of a NumberFormatInfo object are initialized when the object is created. Istnieje możliwość niespójności, ponieważ żaden obiekt tworzenie ani proces zastąpienie użytkownika jest atomic i odpowiednie wartości mogą ulec zmianie podczas tworzenia obiektu.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. Jednak problemy powodujące te niespójności powinny być bardzo rzadko.However, these inconsistencies should be extremely rare.

Można kontrolować, czy użytkownik zastąpienia są odzwierciedlane w NumberFormatInfo obiektami, które reprezentują tę samą kulturę co bieżąca kultura wątku.You can control whether user overrides are reflected in NumberFormatInfo objects that represent the same culture as the current thread culture. W poniższej tabeli przedstawiono sposoby, w którym NumberFormatInfo obiekt mogą być pobierane i wskazuje, czy wynikowy obiekt odzwierciedla napisanie użytkownika.The following table lists the ways in which a NumberFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Źródłowy obiekt CultureInfo i NumberFormatInfoSource of CultureInfo and NumberFormatInfo object Odzwierciedla napisanie użytkownikaReflects user overrides
CultureInfo.CurrentCulture.NumberFormat WłaściwośćCultureInfo.CurrentCulture.NumberFormat property TakYes
NumberFormatInfo.CurrentInfo WłaściwośćNumberFormatInfo.CurrentInfo property TakYes
CultureInfo.CreateSpecificCulture — MetodaCultureInfo.CreateSpecificCulture method TakYes
CultureInfo.GetCultureInfo — MetodaCultureInfo.GetCultureInfo method NieNo
CultureInfo(String) KonstruktorCultureInfo(String) constructor TakYes
CultureInfo.CultureInfo(String, Boolean) KonstruktorCultureInfo.CultureInfo(String, Boolean) constructor Zależy od wartości useUserOverride parametruDepends on value of useUserOverride parameter

Chyba że istnieje istotny powód, aby robić, należy przestrzegać napisanie użytkownika, gdy używasz NumberFormatInfo obiektu w aplikacjach klienckich do formatowania i analizowania danych wejściowych użytkownika lub, aby wyświetlić dane liczbowe.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. Dla aplikacji serwera lub nienadzorowanej aplikacji nie należy przestrzegać napisanie użytkownika.For server applications or unattended applications, you should not respect user overrides. Jednak jeśli używasz NumberFormatInfo obiektu albo jawnie lub niejawnie do utrwalenia danych liczbowych w postaci ciągu, należy użyć NumberFormatInfo należy określić obiekt, który odzwierciedla konwencje formatowania kultury niezmiennej, lub ciąg niestandardowego formatu liczb, którego używasz, niezależnie od kultury.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 i formatowanie liczboweIFormatProvider, NumberFormatInfo, and numeric formatting

A NumberFormatInfo obiekt jest używany jawnie lub niejawnie liczbowe wszystkich operacjach formatowania.A NumberFormatInfo object is used implicitly or explicitly in all numeric formatting operations. Obejmują one wywołania następujących metod:These include calls to the following methods:

Wprowadź wszystkich operacji formatowania liczbowego użytkowania IFormatProvider implementacji.All numeric formatting operations make use of an IFormatProvider implementation. IFormatProvider Interfejs zawiera jedną metodę GetFormat(Type).The IFormatProvider interface includes a single method, GetFormat(Type). Jest to metoda wywołania zwrotnego, który jest przekazywany Type obiekt, który reprezentuje typ niezbędnej do zapewnienia informacji o formatowaniu.This is a callback method that is passed a Type object that represents the type needed to provide formatting information. Metoda jest odpowiedzialna za zwrócenie wystąpienie tego typu lub null, jeśli wystąpienie tego typu nie może dostarczyć.The method is responsible for returning either an instance of that type or null, if it cannot provide an instance of the type. Program .NET Framework zawiera dwa IFormatProvider niedotyczące formatowanie liczb:The .NET Framework provides two IFormatProvider implementations for formatting numbers:

Jeśli IFormatProvider wdrożenia nie zostanie podany do metody formatowania jawnie CultureInfo obiektu zwróconego przez CultureInfo.CurrentCulture właściwość, która reprezentuje bieżącą kulturę wątku jest używana.If 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.

W poniższym przykładzie pokazano relację między IFormatProvider interfejsu i NumberFormatInfo klasy w operacjach formatowania przez zdefiniowanie niestandardowego IFormatProvider implementacji.The following example illustrates the relationship between the IFormatProvider interface and the NumberFormatInfo class in formatting operations by defining a custom IFormatProvider implementation. Jego GetFormat metoda Wyświetla nazwę typu obiektu, żądane przez operację formatowania.Its GetFormat method displays the type name of the object requested by the formatting operation. Jeśli interfejs żąda NumberFormatInfo obiektu, ta metoda zapewnia NumberFormatInfo obiektu dla bieżącej kultury wątku.If the interface is requesting a NumberFormatInfo object, this method provides the NumberFormatInfo object for the current thread culture. Jako dane wyjściowe w przykładzie pokazano Decimal.ToString(IFormatProvider) metod żądań NumberFormatInfo obiektu, aby zapewnić informacje o formatowaniu, natomiast String.Format(IFormatProvider, String, Object[]) metod żądań NumberFormatInfo i DateTimeFormatInfo obiektów, a także ICustomFormatter Implementacja.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

Jeśli IFormatProvider implementacji nie została jawnie podana w liczbową wywołania metody, wywołań metod formatowania CultureInfo.CurrentCulture.GetFormat metody, która zwraca NumberFormatInfo obiekt, który odpowiada bieżącej kultury wątku.If 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.

Ciągi formatów i właściwości NumberFormatInfoFormat strings and NumberFormatInfo properties

Każda operacja formatowania używa standardowym lub niestandardowym ciągiem formatu liczbowego w celu wygenerowania ciąg wynikowy z liczbą.Every formatting operation uses either a standard or a custom numeric format string to produce a result string from a number. W niektórych przypadkach użycie ciągu formatowania, aby utworzyć ciąg wynikowy jest jawne, jak w poniższym przykładzie.In some cases, the use of a format string to produce a result string is explicit, as in the following example. Ten kod wywołuje Decimal.ToString(IFormatProvider) metodę, aby przekonwertować Decimal wartości na liczbę różnych ciągów reprezentujących przy użyciu konwencji formatowania kultury 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

W innych przypadkach korzystanie z ciągiem formatu jest niejawne.In other cases, the use of a format string is implicit. Na przykład w następujących wywołania metody bez parametrów lub domyślny Decimal.ToString() metody, wartość Decimal wystąpienie jest sformatowana przy użyciu specyfikatora formatu ogólnego ("G") i Konwencji bieżącej kultury, czyli w tym przypadku kultura 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żdy ciąg standardowego formatu liczb używa co najmniej jeden NumberFormatInfo właściwości w celu określenia wzorca lub symbole używane w ciągu wynikowym.Each standard numeric format string uses one or more NumberFormatInfo properties to determine the pattern or the symbols used in the result string. Podobnie, każdy niestandardowy specyfikator formatu liczbowego z wyjątkiem "0" i "#" wstawić symbole w ciągu wynikowym, które są zdefiniowane przez NumberFormatInfo właściwości.Similarly, each custom numeric format specifier except "0" and "#" insert symbols in the result string that are defined by NumberFormatInfo properties. W poniższej tabeli wymieniono standardowych i niestandardowych specyfikatorów formatu liczbowego i ich skojarzone NumberFormatInfo właściwości.The following table lists the standard and custom numeric format specifiers and their associated NumberFormatInfo properties. Aby zmienić wygląd ciągu wynikowego dla danej kultury, zobacz właściwości NumberFormatInfo modyfikowanie sekcji.To change the appearance of the result string for a particular culture, see the Modifying NumberFormatInfo properties section. Aby uzyskać szczegółowe informacje dotyczące korzystania z tych specyfikatory formatu, zobacz Standard Numeric Format Strings i Custom Numeric Format Strings.For details about the use of these format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

Specyfikator formatuFormat specifier Skojarzonych z nimi właściwościAssociated properties
"C" lub "c" (specyfikator formatu waluty)"C" or "c" (currency format specifier) CurrencyDecimalDigits, aby zdefiniować domyślną liczbę cyfr dziesiętnych.CurrencyDecimalDigits, to define the default number of fractional digits.

CurrencyDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.CurrencyDecimalSeparator, to define the decimal separator symbol.

CurrencyGroupSeparator, aby zdefiniować grupy lub tysiące separatora.CurrencyGroupSeparator, to define the group or thousands separator.

CurrencyGroupSizes, aby zdefiniować rozmiary grup całkowitoliczbowy.CurrencyGroupSizes, to define the sizes of integral groups.

CurrencyNegativePattern, aby zdefiniować wzorzec ujemnych wartości waluty.CurrencyNegativePattern, to define the pattern of negative currency values.

CurrencyPositivePattern, do definiowania wzorzec dodatnich wartości waluty.CurrencyPositivePattern, to define the pattern of positive currency values.

CurrencySymbol, aby zdefiniować symbol waluty.CurrencySymbol, to define the currency symbol.

NegativeSign, aby zdefiniować symbol znaku ujemnego.NegativeSign, to define the negative sign symbol.
"D" lub "d" (specyfikator formatu dziesiętnego)"D" or "d" (decimal format specifier) NegativeSign, aby zdefiniować symbol znaku ujemnego.NegativeSign, to define the negative sign symbol.
"E" lub "e" (specyfikator formatu wykładniczego i naukowych)"E" or "e" (exponential or scientific format specifier) NegativeSign, aby zdefiniować symbol znaku ujemnego w mantysy i wykładnika.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, aby zdefiniować symbol znaku dodatniego wykładnika.PositiveSign, to define the positive sign symbol in the exponent.
"F" lub "f" (specyfikator formatu stałoprzecinkowego)"F" or "f" (fixed-point format specifier) NegativeSign, aby zdefiniować symbol znaku ujemnego.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, aby zdefiniować domyślną liczbę cyfr dziesiętnych.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.NumberDecimalSeparator, to define the decimal separator symbol.
"G" lub "g" (specyfikator formatu ogólnego)"G" or "g" (general format specifier) NegativeSign, aby zdefiniować symbol znaku ujemnego.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, aby zdefiniować symbol znaku dodatniego ciągi wynikowe w notacji wykładniczej.PositiveSign, to define the positive sign symbol for result strings in exponential format.
"N" lub "n" (specyfikatora formatu liczby)"N" or "n" (number format specifier) NegativeSign, aby zdefiniować symbol znaku ujemnego.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, aby zdefiniować domyślną liczbę cyfr dziesiętnych.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.NumberDecimalSeparator, to define the decimal separator symbol.

NumberGroupSeparator, aby zdefiniować symbol separatora (w tysiącach) grupy.NumberGroupSeparator, to define the group separator (thousands) symbol.

NumberGroupSizes, aby zdefiniować liczbę cyfr liczby całkowitej w grupie.NumberGroupSizes, to define the number of integral digits in a group.

NumberNegativePattern, aby zdefiniować format wartości ujemnych.NumberNegativePattern, to define the format of negative values.
"P" lub "p" (specyfikator formatu procent)"P" or "p" (percent format specifier) NegativeSign, aby zdefiniować symbol znaku ujemnego.NegativeSign, to define the negative sign symbol.

PercentDecimalDigits, aby zdefiniować domyślną liczbę cyfr dziesiętnych.PercentDecimalDigits, to define the default number of fractional digits.

PercentDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.PercentDecimalSeparator, to define the decimal separator symbol.

PercentGroupSeparator, aby zdefiniować symbol separatora grupy.PercentGroupSeparator, to define the group separator symbol.

PercentGroupSizes, aby zdefiniować liczbę cyfr liczby całkowitej w grupie.PercentGroupSizes, to define the number of integral digits in a group.

PercentNegativePattern, aby zdefiniować położenie symbol procentu i symbolu wartości ujemnej dla wartości ujemnych.PercentNegativePattern, to define the placement of the percent symbol and the negative symbol for negative values.

PercentPositivePattern, aby zdefiniować położenie symbolu procentu dla wartości dodatnich.PercentPositivePattern, to define the placement of the percent symbol for positive values.

PercentSymbol, aby zdefiniować symbol procentu.PercentSymbol, to define the percent symbol.
"R" lub "r" (specyfikator formatu obustronne)"R" or "r" (round-trip format specifier) NegativeSign, aby zdefiniować symbol znaku ujemnego.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, aby zdefiniować symbol znaku dodatniego w wykładnik potęgi.PositiveSign, to define the positive sign symbol in an exponent.
"X" lub "x" (specyfikator w formacie szesnastkowym)"X" or "x" (hexadecimal format specifier) Brak.None.
"." (specyfikator formatu niestandardowego punktu dziesiętnego)"." (decimal point custom format specifier) NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.NumberDecimalSeparator, to define the decimal separator symbol.
"," (specyfikator formatu niestandardowego separatora grup)"," (group separator custom format specifier) NumberGroupSeparator, aby zdefiniować symbol separatora grupy (w tysiącach).NumberGroupSeparator, to define the group (thousands) separator symbol.
"%" (specyfikator formatu niestandardowego symbol zastępczy wartości procentowej)"%" (percentage placeholder custom format specifier) PercentSymbol, aby zdefiniować symbol procentu.PercentSymbol, to define the percent symbol.
"‰" (na specyfikator formatu niestandardowego symbolu zastępczego promila)"‰" (per mille placeholder custom format specifier) PerMilleSymbol, aby zdefiniować symbol promila.PerMilleSymbol, to define the per mille symbol.
"E" (specyfikator formatu niestandardowego notacji wykładniczej)"E" (exponential notation custom format specifier) NegativeSign, aby zdefiniować symbol znaku ujemnego w mantysy i wykładnika.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

PositiveSign, aby zdefiniować symbol znaku dodatniego wykładnika.PositiveSign, to define the positive sign symbol in the exponent.

Należy pamiętać, że NumberFormatInfo klasa zawiera NativeDigits właściwość, która określa, 10 podstawowych cyfr używana przez określoną kulturę.Note that the NumberFormatInfo class includes a NativeDigits property that specifies the base 10 digits used by a specific culture. Jednak właściwość nie jest używana w operacji formatowania tylko Łaciński podstawowy cyfr od 0 (U + 0030) do 9 (U + 0039) są używane w ciągu wynikowym.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. Ponadto, aby uzyskać Single i Double wartości NaN, PositiveInfinity, i NegativeInfinity, ciąg wynikowy, który składa się wyłącznie z symbole zdefiniowane przez NaNSymbol, PositiveInfinitySymbol, i NegativeInfinitySymbol właściwości , odpowiednio.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.

Modyfikowanie właściwości NumberFormatInfoModifying NumberFormatInfo properties

Można zmodyfikować właściwości NumberFormatInfo obiekt, aby dostosować ciąg wynikowy utworzony w liczbową operacji formatowania.You can modify the properties of a NumberFormatInfo object to customize the result string produced in a numeric formatting operation. W tym celu:To do this:

  1. Utwórz kopię odczytu/zapisu NumberFormatInfo obiektu, której konwencje formatowania, którą chcesz zmodyfikować.Create a read/write copy of a NumberFormatInfo object whose formatting conventions you want to modify. Aby uzyskać więcej informacji, zobacz utworzenie wystąpienia obiektu NumberFormatInfo sekcji.For more information, see the Instantiating a NumberFormatInfo object section.

  2. Zmodyfikuj właściwości lub właściwości, które są używane do tworzenia ciągu pożądanych efektów.Modify the property or properties that are used to produce the desired result string. Aby uzyskać informacje na temat formatowania sposób używania metody NumberFormatInfo Zobacz właściwości, aby zdefiniować ciągi wynikowe formatowanie ciągów i właściwości NumberFormatInfo sekcji.For information about how formatting methods use NumberFormatInfo properties to define result strings, see the Format strings and NumberFormatInfo properties section.

  3. Użyj niestandardowego NumberFormatInfo obiektu jako IFormatProvider argument w wywołaniach do metod formatowania.Use the custom NumberFormatInfo object as the IFormatProvider argument in calls to formatting methods.

Uwaga

Zamiast dynamiczne modyfikowanie wartości właściwości kultury za każdym razem, jest uruchamiana aplikacja, możesz użyć CultureAndRegionInfoBuilder klasy, aby zdefiniować kultury niestandardowej (kultury, ma unikatową nazwę i które uzupełniają istniejące kultur) lub mogą zastąpić kultura (taki, który jest używany zamiast określonej kultury).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).

Kilka przykładów można znaleźć w poniższych sekcjach.The following sections provide some examples.

Modyfikowanie symbolu waluty i wzoruModifying the currency symbol and pattern

Poniższy przykład modyfikuje NumberFormatInfo obiekt, który reprezentuje konwencje formatowania kultury en US.The following example modifies a NumberFormatInfo object that represents the formatting conventions of the en-US culture. Przypisuje symbol waluty ISO 4217 CurrencySymbol właściwości i definiuje wzorzec dla wartości waluty, który składa się z symbolu waluty, następuje spacja i wartością liczbową.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

Formatowanie krajowego numeru identyfikacyjnegoFormatting a national identification number

Wiele narodowe numery identyfikacyjne składać się wyłącznie z cyfr i dlatego można łatwo formatować, modyfikując właściwości NumberFormatInfo obiektu.Many national identification numbers consist exclusively of digits and so can easily be formatted by modifying the properties of a NumberFormatInfo object. Na przykład numer ubezpieczenia społecznego w Stanach Zjednoczonych składa się z 9 cyfr ułożone w następujący sposób: XXX-XX-XXXX.For example, a social security number in the United States consists of 9 digits arranged as follows: XXX-XX-XXXX. W poniższym przykładzie założono, że numery ubezpieczenia społecznego są przechowywane jako liczby całkowitej wartości oraz formatuje je, odpowiednio.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

Analizowanie ciągów numerycznychParsing numeric strings

Podczas analizowania polega na konwersji ciąg reprezentujący liczbę na liczbę.Parsing involves converting the string representation of a number to a number. Każdego typu liczbowego w programie .NET Framework zawiera dwa przeciążonych metod analizowania: Parse i TryParse.Each numeric type in the .NET Framework includes two overloaded parsing methods: Parse and TryParse. Parse Metoda konwertuje ciąg na liczbę i zgłasza wyjątek, jeśli konwersja nie powiedzie się.The Parse method converts a string to a number and throws an exception if the conversion fails. TryParse Metoda konwertuje ciąg na liczbę, przypisuje numer do out argument i zwraca Boolean wartość, która wskazuje, czy konwersja powiodła się.The 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.

Podczas analizowania metody jawnie lub niejawenie używają NumberStyles wartości wyliczenia, aby ustalić, jakie elementy stylu (takie jak separatory grup i separator dziesiętny, symbol waluty) może być obecne w ciągu, jeśli operacja analizy się powiodła się.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. Jeśli NumberStyles wartość nie zostanie podana w wywołaniu metody, wartość domyślna to NumberStyles wartość, która obejmuje Float i AllowThousands flagi, które określa, że przeanalizowany ciąg może zawierać symbole grupy, separator dziesiętny, znaku minus, i znaki odstępu lub może być reprezentację liczby w zapisie wykładniczym.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.

Podczas analizowania metody, dodatkowo niejawnie lub jawnie za pomocą NumberFormatInfo obiekt, który definiuje określone symbole i wzorce, które mogą wystąpić w ciągu, który ma być analizowany.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. Jeśli NumberFormatInfo obiekt nie zostanie podany, wartość domyślna to NumberFormatInfo dla bieżącej kultury wątku.If a NumberFormatInfo object is not provided, the default is the NumberFormatInfo for the current thread culture. Aby uzyskać więcej informacji na temat analizy, zobacz poszczególne metody analizy, takie jak Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double), i 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).

Poniższy przykład ilustruje rodzaj wrażliwość na ustawienia kulturowe analizowanie ciągów.The following example illustrates the culture-sensitive nature of parsing strings. Próbuje przeanalizować składni ciągu, który zawiera tysiące separatory przy użyciu konwencji en US, fr-FR i niezmiennej kultury.It tries to parse a string that include thousands separators by using the conventions of the en-US, fr-FR, and invariant cultures. Ciąg, który zawiera przecinek jako separator grup i okres jako separatora dziesiętnego nie można przeanalizować w kultury fr-FR, a następnie ciąg z white space jako separator grup i przecinka jako separatora dziesiętnego kończy się niepowodzeniem do analizowania w en US i niezmiennej kultury.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)

Podczas analizowania zwykle odbywa się w dwóch kontekstów:Parsing generally occurs in two contexts:

  • Jako operacja, która jest przeznaczony do konwertowania danych wejściowych użytkownika na wartość liczbową.As an operation that is designed to convert user input into a numeric value.

  • Jako operacja, która została zaprojektowana Aby obustronnie konwertować wartość liczbową; oznacza to do deserializacji wartość liczbowa, która została wcześniej zserializowanym w formacie ciągu.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.

W poniższych sekcjach omówiono te dwie operacje bardziej szczegółowo.The following sections discuss these two operations in greater detail.

Analiza ciągów użytkownikaParsing user strings

Gdy są analizowanie ciągów liczbowych wprowadzane przez użytkownika, należy zawsze wystąpienia NumberFormatInfo obiekt, który odzwierciedla ustawienia kultury użytkownika.When you are parsing numeric strings input by the user, you should always instantiate a NumberFormatInfo object that reflects the user's cultural settings. Aby uzyskać informacje dotyczące tworzenia wystąpienia NumberFormatInfo obiekt, który odzwierciedla modyfikacje użytkownika, zobacz NumberFormatInfo i dane dynamiczne sekcji.For information about how to instantiate a NumberFormatInfo object that reflects user customizations, see the NumberFormatInfo and dynamic data section.

Poniższy przykład ilustruje różnicę między operacji analizowania, która odzwierciedla ustawienia kultury użytkownika oraz jedną, która nie ma.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. W tym przypadku domyślnej kultury systemu jest en US, ale ma zdefiniowany przez użytkownika "," jako separator dziesiętny i "." jako separator grup, w Panelu sterowania Region i język.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. Zazwyczaj te symbole zostały cofnięte w domyślnej kultury en US.Ordinarily, these symbols are reversed in the default en-US culture. Gdy użytkownik wpisuje ciąg, który odzwierciedla ustawienia użytkownika, a ten ciąg jest analizowany przy NumberFormatInfo obiektu odzwierciedlający ustawienia użytkownika (zastąpień), operacja analizowania zwraca odpowiedni wynik.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. Jednak, jeśli ciąg jest analizowany przy NumberFormatInfo obiekt, który odzwierciedla ustawienia kultury en US standard, pomyłki symbol separatora grupy przecinkami i zwraca niepoprawny wynik.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

Serializacja i deserializacja danych liczbowychSerializing and deserializing numeric data

Gdy dane liczbowe jest serializowany w formacie ciągu i później wykonać deserializacji i przeanalizować, ciągi powinien być wygenerowany i analizowane za pomocą Konwencji niezmiennej kultury.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. Operacji formatowania i analizy powinno nigdy nie odzwierciedlają konwencje określonej kultury.The formatting and parsing operations should never reflect the conventions of a specific culture. Jeśli używane są ustawienia specyficzne dla kultury, przenośność danych jest ściśle ograniczona. może być pomyślnie zdeserializowany tylko w wątku, którego ustawienia specyficzne dla kultury są identyczne z tymi wątku, na którym został wydany.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. W niektórych przypadkach oznacza to, że dane nie mogą jeszcze być pomyślnie zdeserializowany, w tym samym systemie, na którym został wydany.In some cases, this means that the data cannot even be successfully deserialized on the same system on which it was serialized.

W poniższym przykładzie pokazano, co może się zdarzyć, gdy zasada ta jest naruszona.The following example illustrates what can happen when this principle is violated. Zmiennoprzecinkowe wartości w tablicy są konwertowane na ciągi, gdy bieżący wątek używa ustawienia specyficzne dla kultury kultury en US.Floating-point values in an array are converted to strings when the current thread uses the culture-specific settings of the en-US culture. Dane, następnie jest analizowany przez wątek, który korzysta z ustawień specyficznych dla kultury kultury en-GB.The data is then parsed by a thread that uses the culture-specific settings of the en-GB culture. W tym przypadku mimo że każda operacja analizy się powiedzie, dane nie ma dwustronnej konwersji pomyślnie i nastąpi uszkodzenie danych.In this case, although each parsing operation succeeds, the data does not round-trip successfully and data corruption occurs. W innych przypadkach może się nie powieść operacji analizowania i FormatException zgłoszony wyjątek.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()

Inicjuje nowe wystąpienie zapisywalny NumberFormatInfo klasy, czyli niezależny od kultury (niezmiennej).Initializes a new writable instance of the NumberFormatInfo class that is culture-independent (invariant).

Właściwości

CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits

Pobiera lub ustawia liczbę miejsc dziesiętnych, do użycia w wartości waluty.Gets or sets the number of decimal places to use in currency values.

CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator

Pobiera lub ustawia ciąg używany jako separator dziesiętny w wartości waluty.Gets or sets the string to use as the decimal separator in currency values.

CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator

Pobiera lub ustawia ciąg oddzielający grupy cyfr z lewej strony separatora dziesiętnego w wartości waluty.Gets or sets the string that separates groups of digits to the left of the decimal in currency values.

CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes

Pobiera lub ustawia liczbę cyfr w każdej grupie na lewo od separatora dziesiętnego w wartości waluty.Gets or sets the number of digits in each group to the left of the decimal in currency values.

CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern

Pobiera lub ustawia wzorzec formatu wartości waluty z wartościami ujemnymi.Gets or sets the format pattern for negative currency values.

CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern

Pobiera lub ustawia wzorzec formatu dla liczb dodatnich wartości.Gets or sets the format pattern for positive currency values.

CurrencySymbol CurrencySymbol CurrencySymbol CurrencySymbol

Pobiera lub ustawia ciąg jest do wykorzystania jako symbol waluty.Gets or sets the string to use as the currency symbol.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Pobiera tylko do odczytu NumberFormatInfo , formatuje wartości na podstawie bieżącej kultury.Gets a read-only NumberFormatInfo that formats values based on the current culture.

DigitSubstitution DigitSubstitution DigitSubstitution DigitSubstitution

Pobiera lub ustawia wartość określającą sposób wyświetlania kształt cyfrę w graficznym interfejsie użytkownika.Gets or sets a value that specifies how the graphical user interface displays the shape of a digit.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Pobiera tylko do odczytu NumberFormatInfo obiekt niezależnych od kultury (niezmiennej).Gets a read-only NumberFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Pobiera wartość wskazującą, czy to NumberFormatInfo obiekt jest tylko do odczytu.Gets a value that indicates whether this NumberFormatInfo object is read-only.

NaNSymbol NaNSymbol NaNSymbol NaNSymbol

Pobiera lub ustawia ciąg, który reprezentuje wartość IEEE NaN (nieliczbową).Gets or sets the string that represents the IEEE NaN (not a number) value.

NativeDigits NativeDigits NativeDigits NativeDigits

Pobiera lub ustawia ciąg tablicę cyfr macierzystych odpowiednikiem Western cyfr od 0 do 9.Gets or sets a string array of native digits equivalent to the Western digits 0 through 9.

NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol

Pobiera lub ustawia ciąg, który reprezentuje ujemna nieskończoność.Gets or sets the string that represents negative infinity.

NegativeSign NegativeSign NegativeSign NegativeSign

Pobiera lub ustawia ciąg, który oznacza, że skojarzone liczba jest ujemna.Gets or sets the string that denotes that the associated number is negative.

NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits

Pobiera lub ustawia liczbę miejsc dziesiętnych, do użycia w wartości liczbowych.Gets or sets the number of decimal places to use in numeric values.

NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator

Pobiera lub ustawia ciąg używany jako separator dziesiętny wartości liczbowe.Gets or sets the string to use as the decimal separator in numeric values.

NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator

Pobiera lub ustawia ciąg oddzielający grupy cyfr z lewej strony separatora dziesiętnego w wartości liczbowych.Gets or sets the string that separates groups of digits to the left of the decimal in numeric values.

NumberGroupSizes NumberGroupSizes NumberGroupSizes NumberGroupSizes

Pobiera lub ustawia liczbę cyfr w każdej grupie na lewo od separatora dziesiętnego w wartości liczbowych.Gets or sets the number of digits in each group to the left of the decimal in numeric values.

NumberNegativePattern NumberNegativePattern NumberNegativePattern NumberNegativePattern

Pobiera lub ustawia wzorzec formatu dla wartości ujemnych liczbowych.Gets or sets the format pattern for negative numeric values.

PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits

Pobiera lub ustawia liczbę miejsc dziesiętnych, do użycia w wartości procentowe.Gets or sets the number of decimal places to use in percent values.

PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator

Pobiera lub ustawia ciąg używany jako separator dziesiętny w wartości procentowe.Gets or sets the string to use as the decimal separator in percent values.

PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator

Pobiera lub ustawia ciąg oddzielający grupy cyfr z lewej strony separatora dziesiętnego w wartości procentowe.Gets or sets the string that separates groups of digits to the left of the decimal in percent values.

PercentGroupSizes PercentGroupSizes PercentGroupSizes PercentGroupSizes

Pobiera lub ustawia liczbę cyfr w każdej grupie na lewo od separatora dziesiętnego w wartości procentowe.Gets or sets the number of digits in each group to the left of the decimal in percent values.

PercentNegativePattern PercentNegativePattern PercentNegativePattern PercentNegativePattern

Pobiera lub ustawia wzorzec formatu ujemna wartość procentowa.Gets or sets the format pattern for negative percent values.

PercentPositivePattern PercentPositivePattern PercentPositivePattern PercentPositivePattern

Pobiera lub ustawia wzorzec formatu dla wartości dodatnich procent.Gets or sets the format pattern for positive percent values.

PercentSymbol PercentSymbol PercentSymbol PercentSymbol

Pobiera lub ustawia ciąg jest do wykorzystania jako symbol procentu.Gets or sets the string to use as the percent symbol.

PerMilleSymbol PerMilleSymbol PerMilleSymbol PerMilleSymbol

Pobiera lub ustawia ciąg do użycia jako symbol promila.Gets or sets the string to use as the per mille symbol.

PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol

Pobiera lub ustawia ciąg, który reprezentuje nieskończoności dodatniej.Gets or sets the string that represents positive infinity.

PositiveSign PositiveSign PositiveSign PositiveSign

Pobiera lub ustawia ciąg, który oznacza, że skojarzone z nimi numery jest dodatni.Gets or sets the string that denotes that the associated number is positive.

Metody

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

Tworzy kopię pobieżną NumberFormatInfo obiektu.Creates a shallow copy of the NumberFormatInfo object.

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

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

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

Pobiera obiekt określonego typu, która udostępnia usługę numeru formatowania.Gets an object of the specified type that provides a number formatting service.

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

Służy jako domyślnej funkcji skrótu.Serves as the default hash function.

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

Pobiera NumberFormatInfo skojarzonego z określonym IFormatProvider.Gets the NumberFormatInfo associated with the specified IFormatProvider.

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

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

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

Tworzy płytką kopię bieżącego Object.Creates a shallow copy of the current Object.

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

Zwraca tylko do odczytu NumberFormatInfo otoki.Returns a read-only NumberFormatInfo wrapper.

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

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Inherited from Object)

Dotyczy

Zobacz też