NumberFormatInfo Classe

Définition

Fournit des informations spécifiques à une culture pour la mise en forme et l'analyse des valeurs numériques.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
Héritage
NumberFormatInfo
Attributs
Implémente

Exemples

L’exemple suivant montre comment récupérer un NumberFormatInfo objet pour un objet correspondant CultureInfo et comment utiliser l’objet récupéré pour interroger les informations de mise en forme des nombres pour la culture particulière.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 '$'

Remarques

La NumberFormatInfo classe contient des informations propres à la culture qui sont utilisées lorsque vous mettez en forme et analysez des valeurs numériques.The NumberFormatInfo class contains culture-specific information that is used when you format and parse numeric values. Ces informations incluent le symbole monétaire, le symbole décimal, le symbole de séparateur de groupes et les symboles pour les signes positif et négatif.This information includes the currency symbol, the decimal symbol, the group separator symbol, and the symbols for positive and negative signs.

Instanciation d’un objet NumberFormatInfoInstantiating a NumberFormatInfo object

Vous pouvez instancier NumberFormatInfo un objet qui représente les conventions de mise en forme de la culture actuelle, de la culture dite indifférente, d’une culture spécifique ou d’une culture neutre.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.

Instanciation d’un objet NumberFormatInfo pour la culture actuelleInstantiating a NumberFormatInfo object for the current culture

Vous pouvez instancier NumberFormatInfo un objet pour la culture de thread actuelle de l’une des manières suivantes.You can instantiate a NumberFormatInfo object for the current thread culture in any of the following ways. Dans chaque cas, l’objet NumberFormatInfo retourné est en lecture seule.In each case, the returned NumberFormatInfo object is read-only.

L’exemple suivant utilise ces trois méthodes pour créer NumberFormatInfo des objets qui représentent les conventions de mise en forme de la culture actuelle.The following example uses these three ways to create NumberFormatInfo objects that represent the formatting conventions of the current culture. Elle récupère également la valeur de la IsReadOnly propriété pour illustrer que chaque objet est en lecture seule.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

Vous pouvez créer un objet NumberFormatInfo accessible en écriture qui représente les conventions de la culture de thread actuelle de l’une des manières suivantes :You can create a writable NumberFormatInfo object that represents the conventions of the current thread culture in any of the following ways:

L’exemple suivant illustre ces deux façons d’instancier un NumberFormatInfo objet et affiche la valeur de sa IsReadOnly propriété pour illustrer que l’objet n’est pas en lecture seule.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

Notez que le système d’exploitation Windows permet à l’utilisateur de remplacer certaines des NumberFormatInfo valeurs de propriété utilisées dans les opérations de mise en forme et d’analyse numériques par le biais de la région et de l’élément de langue dans le panneau de configuration.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. Par exemple, un utilisateur dont la culture est anglais (États-Unis) peut choisir d’afficher des valeurs monétaires de 1,1 USD au lieu de la valeur par défaut de $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. Les NumberFormatInfo objets récupérés de la manière décrite précédemment reflètent tous ces remplacements d’utilisateur.The NumberFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Si ce n’est pas souhaitable, vous pouvez créer NumberFormatInfo un objet qui ne reflète pas les substitutions de l’utilisateur (et qui est également en lecture/écriture plutôt que en lecture seule CultureInfo.CultureInfo(String, Boolean) ) en appelant le constructeur et en false spécifiant useUserOverride une valeur pour le 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. L’exemple suivant fournit une illustration pour un système dont la culture actuelle est l’anglais (États-Unis) et dont le symbole monétaire a été remplacé par la valeur par défaut de $ à 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: $

Si la CultureInfo.UseUserOverride propriété a la truevaleur, les propriétés CultureInfo.DateTimeFormat, CultureInfo.NumberFormatet CultureInfo.TextInfo sont également récupérées à partir des paramètres utilisateur.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. Si les paramètres utilisateur ne sont pas compatibles avec la culture associée à CultureInfo l’objet (par exemple, si le calendrier sélectionné n’est pas l’un des calendriers OptionalCalendars répertoriés par la propriété), les résultats des méthodes et les valeurs des propriétés sont non défini.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.

Instanciation d’un objet NumberFormatInfo pour la culture dite indifférenteInstantiating a NumberFormatInfo object for the invariant culture

La culture dite indifférente représente une culture qui est indépendante de la culture.The invariant culture represents a culture that is culture-insensitive. Il est basé sur la langue anglaise, mais pas sur un pays ou une région anglophone spécifique.It is based on the English language but not on any specific English-speaking country/region. Même si les données de cultures spécifiques peuvent être dynamiques et peuvent changer pour refléter de nouvelles conventions culturelles ou préférences utilisateur, les données de la culture dite indifférente ne changent pas.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. Un NumberFormatInfo objet qui représente les conventions de mise en forme de la culture dite indifférente peut être utilisé pour les opérations de mise en forme dans lesquelles les chaînes de résultat ne doivent pas varier selon la culture.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.

Vous pouvez instancier NumberFormatInfo un objet qui représente les conventions de mise en forme de la culture dite indifférente des manières suivantes :You can instantiate a NumberFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

