NumberFormatInfo Klasa

Definicja

Zawiera informacje specyficzne dla kultury dotyczące formatowania i analizowania wartości liczbowych.

public ref class NumberFormatInfo sealed : IFormatProvider
public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider
public sealed class NumberFormatInfo : IFormatProvider
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
type NumberFormatInfo = class
    interface IFormatProvider
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements ICloneable, IFormatProvider
Dziedziczenie
NumberFormatInfo
Atrybuty
Implementuje

Przykłady

W poniższym przykładzie pokazano, jak pobrać obiekt dla odpowiedniego obiektu i użyć pobranego obiektu do zapytania o informacje o formatowaniu liczb NumberFormatInfo CultureInfo dla określonej kultury.

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

Klasa zawiera informacje specyficzne dla kultury, które są używane podczas formatowania i NumberFormatInfo analizowania wartości liczbowych. Te informacje obejmują symbol waluty, symbol dziesiętny, symbol separatora grupy oraz symbole dla znaków dodatnich i ujemnych.

Utworzenie wystąpienia obiektu NumberFormatInfo

Można utworzyć wystąpienia obiektu, który reprezentuje konwencje formatowania bieżącej kultury, niezmiennej kultury, określonej kultury NumberFormatInfo lub kultury neutralnej.

Utworzenie wystąpienia obiektu NumberFormatInfo dla bieżącej kultury

Obiekt dla bieżącej kultury można utworzyć na NumberFormatInfo jeden z następujących sposobów. W każdym przypadku zwracany obiekt NumberFormatInfo jest tylko do odczytu.

W poniższym przykładzie użyto tych trzech sposobów tworzenia obiektów reprezentujących konwencje NumberFormatInfo formatowania bieżącej kultury. Pobiera również wartość właściwości , aby zilustrować, że każdy IsReadOnly obiekt jest tylko do odczytu.

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żna utworzyć zapisywalny obiekt reprezentujący konwencje bieżącej kultury na NumberFormatInfo jeden z następujących sposobów:

Poniższy przykład ilustruje te dwa sposoby tworzenia wystąpienia obiektu i wyświetla wartość jego właściwości, aby zilustrować, że obiekt nie jest tylko NumberFormatInfo IsReadOnly do odczytu.

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

Pamiętaj, że Windows operacyjny umożliwia użytkownikowi zastąpienie niektórych wartości właściwości używanych w operacjach formatowania liczbowego i analizowania za pośrednictwem elementu Region i język w NumberFormatInfo Panel sterowania. Na przykład użytkownik, którego kultura to angielski (Stany Zjednoczone), może wybrać wyświetlanie wartości waluty jako 1,1 USD zamiast domyślnej wartości 1,1 USD. Obiekty NumberFormatInfo pobrane w sposób omówiony wcześniej wszystkie odzwierciedlają te zastąpienia użytkownika. Jeśli jest to niepożądane, można utworzyć obiekt, który nie odzwierciedla przesłonień użytkownika (i który jest również do odczytu/zapisu, a nie tylko do odczytu), wywołując konstruktor i podając wartość NumberFormatInfo CultureInfo.CultureInfo(String, Boolean) dla false useUserOverride argumentu. Poniższy przykład przedstawia ilustrację dla systemu, którego bieżąca kultura to angielski (Stany Zjednoczone) i którego symbol waluty został zmieniony z domyślnego $na USD.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      NumberFormatInfo nfi;

      culture = CultureInfo.CurrentCulture;
      nfi = culture.NumberFormat;
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}\n", culture.NumberFormat.CurrencySymbol);

      culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol);
   }
}
// The example displays the following output:
//       Culture Name:    en-US
//       User Overrides:  True
//       Currency Symbol: USD
//
//       Culture Name:    en-US
//       User Overrides:  False
//       Currency Symbol: $
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      culture = CultureInfo.CurrentCulture
      nfi = culture.NumberFormat
      Console.WriteLine("Culture Name:    {0}", culture.Name)
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride)
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol)
      Console.WriteLine()
            
      culture = New CultureInfo(CultureInfo.CurrentCulture.Name, False)
      Console.WriteLine("Culture Name:    {0}", culture.Name)
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride)
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol)
   End Sub
End Module
' The example displays the following output:
'       Culture Name:    en-US
'       User Overrides:  True
'       Currency Symbol: USD
'       
'       Culture Name:    en-US
'       User Overrides:  False
'       Currency Symbol: $

Jeśli właściwość CultureInfo.UseUserOverride jest ustawiona na true , właściwości , i są również pobierane z ustawień CultureInfo.DateTimeFormat CultureInfo.NumberFormat CultureInfo.TextInfo użytkownika. Jeśli ustawienia użytkownika są niezgodne z kulturą skojarzoną z obiektem (na przykład jeśli wybrany kalendarz nie jest jednym z kalendarzy wymienionych przez właściwość ), wyniki metod i wartości właściwości są CultureInfo OptionalCalendars niezdefiniowane.

Utworzenie wystąpienia obiektu NumberFormatInfo dla niezmiennej kultury

