NumberFormatInfo Classe

Définition

Fournit des informations spécifiques à une culture pour la mise en forme et l'analyse des valeurs numériques.

public ref class NumberFormatInfo sealed : IFormatProvider
public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider
public sealed class NumberFormatInfo : IFormatProvider
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
type NumberFormatInfo = class
    interface IFormatProvider
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements ICloneable, IFormatProvider
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.

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. 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.

Instanciation d’un objet NumberFormatInfo

Vous pouvez instancier un NumberFormatInfo 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.

Instanciation d’un objet NumberFormatInfo pour la culture actuelle

Vous pouvez instancier un NumberFormatInfo objet pour la culture actuelle de l’une des manières suivantes. Dans chaque cas, l' NumberFormatInfo objet retourné est en lecture seule.

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. Elle récupère également la valeur de la IsReadOnly propriété pour illustrer que chaque objet est en lecture seule.

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 NumberFormatInfo objet accessible en écriture qui représente les conventions de la culture actuelle de l’une des manières suivantes :

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.

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 des nombres par le biais de la région et de l’élément de langue dans le panneau de configuration. 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. Les NumberFormatInfo objets récupérés de la manière décrite précédemment reflètent tous ces remplacements d’utilisateur. Si ce n’est pas souhaitable, vous pouvez créer un NumberFormatInfo objet qui ne reflète pas les substitutions de l’utilisateur (et qui est également en lecture/écriture plutôt que en lecture seule) en appelant le CultureInfo.CultureInfo(String, Boolean) constructeur et en spécifiant une valeur false pour l' 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.

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

Instanciation d’un objet NumberFormatInfo pour la culture dite indifférente

La culture dite indifférente représente une culture qui est indépendante de la culture. Il est basé sur la langue anglaise, mais pas sur un pays ou une région anglophone spécifique. 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. 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.

Vous pouvez instancier un NumberFormatInfo objet qui représente les conventions de mise en forme de la culture dite indifférente des manières suivantes :

L’exemple suivant utilise chacune de ces méthodes pour instancier un NumberFormatInfo objet qui représente la culture dite indifférente. Il indique ensuite si l’objet est en lecture seule,

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écifique

Une culture spécifique représente une langue parlée dans un pays ou une région spécifique. 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. Vous pouvez instancier un NumberFormatInfo objet qui représente les conventions de mise en forme d’une culture spécifique des manières suivantes :

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). Il indique également si chaque objet est en lecture seule.

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 neutre

Une culture neutre représente une culture ou une langue indépendante d’un pays ou d’une région. Il s’agit généralement du parent d’une ou de plusieurs cultures spécifiques. Par exemple, fr est une culture neutre pour la langue française et le parent de la culture fr-FR. 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 créez un NumberFormatInfo objet qui représente les conventions de mise en forme d’une culture spécifique.

Notes

dans la .NET Framework 3,5 et les versions antérieures, la tentative de récupération d’un NumberFormatInfo objet qui reflète les conventions de mise en forme d’une culture neutre lève une 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. au lieu de remplir l' NumberFormatInfo objet avec des valeurs génériques, le .NET Framework retourne un NumberFormatInfo objet qui reflète les conventions de mise en forme d’une culture spécifique qui est un enfant de la culture neutre. Par exemple, l' NumberFormatInfo objet pour la culture Neutralen reflète les conventions de mise en forme de la culture en-US, et l' NumberFormatInfo objet pour la culture fr reflète les conventions de mise en forme de la culture FR-fr.

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.

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 Data