L’exemple suivant utilise chacune de ces méthodes pour instancier NumberFormatInfo un objet qui représente la culture dite indifférente.The following example uses each of these methods to instantiate a NumberFormatInfo object that represents the invariant culture. Il indique ensuite si l’objet est en lecture seule,It then indicates whether the object is read-only,

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo nfi;
      
      nfi = System.Globalization.NumberFormatInfo.InvariantInfo;
      Console.WriteLine(nfi.IsReadOnly);               
      
      nfi = CultureInfo.InvariantCulture.NumberFormat;
      Console.WriteLine(nfi.IsReadOnly);               
      
      nfi = New NumberFormatInfo();
      Console.WriteLine(nfi.IsReadOnly);               
   }
}
// The example displays the following output:
//       True
//       True
//       False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nfi As NumberFormatInfo
      
      nfi = System.Globalization.NumberFormatInfo.InvariantInfo
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = CultureInfo.InvariantCulture.NumberFormat
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = New NumberFormatInfo()
      Console.WriteLine(nfi.IsReadOnly)               
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       False

Instanciation d’un objet NumberFormatInfo pour une culture spécifiqueInstantiating a NumberFormatInfo object for a specific culture

Une culture spécifique représente une langue parlée dans un pays ou une région spécifique.A specific culture represents a language that is spoken in a particular country/region. Par exemple, en-US est une culture spécifique qui représente la langue anglaise parlée dans le États-Unis, et en-CA est une culture spécifique qui représente la langue anglaise parlée au Canada.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. Vous pouvez instancier NumberFormatInfo un objet qui représente les conventions de mise en forme d’une culture spécifique des manières suivantes :You can instantiate a NumberFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

L’exemple suivant utilise ces quatre méthodes pour créer un NumberFormatInfo objet qui reflète les conventions de mise en forme de la culture indonésiennes (Indonésie).The following example uses these four ways to create a NumberFormatInfo object that reflects the formatting conventions of the Indonesian (Indonesia) culture. Il indique également si chaque objet est en lecture seule.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

Instanciation d’un objet NumberFormatInfo pour une culture neutreInstantiating a NumberFormatInfo object for a neutral culture

Une culture neutre représente une culture ou une langue indépendante d’un pays ou d’une région.A neutral culture represents a culture or language that is independent of a country/region. Il s’agit généralement du parent d’une ou de plusieurs cultures spécifiques.It is typically the parent of one or more specific cultures. Par exemple, fr est une culture neutre pour la langue française et le parent de la culture fr-FR.For example, fr is a neutral culture for the French language and the parent of the fr-FR culture. Vous créez un NumberFormatInfo objet qui représente les conventions de mise en forme d’une culture neutre de la même façon que vous NumberFormatInfo créez un objet qui représente les conventions de mise en forme d’une culture spécifique.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.

Notes

Dans et .NET Framework 3.5.NET Framework 3.5 les versions antérieures, la tentative de récupération NumberFormatInfo d’un objet qui reflète les conventions de mise en forme d’une culture NotSupportedException neutre lève une exception.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, trying to retrieve a NumberFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Toutefois, étant donné qu’il est indépendant d’un pays ou d’une région spécifique, une culture neutre ne contient pas d’informations de mise en forme propres à la culture.However, because it is independent of a specific country/region, a neutral culture lacks culture-specific formatting information. Au lieu de remplir NumberFormatInfo l’objet avec des valeurs génériques, le .NET Framework NumberFormatInfo retourne un objet qui reflète les conventions de mise en forme d’une culture spécifique qui est un enfant de la culture neutre.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. Par exemple, l' NumberFormatInfo objet pour la culture Neutralen reflète les conventions de mise en forme de la culture en-US, NumberFormatInfo et l’objet pour la culture fr reflète les conventions de mise en forme de la culture 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.