Niezmienna kultura reprezentuje kulturę, w której nie uwzględnia się ustawień kulturowych. Jest on oparty na języku angielskim, ale nie na żadnym konkretnym kraju/regionie w języku angielskim. Chociaż dane określonych kultur mogą być dynamiczne i mogą ulec zmianie w celu odzwierciedlenia nowych konwencji kulturowych lub preferencji użytkownika, dane niezmiennej kultury nie zmieniają się. Obiekt reprezentujący konwencje formatowania niezmiennej kultury może służyć do operacji formatowania, w których ciągi wynikowe nie powinny się NumberFormatInfo różnić w zależności od kultury.

Można utworzyć wystąpienia obiektu, który reprezentuje konwencje formatowania niezmiennej kultury NumberFormatInfo w następujący sposób:

W poniższym przykładzie użyto każdej z tych metod do wystąpienia obiektu reprezentującego NumberFormatInfo niezmienną kulturę. Następnie wskazuje, czy obiekt jest tylko do odczytu,

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 kultury

Specyficzna kultura reprezentuje język, który jest wypowiadany w określonym kraju/regionie. Na przykład en-US jest określoną kulturą, która reprezentuje język angielski mówiony w języku angielskim w języku Stany Zjednoczone, a en-CA to specyficzna kultura, która reprezentuje język angielski mówiony w Kanadzie. Można utworzyć wystąpienia obiektu, który reprezentuje konwencje formatowania określonej kultury NumberFormatInfo w następujący sposób:

W poniższym przykładzie użyto tych czterech sposobów, aby utworzyć obiekt, który odzwierciedla konwencje formatowania kultury NumberFormatInfo indonezyjskiej (Indonezyjska). Wskazuje również, czy każdy obiekt jest tylko do odczytu.

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 neutralnej

Kultura neutralna reprezentuje kulturę lub język, który jest niezależny od kraju/regionu. Jest to zazwyczaj element nadrzędny co najmniej jednej konkretnej kultury. Na przykład fr jest neutralną kulturą języka francuskiego i elementem nadrzędnym kultury fr-FR. Obiekt reprezentujący konwencje formatowania kultury neutralnej tworzy się w taki sam sposób, jak obiekt reprezentujący konwencje formatowania NumberFormatInfo NumberFormatInfo określonej kultury.

Uwaga

W wersji .NET Framework 3.5 i starszych próba pobrania obiektu, który odzwierciedla konwencje formatowania kultury neutralnej, NumberFormatInfo zgłasza NotSupportedException wyjątek.

Jednak ponieważ jest ona niezależna od określonego kraju/regionu, w kulturze neutralnej brakuje informacji o formatowaniu specyficznych dla kultury. Zamiast wypełniać obiekt wartościami ogólnymi, .NET Framework zwraca obiekt, który odzwierciedla konwencje formatowania określonej kultury, która jest obiektem podrzędnym NumberFormatInfo NumberFormatInfo kultury neutralnej. Na przykład obiekt neutralnej kultury en odzwierciedla konwencje formatowania kultury en-US, a obiekt kultury fr odzwierciedla konwencje formatowania kultury NumberFormatInfo NumberFormatInfo fr-FR.

Możesz użyć kodu podobnego do poniższego, aby określić, które konwencje formatowania określonej kultury reprezentuje każda kultura neutralna.

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

public class Example
{
   public static void Main()
   {
      // Get all the neutral cultures
      List<String> names = new List<String>();
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    culture => names.Add(culture.Name));
      names.Sort();
      foreach (var name in names) {
         // Ignore the invariant culture.
         if (name == "") continue;

         ListSimilarChildCultures(name);
      }
   }

   private static void ListSimilarChildCultures(string name)
   {
      // Create the neutral NumberFormatInfo object.
      NumberFormatInfo nfi = CultureInfo.GetCultureInfo(name).NumberFormat;
      // Retrieve all specific cultures of the neutral culture.
      CultureInfo[] cultures = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures),
                               culture => culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase));
      // Create an array of NumberFormatInfo properties
      PropertyInfo[] properties = typeof(NumberFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
      bool hasOneMatch = false;

      foreach (var ci in cultures) {
         bool match = true;
         // Get the NumberFormatInfo for a specific culture.
         NumberFormatInfo specificNfi = ci.NumberFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.
            if (prop.Name == "IsReadOnly") continue;

            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) {
               IList nList = (IList) prop.GetValue(nfi, null);
               IList sList = (IList) prop.GetValue(specificNfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
                  break;
               }

               for (int ctr = 0; ctr < nList.Count; ctr++) {
                  if (! nList[ctr].Equals(sList[ctr])) {
                     match = false;
                     break;
                  }
               }
            }
            else if (! prop.GetValue(specificNfi).Equals(prop.GetValue(nfi))) {
               match = false;
               break;
            }
         }
         if (match) {
            Console.WriteLine("NumberFormatInfo object for '{0}' matches '{1}'",
                                      name, ci.Name);
            hasOneMatch = true;
         }
      }
      if (! hasOneMatch)
         Console.WriteLine("NumberFormatInfo object for '{0}' --> No Match", name);

      Console.WriteLine();
   }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection

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

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

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

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