Les données spécifiques à la culture pour la mise en forme des valeurs numériques fournies par la NumberFormatInfo classe sont dynamiques, tout comme les données culturelles fournies par la CultureInfo classe. Vous ne devez pas faire d’hypothèses sur la stabilité des valeurs des NumberFormatInfo objets qui sont associés à des CultureInfo objets particuliers. Seules les données fournies par la culture dite indifférente et son NumberFormatInfo objet associé sont stables. D’autres données peuvent changer entre les sessions d’application, ou même au cours d’une seule session, pour les raisons suivantes :

  • Mises à jour du système. Les préférences culturelles, telles que le symbole monétaire ou les formats monétaires changent au fil du temps. dans ce cas, Windows Update comprend les modifications apportées à la NumberFormatInfo valeur de propriété pour une culture particulière.

  • Cultures de remplacement. La CultureAndRegionInfoBuilder classe peut être utilisée pour remplacer les données d’une culture existante.

  • Modifications en cascade des valeurs de propriété. Un certain nombre de propriétés liées à la culture peuvent changer au moment de l’exécution, ce qui entraîne la NumberFormatInfo modification des données. Par exemple, la culture actuelle peut être modifiée par programmation ou par le biais de l’action de l’utilisateur. Dans ce cas, l' NumberFormatInfo objet retourné par la CurrentInfo propriété devient un objet associé à la culture actuelle.

  • Préférences de l’utilisateur. 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. Par exemple, les utilisateurs peuvent choisir un autre symbole monétaire ou un symbole de séparateur décimal différent. Si la CultureInfo.UseUserOverride propriété est définie sur true (sa valeur par défaut), les propriétés de l' NumberFormatInfo objet sont également récupérées à partir des paramètres utilisateur.

à partir de la .NET Framework 2,0, toutes les propriétés substituables par l’utilisateur d’un NumberFormatInfo objet sont initialisées lors de la création de l’objet. 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. Toutefois, ces incohérences doivent être extrêmement rares.

Vous pouvez contrôler si les substitutions de l’utilisateur sont reflétées dans les NumberFormatInfo objets qui représentent la même culture que la culture actuelle. 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.

Source des objets CultureInfo et NumberFormatInfo Reflète les remplacements de l’utilisateur
PropriétéCultureInfo.CurrentCulture.NumberFormat Oui
PropriétéNumberFormatInfo.CurrentInfo Oui
Méthode CultureInfo.CreateSpecificCulture Oui
Méthode CultureInfo.GetCultureInfo Non
Constructeur CultureInfo(String) Oui
Constructeur CultureInfo.CultureInfo(String, Boolean) Dépend de la valeur du useUserOverride paramètre

À moins qu’il y ait une raison impérieuse de le faire autrement, vous devez respecter les remplacements d’utilisateur lorsque vous utilisez l' NumberFormatInfo objet dans les applications clientes pour mettre en forme et analyser l’entrée d’utilisateur ou pour afficher des données numériques. Pour les applications serveur ou les applications sans assistance, vous ne devez pas respecter les remplacements de l’utilisateur. 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 une chaîne de format numérique personnalisée que vous utilisez quelle que soit la culture.

Mise en forme de IFormatProvider, NumberFormatInfo et numérique

Un NumberFormatInfo objet est utilisé implicitement ou explicitement dans toutes les opérations de mise en forme numérique. Il s’agit notamment des appels aux méthodes suivantes :

Toutes les opérations de mise en forme numérique utilisent une IFormatProvider implémentation. L' IFormatProvider interface comprend une seule méthode, GetFormat(Type) . Il s’agit d’une méthode de rappel qui reçoit un Type objet qui représente le type nécessaire pour fournir des informations de mise en forme. 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. l' .NET Framework fournit deux IFormatProvider implémentations pour la mise en forme des nombres :

Si une IFormatProvider implémentation n’est pas fournie explicitement à une méthode de mise en forme, un CultureInfo objet retourné par la CultureInfo.CurrentCulture propriété qui représente la culture actuelle est utilisé.

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 IFormatProvider implémentation personnalisée. Sa GetFormat méthode affiche le nom de type de l’objet demandé par l’opération de mise en forme. Si l’interface demande un NumberFormatInfo objet, cette méthode fournit l' NumberFormatInfo objet pour la culture actuelle. Comme le montre la sortie de l’exemple, la Decimal.ToString(IFormatProvider) méthode demande NumberFormatInfo à un objet de fournir des informations de mise en forme, tandis que la String.Format(IFormatProvider, String, Object[]) méthode demande des objets, ainsi qu' NumberFormatInfo DateTimeFormatInfo une ICustomFormatter implémentation.

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, la méthode appelle la CultureInfo.CurrentCulture.GetFormat méthode, qui retourne l' NumberFormatInfo objet qui correspond à la culture actuelle.