Vous pouvez utiliser du code semblable au suivant pour déterminer les conventions de mise en forme de la culture spécifique que chaque culture neutre représente.You can use code like the following to determine which specific culture's formatting conventions each neutral culture represents.

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

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

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

      foreach (var ci in cultures) {
         bool match = true;     
         // Get the NumberFormatInfo for a specific culture.
         NumberFormatInfo specificNfi = ci.NumberFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.     
            if (prop.Name == "IsReadOnly") continue;
            
            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) { 
               IList nList = (IList) prop.GetValue(nfi, null);
               IList sList = (IList) prop.GetValue(specificNfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
                  break;
               } 

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

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

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

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

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

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

NumberFormatInfo et Dynamic DataNumberFormatInfo and dynamic data

Les données spécifiques à la culture pour la mise en forme des valeurs NumberFormatInfo numériques fournies par la classe sont dynamiques, tout comme les données CultureInfo culturelles fournies par la classe.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. Vous ne devez pas faire d’hypothèses sur la stabilité des valeurs NumberFormatInfo des objets qui sont associés à CultureInfo des objets particuliers.You should not make any assumptions about the stability of values for NumberFormatInfo objects that are associated with particular CultureInfo objects. Seules les données fournies par la culture dite indifférente et NumberFormatInfo son objet associé sont stables.Only the data provided by the invariant culture and its associated NumberFormatInfo object is stable. D’autres données peuvent changer entre les sessions d’application, ou même au cours d’une seule session, pour les raisons suivantes :Other data can change between application sessions, or even within a single session, for the following reasons:

  • Mises à jour du système.System updates. Les préférences culturelles, telles que le symbole monétaire ou les formats monétaires changent au fil du temps.Cultural preferences such as the currency symbol or currency formats change over time. Dans ce cas, Windows Update comprend les modifications apportées à la NumberFormatInfo valeur de propriété pour une culture particulière.When this happens, Windows Update includes changes to the NumberFormatInfo property value for a particular culture.

  • Cultures de remplacement.Replacement cultures. La CultureAndRegionInfoBuilder classe peut être utilisée pour remplacer les données d’une culture existante.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Modifications en cascade des valeurs de propriété.Cascading changes to property values. Un certain nombre de propriétés liées à la culture peuvent changer au moment de l’exécution, ce qui NumberFormatInfo entraîne la modification des données.A number of culture-related properties can change at run time, which, in turn, causes NumberFormatInfo data to change. Par exemple, la culture actuelle peut être modifiée par programmation ou par le biais de l’action de l’utilisateur.For example, the current culture can be changed either programmatically or through user action. Dans ce cas, l' NumberFormatInfo objet retourné par la CurrentInfo propriété devient un objet associé à la culture actuelle.When this happens, the NumberFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture.

  • Préférences de l’utilisateur.User preferences. Les utilisateurs de votre application peuvent remplacer certaines des valeurs associées à la culture système actuelle par le biais des options régionales et linguistiques du panneau de configuration.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. Par exemple, les utilisateurs peuvent choisir un autre symbole monétaire ou un symbole de séparateur décimal différent.For example, users might choose a different currency symbol or a different decimal separator symbol. Si la CultureInfo.UseUserOverride propriété est définie sur true (sa valeur par défaut), les propriétés de NumberFormatInfo l’objet sont également récupérées à partir des paramètres utilisateur.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.

À partir de la .NET Framework 2,0, toutes les propriétés substituables par l' NumberFormatInfo utilisateur d’un objet sont initialisées lors de la création de l’objet.Starting with the .NET Framework 2.0, all user-overridable properties of a NumberFormatInfo object are initialized when the object is created. Il existe toujours une possibilité d’incohérence, car ni la création d’objet, ni le processus de remplacement de l’utilisateur ne sont atomiques, et les valeurs pertinentes peuvent changer pendant la création de l’objet.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. Toutefois, ces incohérences doivent être extrêmement rares.However, these inconsistencies should be extremely rare.

Vous pouvez contrôler si les substitutions de l’utilisateur sont NumberFormatInfo reflétées dans les objets qui représentent la même culture que la culture du thread en cours.You can control whether user overrides are reflected in NumberFormatInfo objects that represent the same culture as the current thread culture. Le tableau suivant répertorie les façons dont un NumberFormatInfo objet peut être récupéré et indique si l’objet résultant reflète les substitutions de l’utilisateur.The following table lists the ways in which a NumberFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Source des objets CultureInfo et NumberFormatInfoSource of CultureInfo and NumberFormatInfo object Reflète les remplacements de l’utilisateurReflects user overrides
PropriétéCultureInfo.CurrentCulture.NumberFormatCultureInfo.CurrentCulture.NumberFormat property OuiYes
PropriétéNumberFormatInfo.CurrentInfoNumberFormatInfo.CurrentInfo property OuiYes
Méthode CultureInfo.CreateSpecificCultureCultureInfo.CreateSpecificCulture method OuiYes
Méthode CultureInfo.GetCultureInfoCultureInfo.GetCultureInfo method NonNo
Constructeur CultureInfo(String)CultureInfo(String) constructor OuiYes
Constructeur CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Dépend de la valeur useUserOverride du paramètreDepends on value of useUserOverride parameter

À moins qu’il y ait une raison impérieuse de le faire autrement, vous devez respecter les remplacements d’utilisateur NumberFormatInfo lorsque vous utilisez l’objet dans les applications clientes pour mettre en forme et analyser l’entrée d’utilisateur ou pour afficher des données numériques.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. Pour les applications serveur ou les applications sans assistance, vous ne devez pas respecter les remplacements de l’utilisateur.For server applications or unattended applications, you should not respect user overrides. Toutefois, si vous utilisez l' NumberFormatInfo objet de manière explicite ou implicite pour conserver les données numériques sous forme de chaîne, vous devez utiliser un NumberFormatInfo objet qui reflète les conventions de mise en forme de la culture dite indifférente, ou vous devez spécifier un chaîne de format numérique personnalisée que vous utilisez quelle que soit la culture.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.

Mise en forme de IFormatProvider, NumberFormatInfo et numériqueIFormatProvider, NumberFormatInfo, and numeric formatting

Un NumberFormatInfo objet est utilisé implicitement ou explicitement dans toutes les opérations de mise en forme numérique.A NumberFormatInfo object is used implicitly or explicitly in all numeric formatting operations. Il s’agit notamment des appels aux méthodes suivantes :These include calls to the following methods:

Toutes les opérations de mise en forme numérique utilisent IFormatProvider une implémentation.All numeric formatting operations make use of an IFormatProvider implementation. L' IFormatProvider interface comprend une seule méthode, GetFormat(Type).The IFormatProvider interface includes a single method, GetFormat(Type). Il s’agit d’une méthode de rappel qui Type reçoit un objet qui représente le type nécessaire pour fournir des informations de mise en forme.This is a callback method that is passed a Type object that represents the type needed to provide formatting information. La méthode est chargée de retourner une instance de ce type ou null, si elle ne peut pas fournir une instance du type.The method is responsible for returning either an instance of that type or null, if it cannot provide an instance of the type. L' .NET Framework fournit deux IFormatProvider implémentations pour la mise en forme des nombres :The .NET Framework provides two IFormatProvider implementations for formatting numbers:

Si une IFormatProvider implémentation n’est pas fournie explicitement à une méthode de mise en CultureInfo forme, un objet CultureInfo.CurrentCulture retourné par la propriété qui représente la culture du thread actuel est utilisé.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.

L’exemple suivant illustre la relation entre l' IFormatProvider interface et la NumberFormatInfo classe dans les opérations de mise en forme en définissant une implémentation personnalisée IFormatProvider .The following example illustrates the relationship between the IFormatProvider interface and the NumberFormatInfo class in formatting operations by defining a custom IFormatProvider implementation. Sa GetFormat méthode affiche le nom de type de l’objet demandé par l’opération de mise en forme.Its GetFormat method displays the type name of the object requested by the formatting operation. Si l’interface demande un NumberFormatInfo objet, cette méthode fournit l' NumberFormatInfo objet pour la culture de thread actuelle.If the interface is requesting a NumberFormatInfo object, this method provides the NumberFormatInfo object for the current thread culture. Comme le montre la sortie de l’exemple, Decimal.ToString(IFormatProvider) la méthode demande NumberFormatInfo à un objet de fournir des informations de mise en forme NumberFormatInfo , tandis que la méthode ICustomFormatter demande les String.Format(IFormatProvider, String, Object[]) objets et DateTimeFormatInfo , ainsi qu’un déploiement.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

Si une IFormatProvider implémentation n’est pas fournie explicitement dans un appel de méthode de mise en forme numérique, CultureInfo.CurrentCulture.GetFormat la méthode appelle la méthode NumberFormatInfo , qui retourne l’objet qui correspond à la culture du thread actuel.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.

Chaînes de format et propriétés NumberFormatInfoFormat strings and NumberFormatInfo properties

Chaque opération de mise en forme utilise une chaîne de format numérique standard ou personnalisée pour produire une chaîne de résultat à partir d’un nombre.Every formatting operation uses either a standard or a custom numeric format string to produce a result string from a number. Dans certains cas, l’utilisation d’une chaîne de format pour produire une chaîne de résultat est explicite, comme dans l’exemple suivant.In some cases, the use of a format string to produce a result string is explicit, as in the following example. Ce code appelle la Decimal.ToString(IFormatProvider) méthode pour convertir une Decimal valeur en plusieurs représentations de chaîne différentes à l’aide des conventions de mise en forme de la culture 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

Dans d’autres cas, l’utilisation d’une chaîne de format est implicite.In other cases, the use of a format string is implicit. Par exemple, dans les appels de méthode suivants à la Decimal.ToString() méthode par défaut ou sans paramètre, la valeur de l' Decimal instance est mise en forme à l’aide du spécificateur de format général (« G ») et des conventions de la culture actuelle, qui dans ce cas est le culture 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

Chaque chaîne de format numérique standard utilise une ou NumberFormatInfo plusieurs propriétés pour déterminer le modèle ou les symboles utilisés dans la chaîne de résultat.Each standard numeric format string uses one or more NumberFormatInfo properties to determine the pattern or the symbols used in the result string. De même, chaque spécificateur de format numérique personnalisé sauf « 0 » et « # » insère des symboles dans la chaîne de résultat qui sont NumberFormatInfo définis par des propriétés.Similarly, each custom numeric format specifier except "0" and "#" insert symbols in the result string that are defined by NumberFormatInfo properties. Le tableau suivant répertorie les spécificateurs de format numériques standard et personnalisés, NumberFormatInfo ainsi que leurs propriétés associées.The following table lists the standard and custom numeric format specifiers and their associated NumberFormatInfo properties. Pour modifier l’apparence de la chaîne de résultat pour une culture particulière, consultez la section modification des propriétés NumberFormatInfo .To change the appearance of the result string for a particular culture, see the Modifying NumberFormatInfo properties section. Pour plus d’informations sur l’utilisation de ces spécificateurs de format, consultez chaînes de format numériques standard et chaînes de format numériques personnalisées.For details about the use of these format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

Spécificateur de formatFormat specifier Propriétés associéesAssociated properties
"C" ou "c" (spécificateur de format monétaire)"C" or "c" (currency format specifier) CurrencyDecimalDigits, pour définir le nombre par défaut de chiffres fractionnaires.CurrencyDecimalDigits, to define the default number of fractional digits.

CurrencyDecimalSeparator, pour définir le symbole de séparateur décimal.CurrencyDecimalSeparator, to define the decimal separator symbol.

CurrencyGroupSeparator, pour définir le groupe ou le séparateur des milliers.CurrencyGroupSeparator, to define the group or thousands separator.

CurrencyGroupSizes, pour définir les tailles des groupes intégraux.CurrencyGroupSizes, to define the sizes of integral groups.

CurrencyNegativePattern, pour définir le modèle de valeurs monétaires négatives.CurrencyNegativePattern, to define the pattern of negative currency values.

CurrencyPositivePattern, pour définir le modèle de valeurs monétaires positives.CurrencyPositivePattern, to define the pattern of positive currency values.

CurrencySymbol, pour définir le symbole monétaire.CurrencySymbol, to define the currency symbol.

NegativeSign, pour définir le symbole de signe négatif.NegativeSign, to define the negative sign symbol.
"D" ou "d" (spécificateur de format décimal)"D" or "d" (decimal format specifier) NegativeSign, pour définir le symbole de signe négatif.NegativeSign, to define the negative sign symbol.
"E" ou "e" (spécificateur de format exponentiel ou scientifique)"E" or "e" (exponential or scientific format specifier) NegativeSign, pour définir le symbole de signe négatif dans la mantisse et l’exposant.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, pour définir le symbole de signe positif dans l’exposant.PositiveSign, to define the positive sign symbol in the exponent.
"F" ou "f" (spécificateur de format à virgule fixe)"F" or "f" (fixed-point format specifier) NegativeSign, pour définir le symbole de signe négatif.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, pour définir le nombre par défaut de chiffres fractionnaires.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.NumberDecimalSeparator, to define the decimal separator symbol.
"G" ou "g" (spécificateur de format général)"G" or "g" (general format specifier) NegativeSign, pour définir le symbole de signe négatif.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, pour définir le symbole de signe positif pour les chaînes de résultat au format exponentiel.PositiveSign, to define the positive sign symbol for result strings in exponential format.
"N" ou "n" (spécificateur de format de nombre)"N" or "n" (number format specifier) NegativeSign, pour définir le symbole de signe négatif.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, pour définir le nombre par défaut de chiffres fractionnaires.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.NumberDecimalSeparator, to define the decimal separator symbol.

NumberGroupSeparator, pour définir le symbole du séparateur de groupes (milliers).NumberGroupSeparator, to define the group separator (thousands) symbol.

NumberGroupSizes, pour définir le nombre de chiffres intégraux dans un groupe.NumberGroupSizes, to define the number of integral digits in a group.

NumberNegativePattern, pour définir le format des valeurs négatives.NumberNegativePattern, to define the format of negative values.
"P" ou "p" (spécificateur de format pourcentage)"P" or "p" (percent format specifier) NegativeSign, pour définir le symbole de signe négatif.NegativeSign, to define the negative sign symbol.

PercentDecimalDigits, pour définir le nombre par défaut de chiffres fractionnaires.PercentDecimalDigits, to define the default number of fractional digits.

PercentDecimalSeparator, pour définir le symbole de séparateur décimal.PercentDecimalSeparator, to define the decimal separator symbol.

PercentGroupSeparator, pour définir le symbole de séparateur de groupes.PercentGroupSeparator, to define the group separator symbol.

PercentGroupSizes, pour définir le nombre de chiffres intégraux dans un groupe.PercentGroupSizes, to define the number of integral digits in a group.

PercentNegativePattern, pour définir l’emplacement du symbole de pourcentage et le symbole négatif pour les valeurs négatives.PercentNegativePattern, to define the placement of the percent symbol and the negative symbol for negative values.

PercentPositivePattern, pour définir l’emplacement du symbole de pourcentage pour les valeurs positives.PercentPositivePattern, to define the placement of the percent symbol for positive values.

PercentSymbol, pour définir le symbole de pourcentage.PercentSymbol, to define the percent symbol.
"R" ou "r" (spécificateur de format aller-retour)"R" or "r" (round-trip format specifier) NegativeSign, pour définir le symbole de signe négatif.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, pour définir le symbole de signe positif dans un exposant.PositiveSign, to define the positive sign symbol in an exponent.
"X" ou "x" (spécificateur de format hexadécimal)"X" or "x" (hexadecimal format specifier) Aucun.None.
"." (spécificateur de format personnalisé de virgule décimale)"." (decimal point custom format specifier) NumberDecimalSeparator, pour définir le symbole de séparateur décimal.NumberDecimalSeparator, to define the decimal separator symbol.
"," (spécificateur de format personnalisé de séparateur de groupes)"," (group separator custom format specifier) NumberGroupSeparator, pour définir le symbole de séparateur de groupe (milliers).NumberGroupSeparator, to define the group (thousands) separator symbol.
"%" (spécificateur de format personnalisé d’espace réservé de pourcentage)"%" (percentage placeholder custom format specifier) PercentSymbol, pour définir le symbole de pourcentage.PercentSymbol, to define the percent symbol.
"‰" (spécificateur de format personnalisé pour l’espace réservé mille)"‰" (per mille placeholder custom format specifier) PerMilleSymbol, pour définir le symbole « pour mille ».PerMilleSymbol, to define the per mille symbol.
"E" (spécificateur de format personnalisé de notation exponentielle)"E" (exponential notation custom format specifier) NegativeSign, pour définir le symbole de signe négatif dans la mantisse et l’exposant.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

PositiveSign, pour définir le symbole de signe positif dans l’exposant.PositiveSign, to define the positive sign symbol in the exponent.

Notez que la NumberFormatInfo classe comprend une NativeDigits propriété qui spécifie les 10 chiffres de base utilisés par une culture spécifique.Note that the NumberFormatInfo class includes a NativeDigits property that specifies the base 10 digits used by a specific culture. Toutefois, la propriété n’est pas utilisée dans les opérations de mise en forme ; Seuls les chiffres latins de base 0 (U + 0030) à 9 (U + 0039) sont utilisés dans la chaîne de résultat.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. En outre, pour Single les Double valeurs et NaNde PositiveInfinity, et NegativeInfinity, la chaîne de résultat se compose exclusivement des symboles définis par NaNSymbolles PositiveInfinitySymbolpropriétés, NegativeInfinitySymbol et. conséquence.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.

Modification des propriétés NumberFormatInfoModifying NumberFormatInfo properties

Vous pouvez modifier les propriétés d’un NumberFormatInfo objet pour personnaliser la chaîne de résultat produite dans une opération de mise en forme numérique.You can modify the properties of a NumberFormatInfo object to customize the result string produced in a numeric formatting operation. Pour ce faire :To do this:

  1. Créez une copie en lecture/écriture d' NumberFormatInfo un objet dont vous souhaitez modifier les conventions de mise en forme.Create a read/write copy of a NumberFormatInfo object whose formatting conventions you want to modify. Pour plus d’informations, consultez la section instanciation d’un objet NumberFormatInfo .For more information, see the Instantiating a NumberFormatInfo object section.

  2. Modifiez la ou les propriétés utilisées pour produire la chaîne de résultat souhaitée.Modify the property or properties that are used to produce the desired result string. Pour plus d’informations sur la façon dont NumberFormatInfo les méthodes de mise en forme utilisent des propriétés pour définir des chaînes de résultat, consultez la section chaînes de format et propriétés NumberFormatInfo .For information about how formatting methods use NumberFormatInfo properties to define result strings, see the Format strings and NumberFormatInfo properties section.

  3. Utilisez l’objet NumberFormatInfo personnalisé comme argument IFormatProvider dans les appels aux méthodes de mise en forme.Use the custom NumberFormatInfo object as the IFormatProvider argument in calls to formatting methods.

Notes

Au lieu de modifier dynamiquement les valeurs de propriété d’une culture chaque fois qu’une application est démarrée, CultureAndRegionInfoBuilder vous pouvez utiliser la classe pour définir une culture personnalisée (culture qui a un nom unique et qui complète les cultures existantes) ou un remplacement culture (une culture qui est utilisée à la place d’une culture spécifique).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).