NumberFormatInfo i dane dynamiczne

Dane specyficzne dla kultury do formatowania wartości liczbowych dostarczonych przez klasę są dynamiczne, podobnie jak dane kulturowe NumberFormatInfo dostarczone przez CultureInfo klasę. Nie należy zakładać stabilności wartości dla obiektów, NumberFormatInfo które są skojarzone z określonymi CultureInfo obiektami. Tylko dane dostarczone przez niezmienną kulturę i skojarzony z nią NumberFormatInfo obiekt są stabilne. Inne dane mogą się zmieniać między sesjami aplikacji, a nawet w ramach jednej sesji, z następujących powodów:

  • Aktualizacje systemu. Preferencje kulturowe, takie jak symbol waluty lub formaty walut, zmieniają się wraz z czasem. W takim przypadku Windows Update obejmuje zmiany wartości NumberFormatInfo właściwości dla określonej kultury.

  • Kultury zastępcze. Klasa CultureAndRegionInfoBuilder może służyć do zastępowania danych istniejącej kultury.

  • Kaskadowe zmiany wartości właściwości. Wiele właściwości związanych z kulturą może ulec zmianie w czasie działania, co z kolei powoduje NumberFormatInfo zmianę danych. Na przykład bieżącą kulturę można zmienić programowo lub za pomocą akcji użytkownika. W takim przypadku obiekt zwrócony przez właściwość zmieni się na obiekt NumberFormatInfo CurrentInfo skojarzony z bieżącą kulturą.

  • Preferencje użytkownika. Użytkownicy aplikacji mogą zastąpić niektóre wartości skojarzone z bieżącą kulturą systemu za pomocą regionu i opcji języka w Panel sterowania. Na przykład użytkownicy mogą wybrać inny symbol waluty lub inny symbol separatora dziesiętnego. Jeśli właściwość CultureInfo.UseUserOverride jest ustawiona na wartość (wartość domyślna), właściwości obiektu są również pobierane true NumberFormatInfo z ustawień użytkownika.

Począwszy od .NET Framework 2.0, wszystkie właściwości obiektu, które można zastąpić przez użytkownika, są inicjowane NumberFormatInfo podczas tworzenia obiektu. Nadal istnieje możliwość niespójności, ponieważ ani tworzenie obiektu, ani proces zastępowania użytkownika nie jest niepodzielny, a odpowiednie wartości mogą ulec zmianie podczas tworzenia obiektu. Jednak te niespójności powinny być bardzo rzadkie.

Możesz kontrolować, czy przesłonięcia użytkownika są odzwierciedlane w obiektach NumberFormatInfo reprezentujących tę samą kulturę co bieżąca kultura. W poniższej tabeli wymieniono sposoby pobierania obiektu i wskazuje, czy wynikowy obiekt odzwierciedla NumberFormatInfo przesłonięcia użytkownika.

Źródło obiektu CultureInfo i NumberFormatInfo Odzwierciedla przesłonięcia użytkownika
CultureInfo.CurrentCulture.NumberFormat Właściwość Tak
NumberFormatInfo.CurrentInfo Właściwość Tak
Metoda CultureInfo.CreateSpecificCulture Tak
Metoda CultureInfo.GetCultureInfo Nie
CultureInfo(String) Konstruktor Tak
CultureInfo.CultureInfo(String, Boolean) Konstruktor Zależy od wartości useUserOverride parametru

O ile nie ma istotnego powodu, aby w inny sposób to zrobić, należy przestrzegać przesłonień użytkowników podczas używania obiektu w aplikacjach klienckich do formatowania i analizowania danych wejściowych użytkownika lub wyświetlania danych NumberFormatInfo liczbowych. W przypadku aplikacji serwerowych lub nienadzorowanych nie należy przestrzegać przesłonięcia użytkowników. Jeśli jednak obiekt jest używany jawnie lub niejawnie do utrwalania danych liczbowych w postaci ciągu, należy użyć obiektu, który odzwierciedla konwencje formatowania niezmiennej kultury, lub określić niestandardowy ciąg formatu liczbowego, który będzie używany niezależnie od NumberFormatInfo NumberFormatInfo kultury.

IFormatProvider, NumberformatInfo i formatowanie liczbowe

Obiekt NumberFormatInfo jest używany niejawnie lub jawnie we wszystkich operacjach formatowania liczbowego. Obejmują one wywołania następujących metod:

Wszystkie operacje formatowania liczbowego korzystają z IFormatProvider implementacji. Interfejs IFormatProvider zawiera pojedynczą metodę , GetFormat(Type) . Jest to metoda wywołania zwrotnego, która jest przekazywana do Type obiektu reprezentującego typ wymagany do podania informacji o formatowaniu. Metoda jest odpowiedzialna za zwracanie wystąpienia tego typu lub , jeśli nie może null dostarczyć wystąpienia typu. Ten .NET Framework dwie IFormatProvider implementacje formatowania liczb:

Jeśli implementacja nie zostanie jawnie określona dla metody formatowania, zostanie użyty obiekt zwrócony przez właściwość IFormatProvider CultureInfo CultureInfo.CurrentCulture reprezentującą bieżącą kulturę.

Poniższy przykład ilustruje relację między interfejsem a klasą w operacjach formatowania przez IFormatProvider NumberFormatInfo zdefiniowanie implementacji IFormatProvider niestandardowej. Metoda GetFormat wyświetla nazwę typu obiektu żądanego przez operację formatowania. Jeśli interfejs żąda NumberFormatInfo obiektu, ta metoda udostępnia NumberFormatInfo obiekt dla bieżącej kultury. Jak pokazują dane wyjściowe z przykładu, metoda żąda obiektu w celu podania informacji o formatowaniu, podczas gdy metoda żąda i obiekty, Decimal.ToString(IFormatProvider) NumberFormatInfo a także String.Format(IFormatProvider, String, Object[]) NumberFormatInfo DateTimeFormatInfo ICustomFormatter implementację.

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 implementacja nie jest jawnie określona w wywołaniu metody formatowania liczbowego, metoda wywołuje metodę , która zwraca obiekt, który IFormatProvider CultureInfo.CurrentCulture.GetFormat odpowiada NumberFormatInfo bieżącej kulturze.

Ciągi formatów i właściwości NumberFormatInfo