Chaînes de format et propriétés NumberFormatInfo

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. 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. 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.

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. Par exemple, dans les appels de méthode suivants à la méthode par défaut ou sans paramètre Decimal.ToString() , 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 la culture en-US.

using System;

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

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

Chaque chaîne de format numérique standard utilise une ou plusieurs NumberFormatInfo Propriétés pour déterminer le modèle ou les symboles utilisés dans la chaîne de résultat. 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 définis par des NumberFormatInfo Propriétés. Le tableau suivant répertorie les spécificateurs de format numériques standard et personnalisés, ainsi que leurs NumberFormatInfo propriétés associées. 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 . 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.

Spécificateur de format Propriétés associées
"C" ou "c" (spécificateur de format monétaire) CurrencyDecimalDigits, pour définir le nombre par défaut de chiffres fractionnaires.

CurrencyDecimalSeparator, pour définir le symbole de séparateur décimal.

CurrencyGroupSeparator, pour définir le groupe ou le séparateur des milliers.

CurrencyGroupSizes, pour définir les tailles des groupes intégraux.

CurrencyNegativePattern, pour définir le modèle de valeurs monétaires négatives.

CurrencyPositivePattern, pour définir le modèle de valeurs monétaires positives.

CurrencySymbol, pour définir le symbole monétaire.

NegativeSign, pour définir le symbole de signe négatif.
"D" ou "d" (spécificateur de format décimal) NegativeSign, pour définir le symbole de signe négatif.
"E" ou "e" (spécificateur de format exponentiel ou scientifique) NegativeSign, pour définir le symbole de signe négatif dans la mantisse et l’exposant.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.

PositiveSign, pour définir le symbole de signe positif dans l’exposant.
"F" ou "f" (spécificateur de format à virgule fixe) NegativeSign, pour définir le symbole de signe négatif.

NumberDecimalDigits, pour définir le nombre par défaut de chiffres fractionnaires.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.
"G" ou "g" (spécificateur de format général) NegativeSign, pour définir le symbole de signe négatif.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.

PositiveSign, pour définir le symbole de signe positif pour les chaînes de résultat au format exponentiel.
"N" ou "n" (spécificateur de format de nombre) NegativeSign, pour définir le symbole de signe négatif.

NumberDecimalDigits, pour définir le nombre par défaut de chiffres fractionnaires.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.

NumberGroupSeparator, pour définir le symbole du séparateur de groupes (milliers).

NumberGroupSizes, pour définir le nombre de chiffres intégraux dans un groupe.

NumberNegativePattern, pour définir le format des valeurs négatives.
"P" ou "p" (spécificateur de format pourcentage) NegativeSign, pour définir le symbole de signe négatif.

PercentDecimalDigits, pour définir le nombre par défaut de chiffres fractionnaires.

PercentDecimalSeparator, pour définir le symbole de séparateur décimal.

PercentGroupSeparator, pour définir le symbole de séparateur de groupes.

PercentGroupSizes, pour définir le nombre de chiffres intégraux dans un groupe.

PercentNegativePattern, pour définir l’emplacement du symbole de pourcentage et le symbole négatif pour les valeurs négatives.

PercentPositivePattern, pour définir l’emplacement du symbole de pourcentage pour les valeurs positives.

PercentSymbol, pour définir le symbole de pourcentage.
"R" ou "r" (spécificateur de format aller-retour) NegativeSign, pour définir le symbole de signe négatif.

NumberDecimalSeparator, pour définir le symbole de séparateur décimal.