Les sections suivantes fournissent des exemples.The following sections provide some examples.

Modification du symbole monétaire et du modèleModifying the currency symbol and pattern

L’exemple suivant modifie un NumberFormatInfo objet qui représente les conventions de mise en forme de la culture en-US.The following example modifies a NumberFormatInfo object that represents the formatting conventions of the en-US culture. Il affecte le symbole de devise ISO-4217 à la CurrencySymbol propriété et définit un modèle pour les valeurs monétaires qui se compose du symbole monétaire suivi d’un espace et d’une valeur numérique.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

Mise en forme d’un numéro d’identification nationalFormatting a national identification number

De nombreux numéros d’identification nationaux sont composés exclusivement de chiffres et peuvent donc être facilement mis en forme en modifiant NumberFormatInfo les propriétés d’un objet.Many national identification numbers consist exclusively of digits and so can easily be formatted by modifying the properties of a NumberFormatInfo object. Par exemple, un numéro de sécurité sociale du États-Unis se compose de 9 chiffres organisés comme suit XXX-XX-XXXX:.For example, a social security number in the United States consists of 9 digits arranged as follows: XXX-XX-XXXX. L’exemple suivant suppose que les numéros de sécurité sociale sont stockés sous forme de valeurs entières et les formate de manière appropriée.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