Każda operacja formatowania używa standardowego lub niestandardowego ciągu formatu liczbowego w celu uzyskania ciągu wynikowego z liczby. W niektórych przypadkach użycie ciągu formatu do tworzenia ciągu wynikowego jest jawne, jak w poniższym przykładzie. Ten kod wywołuje metodę w celu przekonwertowania wartości na liczbę różnych reprezentacji ciągów przy użyciu konwencji formatowania kultury Decimal.ToString(IFormatProvider) Decimal en-US.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formatStrings = { "C2", "E1", "F", "G3", "N",
                                 "#,##0.000", "0,000,000,000.0##" };
      CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
      Decimal[] values = { 1345.6538m, 1921651.16m };

      foreach (var value in values) {
         foreach (var formatString in formatStrings) {
            string resultString = value.ToString(formatString, culture);
            Console.WriteLine("{0,-18} -->  {1}", formatString, resultString);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       C2                 -->  $1,345.65
//       E1                 -->  1.3E+003
//       F                  -->  1345.65
//       G3                 -->  1.35E+03
//       N                  -->  1,345.65
//       #,##0.000          -->  1,345.654
//       0,000,000,000.0##  -->  0,000,001,345.654
//
//       C2                 -->  $1,921,651.16
//       E1                 -->  1.9E+006
//       F                  -->  1921651.16
//       G3                 -->  1.92E+06
//       N                  -->  1,921,651.16
//       #,##0.000          -->  1,921,651.160
//       0,000,000,000.0##  -->  0,001,921,651.16
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim formatStrings() As String = { "C2", "E1", "F", "G3", "N", 
                                        "#,##0.000", "0,000,000,000.0##" }
      Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim values() As Decimal = { 1345.6538d, 1921651.16d }
      
      For Each value In values
         For Each formatString In formatStrings
            Dim resultString As String = value.ToString(formatString, culture)
            Console.WriteLine("{0,-18} -->  {1}", formatString, resultString)
         Next
         Console.WriteLine()      
      Next   
   End Sub
End Module
' The example displays the following output:
'       C2                 -->  $1,345.65
'       E1                 -->  1.3E+003
'       F                  -->  1345.65
'       G3                 -->  1.35E+03
'       N                  -->  1,345.65
'       #,##0.000          -->  1,345.654
'       0,000,000,000.0##  -->  0,000,001,345.654
'       
'       C2                 -->  $1,921,651.16
'       E1                 -->  1.9E+006
'       F                  -->  1921651.16
'       G3                 -->  1.92E+06
'       N                  -->  1,921,651.16
'       #,##0.000          -->  1,921,651.160
'       0,000,000,000.0##  -->  0,001,921,651.16

W innych przypadkach użycie ciągu formatu jest niejawne. Na przykład w następującej metodzie metoda wywołuje metodę domyślną lub bez parametrów, wartość wystąpienia jest formatowana przy użyciu specyfikatora ogólnego formatu ("G") i konwencji bieżącej kultury, która w tym przypadku jest kulturą Decimal.ToString() Decimal en-US.

using System;

public class Example
{
   public static void Main()
   {
      Decimal[] values = { 1345.6538m, 1921651.16m };

      foreach (var value in values) {
         string resultString = value.ToString();
         Console.WriteLine(resultString);
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       1345.6538
//
//       1921651.16
Module Example
   Public Sub Main()
      Dim values() As Decimal = { 1345.6538d, 1921651.16d }
      
      For Each value In values
         Dim resultString As String = value.ToString()
         Console.WriteLine(resultString)
         Console.WriteLine()      
      Next   
   End Sub
End Module
' The example displays the following output:
'       1345.6538
'       
'       1921651.16

Każdy ciąg standardowego formatu liczbowego używa co najmniej jednej właściwości do określenia wzorca lub NumberFormatInfo symboli używanych w ciągu wynikowym. Podobnie każdy specyfikator niestandardowego formatu liczbowego z wyjątkiem symboli "0" i "#" wstawia symbole w ciągu wynikowym, które są definiowane przez NumberFormatInfo właściwości. W poniższej tabeli wymieniono specyfikatory standardowego i niestandardowego formatu liczbowego oraz skojarzone z nimi NumberFormatInfo właściwości. Aby zmienić wygląd ciągu wynikowego dla określonej kultury, zobacz sekcję Modyfikowanie właściwości NumberFormatInfo. Aby uzyskać szczegółowe informacje na temat używania tych specyfikatorów formatu, zobacz Ciągi standardowego formatu liczbowego i Niestandardowe ciągi formatu liczbowego.

Specyfikator formatu Skojarzone właściwości
"C" lub "c" (specyfikator formatu waluty) CurrencyDecimalDigits, aby zdefiniować domyślną liczbę cyfr ułamkowych.

CurrencyDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.

CurrencyGroupSeparator, aby zdefiniować separator grupy lub tysięcy.

CurrencyGroupSizes, aby zdefiniować rozmiary grup całkowitocowych.

CurrencyNegativePattern, aby zdefiniować wzorzec ujemnych wartości waluty.

CurrencyPositivePattern, aby zdefiniować wzorzec dodatnich wartości waluty.

CurrencySymbol, aby zdefiniować symbol waluty.

NegativeSign, aby zdefiniować symbol znaku ujemnego.
"D" lub "d" (specyfikator formatu dziesiętnego) NegativeSign, aby zdefiniować symbol znaku ujemnego.
"E" lub "e" (specyfikator formatu wykładniczego lub naukowego) NegativeSign, aby zdefiniować symbol znaku ujemnego w mantysie i wykładniku.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.

PositiveSign, aby zdefiniować symbol znaku dodatniego w wykładniku.
"F" lub "f" (specyfikator formatu stałego) NegativeSign, aby zdefiniować symbol znaku ujemnego.

NumberDecimalDigits, aby zdefiniować domyślną liczbę cyfr ułamkowych.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.
"G" lub "g" (ogólny specyfikator formatu) NegativeSign, aby zdefiniować symbol znaku ujemnego.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.

PositiveSign, aby zdefiniować symbol znaku dodatniego dla ciągów wynikowych w formacie wykładniczego.
"N" lub "n" (specyfikator formatu liczb) NegativeSign, aby zdefiniować symbol znaku ujemnego.

NumberDecimalDigits, aby zdefiniować domyślną liczbę cyfr ułamkowych.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.

NumberGroupSeparator, aby zdefiniować symbol separatora grupy (tysiące).

NumberGroupSizes, aby zdefiniować liczbę cyfr całkowitocowych w grupie.

NumberNegativePattern, aby zdefiniować format wartości ujemnych.
"P" lub "p" (specyfikator formatu procentu) NegativeSign, aby zdefiniować symbol znaku ujemnego.

PercentDecimalDigits, aby zdefiniować domyślną liczbę cyfr ułamkowych.

PercentDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.

PercentGroupSeparator, aby zdefiniować symbol separatora grupy.

PercentGroupSizes, aby zdefiniować liczbę cyfr całkowitocowych w grupie.

PercentNegativePattern, aby zdefiniować położenie symbolu procentu i symbolu ujemnego dla wartości ujemnych.

PercentPositivePattern, aby zdefiniować położenie symbolu procentu dla wartości dodatnich.

PercentSymbol, aby zdefiniować symbol procentu.
"R" lub "r" (specyfikator formatu rundy) NegativeSign, aby zdefiniować symbol znaku ujemnego.

NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.

PositiveSign, aby zdefiniować symbol znaku dodatniego w wykładniku.
"X" lub "x" (specyfikator formatu szesnastkowego) Brak.
"." (specyfikator formatu niestandardowego punktu dziesiętnego) NumberDecimalSeparator, aby zdefiniować symbol separatora dziesiętnego.
"," (specyfikator formatu niestandardowego separatora grup) NumberGroupSeparator, aby zdefiniować symbol separatora grupy (tysiące).
"%" (specyfikator formatu niestandardowego symbolu zastępczego procentu) PercentSymbol, aby zdefiniować symbol procentu.
"–" (specyfikator formatu niestandardowego symbolu zastępczego na milisekwę) PerMilleSymbol, aby zdefiniować symbol na milisekwę.
"E" (specyfikator formatu niestandardowego notacji wykładniczej) NegativeSign, aby zdefiniować symbol znaku ujemnego w mantysie i wykładniku.

PositiveSign, aby zdefiniować symbol znaku dodatniego w wykładniku.

Należy NumberFormatInfo pamiętać, że klasa zawiera NativeDigits właściwość określającą 10 podstawowych cyfr używanych przez określoną kulturę. Jednak właściwość nie jest używana w operacjach formatowania; W ciągu wynikowym są używane tylko podstawowe cyfry łaciński od 0 (U+0030) do 9 (U+0039). Ponadto dla Single wartości i Double , i NaN ciąg PositiveInfinity NegativeInfinity wynikowy NaNSymbol PositiveInfinitySymbol NegativeInfinitySymbol składa się wyłącznie z symboli zdefiniowanych odpowiednio przez właściwości , i .

Modyfikowanie właściwości NumberFormatInfo

Właściwości obiektu można zmodyfikować, aby dostosować NumberFormatInfo ciąg wynikowy wytwarzanych w operacji formatowania liczbowego. W tym celu:

  1. Utwórz kopię do odczytu/zapisu NumberFormatInfo obiektu, którego konwencje formatowania chcesz zmodyfikować. Aby uzyskać więcej informacji, zobacz sekcję Wystąpienia obiektu NumberFormatInfo.

  2. Zmodyfikuj właściwość lub właściwości, które są używane do tworzenia żądanego ciągu wynikowego. Aby uzyskać informacje na temat sposobu, w jaki metody formatowania używają właściwości do definiowania ciągów NumberFormatInfo wynikowych, zobacz sekcję Format strings and NumberFormatInfo properties (Ciągi formatu i właściwości NumberFormatInfo).

  3. Użyj obiektu NumberFormatInfo niestandardowego jako IFormatProvider argumentu w wywołaniach metod formatowania.

Uwaga

Zamiast dynamicznie modyfikować wartości właściwości kultury za każdym razem, gdy aplikacja jest uruchomiona, można użyć klasy do zdefiniowania kultury niestandardowej (kultury o unikatowej nazwie, która uzupełnia istniejące kultury) lub kultury zastępczej (która jest używana zamiast określonej CultureAndRegionInfoBuilder kultury).

W poniższych sekcjach przedstawiono kilka przykładów.

Modyfikowanie symbolu waluty i wzoru

W poniższym przykładzie zmodyfikuje obiekt reprezentujący konwencje formatowania NumberFormatInfo kultury en-US. Przypisuje ona symbol waluty ISO-4217 do właściwości i definiuje wzorzec wartości waluty, który składa się z symbolu waluty, po którym następuje spacja i CurrencySymbol wartość liczbowa.

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 identyfikacyjnego

Wiele krajowych numerów identyfikacyjnych składa się wyłącznie z cyfr, więc można je łatwo sformatować, modyfikując właściwości NumberFormatInfo obiektu. Na przykład numer ubezpieczenia społecznego w Stany Zjednoczone składa się z 9 cyfr ułożonych w następujący sposób: XXX-XX-XXXX . W poniższym przykładzie przyjęto założenie, że numery ubezpieczenia społecznego są przechowywane jako wartości całkowite i odpowiednio je formatują.

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 numerycznych

Analizowanie polega na przekonwertowaniu ciągu reprezentacji liczby na liczbę. Każdy typ liczbowy w .NET Framework zawiera dwie przeciążone metody analizowania: Parse i TryParse . Metoda konwertuje ciąg na liczbę i zgłasza wyjątek Parse w przypadku niepowodzenia konwersji. Metoda konwertuje ciąg na liczbę, przypisuje liczbę do argumentu i zwraca wartość, która TryParse out wskazuje, Boolean czy konwersja zakończyła się pomyślnie.

Metody analizowania niejawnie lub jawnie używają wartości wyliczenia, aby określić, które elementy stylu (takie jak separatory grup, separator dziesiętny lub symbol waluty) mogą być obecne w ciągu, jeśli operacja analizy zakończy się NumberStyles powodzeniem. Jeśli wartość nie zostanie podany w wywołaniu metody, wartością domyślną jest wartość, która zawiera flagi i , która określa, że analizowany ciąg może zawierać symbole grupy, separator dziesiętny, znak ujemny i znaki odstępu lub może być ciągiem reprezentacji liczby w notacji NumberStyles NumberStyles Float AllowThousands wykładniczej.

Metody analizowania również niejawnie lub jawnie używają obiektu definiującego określone symbole i wzorce, które mogą wystąpić w ciągu NumberFormatInfo do analizy. Jeśli obiekt NumberFormatInfo nie zostanie podany, wartością domyślną jest NumberFormatInfo wartość dla bieżącej kultury. Aby uzyskać więcej informacji na temat analizowania, zobacz poszczególne metody analizowania, takie jak Int16.Parse(String) , , , , i Int32.Parse(String, NumberStyles) Int64.Parse(String, IFormatProvider) Decimal.Parse(String, NumberStyles, IFormatProvider) Double.TryParse(String, Double) BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger) .

Poniższy przykład ilustruje wrażliwy na kulturę charakter analizowania ciągów. Próbuje on analizowanie ciągu, który zawiera separatory tysięcy, przy użyciu konwencji en-US, fr-FR i niezmiennych kultur. Ciąg, który zawiera przecinek jako separator grupy i kropka jako separator dziesiętny, nie może analizujeć w kulturze fr-FR, a ciąg z białym znakiem jako separatorem grupy i przecinkiem jako separatorem dziesiętnym nie może analizujeć w kulturach en-US i niezmiennych.

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)

Analizowanie zwykle odbywa się w dwóch kontekstach:

  • Operacja przeznaczona do konwertowania danych wejściowych użytkownika na wartość liczbową.

  • Jako operację, która jest przeznaczona do zaokrąglania wartości liczbowej; oznacza to, aby deserializować wartość liczbową, która została wcześniej serializowana jako ciąg.

W poniższych sekcjach bardziej szczegółowo omówiono te dwie operacje.

Analiza ciągów użytkownika

Podczas analizowania ciągów liczbowych wejściowych przez użytkownika należy zawsze utworzyć wystąpienia obiektu, który odzwierciedla NumberFormatInfo ustawienia kulturowe użytkownika. Aby uzyskać informacje na temat sposobu wystąpienia obiektu odzwierciedlającego dostosowania NumberFormatInfo użytkownika, zobacz sekcję NumberFormatInfo i dane dynamiczne.

Poniższy przykład ilustruje różnicę między operacją analizowania, która odzwierciedla ustawienia kulturowe użytkownika, a operacją, która nie jest. W tym przypadku domyślna kultura systemowa to en-US, ale użytkownik zdefiniuje znak "", jako symbol dziesiętny i znak "." jako separator grupy w języku Panel sterowania, Regionie i Języku. Zwykle te symbole są odwracane w domyślnej kulturze en-US. Gdy użytkownik wprowadza ciąg odzwierciedlający ustawienia użytkownika, a ciąg jest analizowany przez obiekt, który również odzwierciedla ustawienia użytkownika (przesłonięcia), operacja analizowania zwraca NumberFormatInfo prawidłowy wynik. Jednak gdy ciąg jest analizowany przez obiekt, który odzwierciedla standardowe ustawienia kulturowe en-US, myli symbol przecinka dla separatora grupy i zwraca NumberFormatInfo niepoprawny wynik.

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 liczbowych

Gdy dane liczbowe są serializowane w formacie ciągu, a następnie deserializowane i analizowane, ciągi powinny być generowane i analizowane przy użyciu konwencji niezmiennej kultury. Operacje formatowania i analizowania nigdy nie powinny odzwierciedlać konwencji określonej kultury. Jeśli są używane ustawienia specyficzne dla kultury, przenośność danych jest ściśle ograniczona; Można pomyślnie deserializacji tylko w wątku, którego ustawienia specyficzne dla kultury są identyczne z tych wątku, w którym został zseranizowany. W niektórych przypadkach oznacza to, że dane nie można nawet pomyślnie deserializacji w tym samym systemie, w którym została serializowana.

Poniższy przykład ilustruje, co może się zdarzyć, gdy ta zasada zostanie naruszona. Wartości zmiennoprzecinkowe w tablicy są konwertowane na ciągi, gdy bieżący wątek używa ustawień specyficznych dla kultury en-US. Dane są następnie analizowane przez wątek, który używa ustawień specyficznych dla kultury pt-BR kultury. W takim przypadku, mimo że każda operacja analizowania kończy się powodzeniem, dane nie są pomyślnie zaokrąglane i następuje uszkodzenie danych. W innych przypadkach operacja analizowania może się nie powieść i FormatException może zostać zgłoszony wyjątek.

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

public class Example
{
   public static void Main()
   {
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      PersistData();

      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("pt-BR");
      RestoreData();
   }

   private static void PersistData()
   {
      // Define an array of floating-point values.
      Double[] values = { 160325.972, 8631.16, 1.304e5, 98017554.385,
                          8.5938287084321676e94 };
      Console.WriteLine("Original values: ");
      foreach (var value in values)
         Console.WriteLine(value.ToString("R", CultureInfo.InvariantCulture));

      // Serialize an array of doubles to a file
      StreamWriter sw = new StreamWriter(@".\NumericData.bin");
      for (int ctr = 0; ctr < values.Length; ctr++) {
         sw.Write(values[ctr].ToString("R"));
         if (ctr < values.Length - 1) sw.Write("|");
      }
      sw.Close();
      Console.WriteLine();
   }

   private static void RestoreData()
   {
      // Deserialize the data
      StreamReader sr = new StreamReader(@".\NumericData.bin");
      String data = sr.ReadToEnd();
      sr.Close();

      String[] stringValues = data.Split('|');
      List<Double> newValueList = new List<Double>();

      foreach (var stringValue in stringValues) {
         try {
            newValueList.Add(Double.Parse(stringValue));
         }
         catch (FormatException) {
            newValueList.Add(Double.NaN);
         }
      }

      Console.WriteLine("Restored values:");
      foreach (var newValue in newValueList)
         Console.WriteLine(newValue.ToString("R", NumberFormatInfo.InvariantInfo));
   }
}
// The example displays the following output:
//       Original values:
//       160325.972
//       8631.16
//       130400
//       98017554.385
//       8.5938287084321671E+94
//
//       Restored values:
//       160325972
//       863116
//       130400
//       98017554385
//       8.5938287084321666E+110
Imports System.Collections.Generic
Imports System.Globalization
Imports System.IO
Imports System.Threading

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

      Console.WriteLine("Restored values:")
      For Each newValue In newValueList
         Console.WriteLine(newValue.ToString("R", NumberFormatInfo.InvariantInfo))
      Next
   End Sub
End Module
' The example displays the following output:
'       Original values:
'       160325.972
'       8631.16
'       130400
'       98017554.385
'       8.5938287084321671E+94
'       
'       Restored values:
'       160325972
'       863116
'       130400
'       98017554385
'       8.5938287084321666E+110

Konstruktory

NumberFormatInfo()

Inicjuje nowe zapisywalne wystąpienie klasy, która jest niezależna od kultury NumberFormatInfo (niezmienna).

Właściwości

CurrencyDecimalDigits

Pobiera lub ustawia liczbę miejsc dziesiętnych do użycia w wartościach waluty.

CurrencyDecimalSeparator

Pobiera lub ustawia ciąg do użycia jako separator dziesiętny w wartościach waluty.

CurrencyGroupSeparator

Pobiera lub ustawia ciąg, który oddziela grupy cyfr po lewej stronie wartości dziesiętnych w wartościach waluty.

CurrencyGroupSizes

Pobiera lub ustawia liczbę cyfr w każdej grupie z lewej strony wartości dziesiętnych w walucie.

CurrencyNegativePattern

Pobiera lub ustawia wzorzec formatu dla ujemnych wartości waluty.

CurrencyPositivePattern

Pobiera lub ustawia wzorzec formatu dla dodatnich wartości waluty.

CurrencySymbol

Pobiera lub ustawia ciąg do użycia jako symbol waluty.

CurrentInfo

Pobiera wartość tylko do NumberFormatInfo odczytu, która formatuje wartości na podstawie bieżącej kultury.

DigitSubstitution

Pobiera lub ustawia wartość, która określa sposób graficznego interfejsu użytkownika wyświetla kształt cyfry.

InvariantInfo

Pobiera obiekt tylko do NumberFormatInfo odczytu, który jest niezależny od kultury (niezmienny).

IsReadOnly

Pobiera wartość, która wskazuje, czy ten NumberFormatInfo obiekt jest tylko do odczytu.

NaNSymbol

Pobiera lub ustawia ciąg reprezentujący wartość IEEE NaN (nie liczbę).

NativeDigits

Pobiera lub ustawia tablicę ciągów cyfr natywnych równoważnych cyfrom zachodnim od 0 do 9.

NegativeInfinitySymbol

Pobiera lub ustawia ciąg reprezentujący nieskończoność ujemną.

NegativeSign

Pobiera lub ustawia ciąg oznaczający, że skojarzona liczba jest ujemna.

NumberDecimalDigits

Pobiera lub ustawia liczbę miejsc dziesiętnych do użycia w wartościach liczbowych.

NumberDecimalSeparator

Pobiera lub ustawia ciąg do użycia jako separator dziesiętny w wartościach liczbowych.

NumberGroupSeparator

Pobiera lub ustawia ciąg, który oddziela grupy cyfr z lewej strony liczby dziesiętnej w wartościach liczbowych.

NumberGroupSizes

Pobiera lub ustawia liczbę cyfr w każdej grupie z lewej strony dziesiętnych wartości liczbowych.

NumberNegativePattern

Pobiera lub ustawia wzorzec formatu dla ujemnych wartości liczbowych.

PercentDecimalDigits

Pobiera lub ustawia liczbę miejsc dziesiętnych do użycia w wartościach procentowych.

PercentDecimalSeparator

Pobiera lub ustawia ciąg do użycia jako separator dziesiętny w wartościach procentowych.

PercentGroupSeparator

Pobiera lub ustawia ciąg, który oddziela grupy cyfr z lewej strony wartości procentowych dziesiętnych.

PercentGroupSizes

Pobiera lub ustawia liczbę cyfr w każdej grupie z lewej strony wartości procentowych dziesiętnych.

PercentNegativePattern

Pobiera lub ustawia wzorzec formatu dla ujemnych wartości procentowych.

PercentPositivePattern

Pobiera lub ustawia wzorzec formatu dla dodatnich wartości procentowych.

PercentSymbol

Pobiera lub ustawia ciąg do użycia jako symbol procentu.

PerMilleSymbol

Pobiera lub ustawia ciąg do użycia jako symbol na milisekwę.

PositiveInfinitySymbol

Pobiera lub ustawia ciąg reprezentujący nieskończoność dodatnią.

PositiveSign

Pobiera lub ustawia ciąg oznaczający, że skojarzona liczba jest dodatnia.

Metody

Clone()

Tworzy pobiezną kopię NumberFormatInfo obiektu .

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetFormat(Type)

Pobiera obiekt określonego typu, który zapewnia usługę formatowania liczb.

GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetInstance(IFormatProvider)

Pobiera NumberFormatInfo skojarzoną z określonym IFormatProvider .

GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
ReadOnly(NumberFormatInfo)

Zwraca otokę tylko NumberFormatInfo do odczytu.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)

Dotyczy

Zobacz też