PositiveSign, pour définir le symbole de signe positif dans un exposant.
"X" ou "x" (spécificateur de format hexadécimal) Aucun.
"." (spécificateur de format personnalisé de virgule décimale) NumberDecimalSeparator, pour définir le symbole de séparateur décimal.
"," (spécificateur de format personnalisé de séparateur de groupes) NumberGroupSeparator, pour définir le symbole de séparateur de groupe (milliers).
"%" (spécificateur de format personnalisé d’espace réservé de pourcentage) PercentSymbol, pour définir le symbole de pourcentage.
"‰" (spécificateur de format personnalisé pour l’espace réservé mille) PerMilleSymbol, pour définir le symbole « pour mille ».
"E" (spécificateur de format personnalisé de notation exponentielle) NegativeSign, pour définir le symbole de signe négatif dans la mantisse et l’exposant.

PositiveSign, pour définir le symbole de signe positif dans l’exposant.

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. 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. En outre, pour Single Double les valeurs et de, NaN PositiveInfinity et NegativeInfinity , la chaîne de résultat se compose exclusivement des symboles définis par NaNSymbol les PositiveInfinitySymbol Propriétés, et NegativeInfinitySymbol , respectivement.

Modification des propriétés NumberFormatInfo

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. Pour ce faire :

  1. Créez une copie en lecture/écriture d’un NumberFormatInfo objet dont vous souhaitez modifier les conventions de mise en forme. Pour plus d’informations, consultez la section instanciation d’un objet NumberFormatInfo .

  2. Modifiez la ou les propriétés utilisées pour produire la chaîne de résultat souhaitée. Pour plus d’informations sur la façon dont les méthodes de mise en forme utilisent des NumberFormatInfo Propriétés pour définir des chaînes de résultat, consultez la section chaînes de format et propriétés NumberFormatInfo .

  3. Utilisez l' NumberFormatInfo objet personnalisé comme IFormatProvider argument dans les appels aux méthodes de mise en forme.

Notes

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

Les sections suivantes fournissent des exemples.

Modification du symbole monétaire et du modèle

L’exemple suivant modifie un NumberFormatInfo objet qui représente les conventions de mise en forme de la culture en-US. 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.

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 national

De nombreux numéros d’identification nationaux sont composés exclusivement de chiffres et peuvent donc être facilement mis en forme en modifiant les propriétés d’un NumberFormatInfo objet. Par exemple, un numéro de sécurité sociale du États-Unis se compose de 9 chiffres organisés comme suit : 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.

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ériques

L’analyse implique la conversion de la représentation sous forme de chaîne d’un nombre en nombre. chaque type numérique dans le .NET Framework comprend deux méthodes d’analyse surchargées : Parse et TryParse . La Parse méthode convertit une chaîne en nombre et lève une exception en cas d’échec de la conversion. 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.

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. Si aucune NumberStyles valeur n’est fournie dans l’appel de méthode, la valeur par défaut est une NumberStyles valeur qui inclut les Float AllowThousands 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 des espaces blancs, ou il peut s’agir de la représentation sous forme de chaîne d’un nombre en notation exponentielle.

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. Si aucun NumberFormatInfo objet n’est fourni, la valeur par défaut est NumberFormatInfo pour la culture actuelle. Pour plus d’informations sur l’analyse, consultez les méthodes d’analyse individuelles, telles que,,,,, Int16.Parse(String) Int32.Parse(String, NumberStyles) Int64.Parse(String, IFormatProvider) Decimal.Parse(String, NumberStyles, IFormatProvider) Double.TryParse(String, Double) et BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger) .

L’exemple suivant illustre la nature dépendante de la culture des chaînes d’analyse. 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. 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.

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 :

  • En tant qu’opération conçue pour convertir une entrée d’utilisateur en une valeur numérique.

  • 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.

Les sections suivantes décrivent ces deux opérations plus en détail.

Analyse des chaînes utilisateur

Lorsque vous analysez des chaînes numériques entrées par l’utilisateur, vous devez toujours instancier un NumberFormatInfo objet qui reflète les paramètres culturels de l’utilisateur. Pour plus d’informations sur la façon d’instancier un NumberFormatInfo objet qui reflète les personnalisations de l’utilisateur, consultez la section NumberFormatInfo et Dynamic Data .

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. 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. En règle générale, ces symboles sont inversés dans la culture en-US par défaut. Lorsque l’utilisateur entre une chaîne qui reflète les paramètres utilisateur et que la chaîne est analysée par un NumberFormatInfo objet qui reflète également les paramètres utilisateur (substitutions), l’opération d’analyse retourne un résultat correct. 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.

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ériques

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. Les opérations de mise en forme et d’analyse ne doivent jamais refléter les conventions d’une culture spécifique. 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é. 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.