Analyse de chaînes numériquesParsing numeric strings

L’analyse implique la conversion de la représentation sous forme de chaîne d’un nombre en nombre.Parsing involves converting the string representation of a number to a number. Chaque type numérique dans le .NET Framework comprend deux méthodes d’analyse surchargées : Parse et TryParse.Each numeric type in the .NET Framework includes two overloaded parsing methods: Parse and TryParse. La Parse méthode convertit une chaîne en nombre et lève une exception en cas d’échec de la conversion.The Parse method converts a string to a number and throws an exception if the conversion fails. La TryParse méthode convertit une chaîne en nombre, assigne le nombre à un out argument et retourne une Boolean valeur qui indique si la conversion a réussi.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.

Les méthodes d’analyse utilisent implicitement ou explicitement une NumberStyles valeur d’énumération pour déterminer les éléments de style (tels que les séparateurs de groupe, un séparateur décimal ou un symbole monétaire) qui peuvent être présents dans une chaîne si l’opération d’analyse doit être effectuée.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. Si aucune NumberStyles valeur n’est fournie dans l’appel de méthode, la valeur par NumberStyles défaut est une valeur Float qui AllowThousands inclut les indicateurs et, qui spécifie que la chaîne analysée peut inclure des symboles de groupe, un séparateur décimal, un signe négatif, et les espaces blancs, ou il peut s’agir de la représentation sous forme de chaîne d’un nombre en notation exponentielle.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.

Les méthodes d’analyse utilisent également implicitement ou explicitement un NumberFormatInfo objet qui définit les symboles et les modèles spécifiques qui peuvent se produire dans la chaîne à analyser.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. Si aucun NumberFormatInfo objet n’est fourni, la valeur par défaut NumberFormatInfo est le pour la culture de thread actuelle.If a NumberFormatInfo object is not provided, the default is the NumberFormatInfo for the current thread culture. Pour plus d’informations sur l’analyse, consultez les méthodes d’analyse individuelles, telles Int16.Parse(String)que Int32.Parse(String, NumberStyles) Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider) Double.TryParse(String, Double),,,, BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger)et.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).

L’exemple suivant illustre la nature dépendante de la culture des chaînes d’analyse.The following example illustrates the culture-sensitive nature of parsing strings. Elle tente d’analyser une chaîne qui inclut des séparateurs de milliers en utilisant les conventions des cultures en-US, fr-FR et invariant.It tries to parse a string that include thousands separators by using the conventions of the en-US, fr-FR, and invariant cultures. Une chaîne qui comprend la virgule comme séparateur de groupes et le point comme séparateur décimal ne parvient pas à être analysée dans la culture fr-FR, et une chaîne avec un espace blanc comme séparateur de groupes et une virgule comme séparateur décimal ne parvient pas à être analysée dans les cultures en-US et invariants.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)