L’exemple suivant illustre ce qui peut se produire lorsque ce principe est violé. 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. Les données sont ensuite analysées par un thread qui utilise les paramètres spécifiques à la culture de la culture PT-BR. Dans ce cas, bien que chaque opération d’analyse aboutisse, les données ne sont pas parcourues correctement et des données endommagées se produisent. Dans d’autres cas, une opération d’analyse peut échouer et une FormatException exception peut être levée.

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

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

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

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

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

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

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

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

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

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

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

Constructeurs

NumberFormatInfo()

Initialise une nouvelle instance accessible en écriture de la classe NumberFormatInfo qui est indépendante de la culture (dite indifférente).

Propriétés

CurrencyDecimalDigits

Obtient ou définit le nombre de décimales à utiliser dans les valeurs de devise.

CurrencyDecimalSeparator

Obtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs de devise.

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.

CurrencyGroupSizes

Obtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs de devise.

CurrencyNegativePattern

Obtient ou définit le modèle de format pour les valeurs de devise négatives.

CurrencyPositivePattern

Obtient ou définit le modèle de format pour les valeurs de devise positives.

CurrencySymbol

Obtient ou définit la chaîne à utiliser comme symbole de devise.

CurrentInfo

Obtient un objet NumberFormatInfo en lecture seule qui met en forme des valeurs en fonction de la culture actuelle.

DigitSubstitution

Obtient ou définit une valeur qui spécifie la façon dont l'interface graphique affiche la forme d'un chiffre.

InvariantInfo

Obtient un objet NumberFormatInfo en lecture seule indépendant de la culture (invariant).

IsReadOnly

Obtient une valeur qui indique si cet objet NumberFormatInfo est en lecture seule.

NaNSymbol

Obtient ou définit la chaîne représentant la valeur IEEE NaN (pas un nombre).

NativeDigits

Obtient ou définit un tableau de chaînes de chiffres natifs correspondant aux chiffres occidentaux de 0 à 9.

NegativeInfinitySymbol

Obtient ou définit la chaîne représentant l'infini négatif.

NegativeSign

Obtient ou définit la chaîne indiquant que le nombre associé est négatif.

NumberDecimalDigits

Obtient ou définit le nombre de décimales à utiliser dans les valeurs numériques.

NumberDecimalSeparator

Obtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs numériques.

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.

NumberGroupSizes

Obtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs numériques.

NumberNegativePattern

Obtient ou définit le modèle de format pour les valeurs numériques négatives.

PercentDecimalDigits

Obtient ou définit le nombre de décimales à utiliser dans les valeurs de pourcentage.

PercentDecimalSeparator

Obtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs de pourcentage.

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.

PercentGroupSizes

Obtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs de pourcentage.

PercentNegativePattern

Obtient ou définit le modèle de format pour les valeurs de pourcentage négatives.

PercentPositivePattern

Obtient ou définit le modèle de format pour les valeurs de pourcentage positives.

PercentSymbol

Obtient ou définit la chaîne à utiliser comme symbole de pourcentage.

PerMilleSymbol

Obtient ou définit la chaîne à utiliser comme symbole de "pour mille".

PositiveInfinitySymbol

Obtient ou définit la chaîne représentant l'infini positif.

PositiveSign

Obtient ou définit la chaîne indiquant que le nombre associé est positif.

Méthodes

Clone()

Crée une copie superficielle de l'objet NumberFormatInfo.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

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

Obtient un objet du type spécifié qui fournit un service de mise en forme des nombres.

GetHashCode()

Fait office de fonction de hachage par défaut.

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

Obtient le NumberFormatInfo associé au IFormatProvider spécifié.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

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

Retourne un wrapper NumberFormatInfo en lecture seule.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

S’applique à

Voir aussi