L’analyse se produit généralement dans deux contextes :Parsing generally occurs in two contexts:

  • En tant qu’opération conçue pour convertir une entrée d’utilisateur en une valeur numérique.As an operation that is designed to convert user input into a numeric value.

  • En tant qu’opération conçue pour effectuer un aller-retour d’une valeur numérique ; autrement dit, pour désérialiser une valeur numérique précédemment sérialisée en tant que chaîne.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.

Les sections suivantes décrivent ces deux opérations plus en détail.The following sections discuss these two operations in greater detail.

Analyse des chaînes utilisateurParsing user strings

Lorsque vous analysez des chaînes numériques entrées par l’utilisateur, vous devez toujours instancier NumberFormatInfo un objet qui reflète les paramètres culturels de l’utilisateur.When you are parsing numeric strings input by the user, you should always instantiate a NumberFormatInfo object that reflects the user's cultural settings. Pour plus d’informations sur la façon NumberFormatInfo d’instancier un objet qui reflète les personnalisations de l’utilisateur, consultez la section NumberFormatInfo et Dynamic Data .For information about how to instantiate a NumberFormatInfo object that reflects user customizations, see the NumberFormatInfo and dynamic data section.

L’exemple suivant illustre la différence entre une opération d’analyse qui reflète des paramètres culturels utilisateur et une autre qui ne le fait pas.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. Dans ce cas, la culture système par défaut est en-US, mais l’utilisateur a défini « , » comme symbole décimal et « . » comme séparateur de groupes dans le panneau de configuration, région et langue.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. En règle générale, ces symboles sont inversés dans la culture en-US par défaut.Ordinarily, these symbols are reversed in the default en-US culture. Lorsque l’utilisateur entre une chaîne qui reflète les paramètres utilisateur et que la chaîne est analysée par NumberFormatInfo un objet qui reflète également les paramètres utilisateur (substitutions), l’opération d’analyse retourne un résultat correct.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. Toutefois, lorsque la chaîne est analysée par un NumberFormatInfo objet qui reflète des paramètres culturels standard en-US, elle faut le symbole de virgule pour un séparateur de groupes et retourne un résultat incorrect.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

Sérialisation et désérialisation de données numériquesSerializing and deserializing numeric data

Lorsque les données numériques sont sérialisées au format de chaîne, puis désérialisées et analysées ultérieurement, les chaînes doivent être générées et analysées à l’aide des conventions de la culture dite indifférente.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. Les opérations de mise en forme et d’analyse ne doivent jamais refléter les conventions d’une culture spécifique.The formatting and parsing operations should never reflect the conventions of a specific culture. Si les paramètres spécifiques à la culture sont utilisés, la portabilité des données est strictement limitée ; Il peut être désérialisé avec succès uniquement sur un thread dont les paramètres spécifiques à la culture sont identiques à ceux du thread sur lequel il a été sérialisé.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. Dans certains cas, cela signifie que les données ne peuvent même pas être désérialisées avec succès sur le même système que celui sur lequel elles ont été sérialisées.In some cases, this means that the data cannot even be successfully deserialized on the same system on which it was serialized.

L’exemple suivant illustre ce qui peut se produire lorsque ce principe est violé.The following example illustrates what can happen when this principle is violated. Les valeurs à virgule flottante d’un tableau sont converties en chaînes lorsque le thread actuel utilise les paramètres spécifiques à la culture de la culture 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. Les données sont ensuite analysées par un thread qui utilise les paramètres spécifiques à la culture de la culture en-GB.The data is then parsed by a thread that uses the culture-specific settings of the en-GB culture. Dans ce cas, bien que chaque opération d’analyse réussisse, les données n’effectuent pas d’aller-retour et la corruption des données se produit.In this case, although each parsing operation succeeds, the data does not round-trip successfully and data corruption occurs. Dans d’autres cas, une opération d’analyse peut échouer FormatException et une exception peut être levée.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

Constructeurs

NumberFormatInfo()

Initialise une nouvelle instance accessible en écriture de la classe NumberFormatInfo qui est indépendante de la culture (dite indifférente).Initializes a new writable instance of the NumberFormatInfo class that is culture-independent (invariant).

Propriétés

CurrencyDecimalDigits

Obtient ou définit le nombre de décimales à utiliser dans les valeurs de devise.Gets or sets the number of decimal places to use in currency values.

CurrencyDecimalSeparator

Obtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs de devise.Gets or sets the string to use as the decimal separator in currency values.

CurrencyGroupSeparator

Obtient ou définit la chaîne qui sépare les groupes de chiffres à gauche du séparateur décimal dans les valeurs de devise.Gets or sets the string that separates groups of digits to the left of the decimal in currency values.

CurrencyGroupSizes

Obtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs de devise.Gets or sets the number of digits in each group to the left of the decimal in currency values.

CurrencyNegativePattern

Obtient ou définit le modèle de format pour les valeurs de devise négatives.Gets or sets the format pattern for negative currency values.

CurrencyPositivePattern

Obtient ou définit le modèle de format pour les valeurs de devise positives.Gets or sets the format pattern for positive currency values.

CurrencySymbol

Obtient ou définit la chaîne à utiliser comme symbole de devise.Gets or sets the string to use as the currency symbol.

CurrentInfo

Obtient un objet NumberFormatInfo en lecture seule qui met en forme des valeurs en fonction de la culture actuelle.Gets a read-only NumberFormatInfo that formats values based on the current culture.

DigitSubstitution

Obtient ou définit une valeur qui spécifie la façon dont l'interface graphique affiche la forme d'un chiffre.Gets or sets a value that specifies how the graphical user interface displays the shape of a digit.

InvariantInfo

Obtient un objet NumberFormatInfo en lecture seule indépendant de la culture (invariant).Gets a read-only NumberFormatInfo object that is culture-independent (invariant).

IsReadOnly

Obtient une valeur qui indique si cet objet NumberFormatInfo est en lecture seule.Gets a value that indicates whether this NumberFormatInfo object is read-only.

NaNSymbol

Obtient ou définit la chaîne représentant la valeur IEEE NaN (pas un nombre).Gets or sets the string that represents the IEEE NaN (not a number) value.

NativeDigits

Obtient ou définit un tableau de chaînes de chiffres natifs correspondant aux chiffres occidentaux de 0 à 9.Gets or sets a string array of native digits equivalent to the Western digits 0 through 9.

NegativeInfinitySymbol

Obtient ou définit la chaîne représentant l'infini négatif.Gets or sets the string that represents negative infinity.

NegativeSign

Obtient ou définit la chaîne indiquant que le nombre associé est négatif.Gets or sets the string that denotes that the associated number is negative.

NumberDecimalDigits

Obtient ou définit le nombre de décimales à utiliser dans les valeurs numériques.Gets or sets the number of decimal places to use in numeric values.

NumberDecimalSeparator

Obtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs numériques.Gets or sets the string to use as the decimal separator in numeric values.

NumberGroupSeparator

Obtient ou définit la chaîne qui sépare les groupes de chiffres à gauche du séparateur décimal dans les valeurs numériques.Gets or sets the string that separates groups of digits to the left of the decimal in numeric values.

NumberGroupSizes

Obtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs numériques.Gets or sets the number of digits in each group to the left of the decimal in numeric values.

NumberNegativePattern

Obtient ou définit le modèle de format pour les valeurs numériques négatives.Gets or sets the format pattern for negative numeric values.

PercentDecimalDigits

Obtient ou définit le nombre de décimales à utiliser dans les valeurs de pourcentage.Gets or sets the number of decimal places to use in percent values.

PercentDecimalSeparator

Obtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs de pourcentage.Gets or sets the string to use as the decimal separator in percent values.

PercentGroupSeparator

Obtient ou définit la chaîne qui sépare les groupes de chiffres à gauche du séparateur décimal dans les valeurs de pourcentage.Gets or sets the string that separates groups of digits to the left of the decimal in percent values.

PercentGroupSizes

Obtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs de pourcentage.Gets or sets the number of digits in each group to the left of the decimal in percent values.

PercentNegativePattern

Obtient ou définit le modèle de format pour les valeurs de pourcentage négatives.Gets or sets the format pattern for negative percent values.

PercentPositivePattern

Obtient ou définit le modèle de format pour les valeurs de pourcentage positives.Gets or sets the format pattern for positive percent values.

PercentSymbol

Obtient ou définit la chaîne à utiliser comme symbole de pourcentage.Gets or sets the string to use as the percent symbol.

PerMilleSymbol

Obtient ou définit la chaîne à utiliser comme symbole de "pour mille".Gets or sets the string to use as the per mille symbol.

PositiveInfinitySymbol

Obtient ou définit la chaîne représentant l'infini positif.Gets or sets the string that represents positive infinity.

PositiveSign

Obtient ou définit la chaîne indiquant que le nombre associé est positif.Gets or sets the string that denotes that the associated number is positive.

Méthodes

Clone()

Crée une copie superficielle de l'objet NumberFormatInfo.Creates a shallow copy of the NumberFormatInfo object.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetFormat(Type)

Obtient un objet du type spécifié qui fournit un service de mise en forme des nombres.Gets an object of the specified type that provides a number formatting service.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetInstance(IFormatProvider)

Obtient le NumberFormatInfo associé au IFormatProvider spécifié.Gets the NumberFormatInfo associated with the specified IFormatProvider.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ReadOnly(NumberFormatInfo)

Retourne un wrapper NumberFormatInfo en lecture seule.Returns a read-only NumberFormatInfo wrapper.

ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)

S’applique à

Voir aussi