Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

NumberFormatInfo, classe

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

System.Object
  System.Globalization.NumberFormatInfo

Espace de noms :  System.Globalization
Assembly :  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class NumberFormatInfo : ICloneable, 
	IFormatProvider

Le type NumberFormatInfo expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNumberFormatInfoInitialise une nouvelle instance accessible en écriture de la classe NumberFormatInfo qui est indépendante de la culture (dite indifférente).
Début

  NomDescription
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrencyDecimalDigitsObtient ou définit le nombre de décimales à utiliser dans les valeurs monétaires.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrencyDecimalSeparatorObtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs monétaires.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrencyGroupSeparatorObtient ou définit la chaîne qui sépare les groupes de chiffres à gauche du séparateur décimal dans les valeurs monétaires.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrencyGroupSizesObtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs monétaires.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrencyNegativePatternObtient ou définit le modèle de format pour les valeurs monétaires négatives.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrencyPositivePatternObtient ou définit le modèle de format pour les valeurs monétaires positives.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrencySymbolObtient ou définit la chaîne à utiliser comme symbole monétaire.
Propriété publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrentInfoObtient un NumberFormatInfo en lecture seule qui met en forme les valeurs en fonction de la culture en cours.
Propriété publiqueDigitSubstitutionObtient ou définit une valeur qui spécifie la façon dont l'interface utilisateur graphique affiche la forme d'un chiffre.
Propriété publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreInvariantInfoObtient un objet NumberFormatInfo en lecture seule indépendant de la culture (dite indifférente).
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsReadOnlyObtient une valeur qui indique si cet objet NumberFormatInfo est en lecture seule.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNaNSymbolObtient ou définit la chaîne représentant la valeur IEEE NaN (pas un nombre).
Propriété publiqueNativeDigitsObtient ou définit un tableau de chaînes de chiffres natifs correspondant aux chiffres occidentaux de 0 à 9.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNegativeInfinitySymbolObtient ou définit la chaîne représentant l'infini négatif.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNegativeSignObtient ou définit la chaîne dénotant que le nombre associé est négatif.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNumberDecimalDigitsObtient ou définit le nombre de décimales à utiliser dans les valeurs numériques.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNumberDecimalSeparatorObtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs numériques.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNumberGroupSeparatorObtient ou définit la chaîne qui sépare les groupes de chiffres à gauche du séparateur décimal dans les valeurs numériques.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNumberGroupSizesObtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs numériques.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNumberNegativePatternObtient ou définit le modèle de format pour les valeurs numériques négatives.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePercentDecimalDigitsObtient ou définit le nombre de décimales à utiliser dans les valeurs de pourcentage.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePercentDecimalSeparatorObtient ou définit la chaîne à utiliser comme séparateur décimal dans les valeurs de pourcentage.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePercentGroupSeparatorObtient ou définit la chaîne qui sépare les groupes de chiffres à gauche du séparateur décimal dans les valeurs de pourcentage.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePercentGroupSizesObtient ou définit le nombre de chiffres dans chaque groupe à gauche du séparateur décimal dans les valeurs de pourcentage.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePercentNegativePatternObtient ou définit le modèle de format pour les valeurs de pourcentage négatives.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePercentPositivePatternObtient ou définit le modèle de format pour les valeurs de pourcentage positives.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePercentSymbolObtient ou définit la chaîne à utiliser comme symbole de pourcentage.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePerMilleSymbolObtient ou définit la chaîne à utiliser comme symbole "pour mille".
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePositiveInfinitySymbolObtient ou définit la chaîne représentant l'infini positif.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePositiveSignObtient ou définit la chaîne dénotant que le nombre associé est positif.
Début

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCloneCrée une copie superficielle de l'objet NumberFormatInfo.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Détermine si l'objet spécifié est identique à l'objet actuel. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetFormatObtient un objet du type spécifié qui fournit un service de mise en forme des nombres.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeSert de fonction de hachage par défaut. (Hérité de Object.)
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetInstanceObtient le NumberFormatInfo associé au IFormatProvider spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReadOnlyRetourne un wrapper NumberFormatInfo en lecture seule.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToStringRetourne une chaîne qui représente l'objet actif. (Hérité de Object.)
Début

La classe NumberFormatInfo contient des informations spécifiques à la culture 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 nombres positifs et les signes.

Instanciation d'un objet NumberFormatInfo

Instanciez un objet NumberFormatInfo qui représente les conventions de mise en forme de la culture actuelle, de la culture indifférente, d'une culture spécifique, ou d'une culture neutre.

Instanciation d'un objet de NumberFormatInfo pour la culture actuelle

Instanciez un objet NumberFormatInfo pour la culture du thread actuel de plusieurs façons. Dans chaque cas, l'objet NumberFormatInfo retourné est en lecture seule.

L'exemple suivant utilise ces trois façons de créer des objets NumberFormatInfo qui représentent les conventions de mise en forme de la culture actuelle. Il extrait également la valeur de la propriété IsReadOnly 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


Il vous est possible de créer un objet NumberFormatInfo accessible en écriture qui représente les conventions de la culture du thread actuel de l'une des façons suivantes :

  • Lorsque vous récupérez un objet NumberFormatInfo de l'une des façons illustrées dans l'exemple de code précédent, et appelez la méthode Clone sur l'objet NumberFormatInfo retourné. Cela crée une copie de l'objet NumberFormatInfo d'origine, si ce n'est que sa propriété IsReadOnly est false.

  • En appelant la méthode CultureInfo.CreateSpecificCulture pour créer un objet CultureInfo qui représente la culture actuelle, puis en utilisant sa propriété CultureInfo.NumberFormat pour récupérer l'objet NumberFormatInfo.

L'exemple suivant illustre ces deux façons d'instancier un objet NumberFormatInfo, et affiche la valeur de sa propriété IsReadOnly pour montrer 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


Notez que le système d'exploitation Windows permet à l'utilisateur de substituer certaines valeurs de propriété NumberFormatInfo utilisées dans les opérations de mise en forme numérique et d'analyse et via l'élément Région et langue du Panneau de configuration. Par exemple, un utilisateur dont la culture est Anglais (États-Unis) pourrait choisir d'afficher des valeurs monétaires comme 1,1 USD au lieu de la valeur par défaut de $1,1. Tous les objets NumberFormatInfo extraits selon les méthodes expliquées précédemment reflètent ces substitutions d'utilisateur. Si c'est indésirable, créez un objet NumberFormatInfo qui ne reflète pas les substitutions d'utilisateur (et qui est également en lecture/écriture plutôt qu'en lecture seule) en appelant le constructeur CultureInfo.CultureInfo(String, Boolean) et en fournissant une valeur false pour l'argument useUserOverride. L'exemple suivant fournit une illustration pour un système dont la culture actuelle est Anglais (États-Unis) et dont le symbole monétaire est passé de la valeur par défaut $ à 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: $


Si la propriété CultureInfo.UseUserOverride a la valeur true, les propriétés CultureInfo.DateTimeFormat, CultureInfo.NumberFormat et CultureInfo.TextInfo sont aussi récupérées des paramètres utilisateur. Si les paramètres utilisateur ne sont pas compatibles avec la culture associée à l'objet CultureInfo (par exemple, si le calendrier sélectionné n'est pas l'un des calendriers listés par la propriété OptionalCalendars ), les résultats des méthodes et les valeurs des propriétés ne sont pas définis.

Instanciation d'un objet de NumberFormatInfo pour la culture indifférente

La culture indifférente représente une culture qui est indépendante de la culture. Elle est basée sur l'anglais mais pas sur un pays/région spécifique anglophone. Bien que les données des cultures spécifiques soient dynamiques et puissent être modifiées pour refléter de nouvelles conventions culturelles ou préférences de l'utilisateur, les données de la culture dite indifférente ne changent pas. Objet NumberFormatInfo qui représente les conventions de mise en forme de la culture indifférente peut être utilisée pour la mise en forme des opérations dans lesquelles les chaînes de résultat ne doivent pas varier selon la culture.

Instanciez un objet NumberFormatInfo qui représente les conventions de mise en forme de la culture indifférente selon les façons suivantes :

  • En récupérant la valeur de la propriété InvariantInfo. L'objet NumberFormatInfo qui est retourné est en lecture seule.

  • Lorsque vous récupérez la valeur de la propriété CultureInfo.NumberFormat de l'objet CultureInfo retourné par la propriété CultureInfo.InvariantCulture. L'objet NumberFormatInfo qui est retourné est en lecture seule.

  • En appelant le constructeur sans paramètre de classe NumberFormatInfo. L'objet NumberFormatInfo retourné est en lecture/écriture.

L'exemple suivant utilise chacune de ces méthodes pour instancier un objet NumberFormatInfo qui représente la culture dite indifférente. Il montre 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


Instanciation d'un objet de NumberFormatInfo pour une culture spécifique

Une culture spécifique représente un langage qui est parlé dans des pays/région particuliers. Par exemple, en-US sont une culture spécifique qui représente la langue anglaise parlée aux États-Unis, et l'en-CA est une culture spécifique qui représente la langue anglaise parlée du Canada. Instanciez un objet NumberFormatInfo qui représente les conventions de mise en forme d'une culture spécifique selon les façons suivantes :

L'exemple suivant utilise ces quatre façons de créer un objet NumberFormatInfo qui reflète les conventions de mise en forme de la culture indonésienne (de l'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


Instanciation d'un objet de NumberFormatInfo pour une culture neutre

Une culture neutre représente une culture ou un langage qui sont indépendants d'un pays ou une région. Il s'agit en général du parent d'une ou plusieurs cultures spécifiques. Par exemple, le fr est une culture neutre pour la langue française et le parent de la culture fr-FR. Vous créez un objet NumberFormatInfo qui représente les conventions de mise en forme d'une culture neutre de la même façon que vous créez un objet NumberFormatInfo qui représente les conventions de mise en forme d'une culture spécifique.

RemarqueRemarque

Dans le .NET Framework 3.5 et ses versions antérieures, toute tentative de récupérer un objet NumberFormatInfo qui reflète les conventions de mise en forme d'une culture neutre lève une exception NotSupportedException.

Toutefois, car elle est indépendante d'un pays/une région spécifiques, une culture neutre manque d'informations de mise en forme spécifique à la culture. Plutôt que de remplir objet NumberFormatInfo avec des valeurs génériques, le .NET Framework retourne un objet NumberFormatInfo reflétant les conventions de mise en forme d'une culture spécifique qui est un enfant de la culture neutre. Par exemple, l'objet NumberFormatInfo de la culture neutre en reflète les conventions de mise en forme de la culture en-US, et l'objet NumberFormatInfo pour la culture fr reflète les conventions de mise en forme de la culture fr-FR.

Utilisez un code semblable au suivant pour déterminer les conventions spécifiques de mise en forme 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();
   }
}


NumberFormatInfo et données dynamiques

Les données spécifique à la culture pour mettre en forme des valeurs numériques fournies par la classe NumberFormatInfo sont dynamiques, tout comme les données culturelles fournies par la classe CultureInfo. Vous ne devez effectuer aucune hypothèse concernant la stabilité des valeurs pour les objets NumberFormatInfo associés aux objets CultureInfo particuliers. Seuls les données fournies par la culture indifférente et son objet NumberFormatInfo associé sont stables. D'autres données peuvent varier entre des sessions d'application, ou même dans une seule session, pour les raisons suivantes :

  • Mises à jour système. Les préférences culturelles telles que le symbole monétaire ou les formats monétaires changent au fil du temps. Lorsque cela se produit, Windows Update inclut des modifications à la valeur de propriété NumberFormatInfo pour une culture spécifique.

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

  • Modifications d'empilement des valeurs de propriété. Un certain nombre de propriétés liées peuvent changer au moment de l'exécution, qui, elles-mêmes, provoque la modification des données de NumberFormatInfo. Par exemple, la culture actuelle peut être modifiée par programme ou via l'action de l'utilisateur. Lorsque cela se produit, l'objet NumberFormatInfo retourné par la propriété CurrentInfo devient un objet associé à la culture actuelle.

  • Préférences utilisateur Les utilisateurs de votre application peuvent choisir de substituer certaines des valeurs associées à la culture du système en cours par le biais des options régionales et linguistiques du Panneau de configuration. Par exemple, les utilisateurs peuvent choisir un symbole monétaire différent ou un symbole de séparateur décimal différent. Si la propriété CultureInfo.UseUserOverride détient la valeur true (valeur par défaut), les propriétés de l'objet NumberFormatInfo sont également récupérées des paramètres utilisateur.

Depuis le .NET Framework 2.0, toutes les propriétés d'un objet NumberFormatInfo substituables par l'utilisateur sont initialisées lorsque l'objet est créé. Il reste une possibilité d'incohérence, car ni la création d'objet ni le processus de substitution par l'utilisateur n'est atomique et les valeurs pertinentes peuvent changer pendant la création de l'objet. Toutefois, ces incohérences doivent être très rares.

Contrôlez si les substitutions d'utilisateur sont reflétées dans les objets NumberFormatInfo qui représentent la même culture que la culture du thread actuel. Le tableau suivant répertorie les façons par lesquelles un objet NumberFormatInfo peut être récupéré et indique si l'objet obtenu reflète les substitutions d'utilisateur.

Source d'objet CultureInfo et de NumberFormatInfo

Reflète des substitutions d'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 paramètre useUserOverride

À moins qu'il n'existe une bonne raison de faire autrement, vous devez réaliser des substitutions d'utilisateur lorsque vous utilisez l'objet NumberFormatInfo dans les applications clientes pour formater et analyser l'entrée d'utilisateur ou afficher des données numériques. Pour les applications serveur ou des applications sans assistance, vous ne devez pas respecter les substitutions d'utilisateur. Toutefois, si vous utilisez l'objet NumberFormatInfo que ce soit explicitement ou implicitement pour conservez des données numériques sous forme de chaîne, vous devez soit utiliser un objet NumberFormatInfo qui reflète les conventions de mise en forme de la culture indifférente, soit spécifier une chaîne de format numérique personnalisée que vous utilisez indépendamment de la culture.

IFormatProvider, NumberFormatInfo, et mise en forme numérique

L' objet NumberFormatInfo est utilisé implicitement ou explicitement dans toutes les opérations de mise en forme numériques. Ceux-ci incluent des appels aux méthodes suivantes :

Toutes les opérations de mise en forme numériques utilisent une implémentation de IFormatProvider. L'interface IFormatProvider inclut une méthode unique, GetFormat(Type). Il s'agit une méthode de rappel qui reçoit un objet Type représentant le type nécessaire pour fournir des informations de mise en forme. La méthode est chargée de retourner soit une instance de ce type soit null, si elle ne peut pas fournir une instance du type. Le .NET Framework fournit deux implémentations de IFormatProvider pour mettre des nombres en forme :

  • La classe CultureInfo, qui représente une culture spécifique (ou un langage spécifique dans un pays/région spécifique). Dans une opération de mise en forme numérique, la méthode CultureInfo.GetFormat retourne l'objet NumberFormatInfo associé à sa propriété CultureInfo.NumberFormat.

  • La classe NumberFormatInfo, qui fournit des informations sur les conventions de présentation de sa culture associée. La méthode NumberFormatInfo.GetFormat retourne une instance d'elle-même.

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

L'exemple suivant illustre la relation entre l'interface IFormatProvider et la classe NumberFormatInfo dans les opérations de mise en forme en définissant une implémentation personnalisée de IFormatProvider. Sa méthode GetFormat affiche le nom de type de l'objet demandé par l'opération de mise en forme. Si l'interface demande un objet NumberFormatInfo, cette méthode fournit l'objet NumberFormatInfo pour la culture du thread actuel. Comme la sortie de l'exemple le montre, la méthode Decimal.ToString(IFormatProvider) invite un objet NumberFormatInfo à fournir des informations de mise en forme, alors que la méthode String.Format(IFormatProvider, String, Object[]) demande NumberFormatInfo et des objets DateTimeFormatInfo ainsi qu'une implémentation de ICustomFormatter.


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


Si une implémentation de IFormatProvider n'est pas explicitement fournie dans un appel de méthode de mise en forme numérique, la méthode appelle la méthode CultureInfo.CurrentCulture.GetFormat, qui retourne l'objet NumberFormatInfo correspondant à la culture du thread actuel.

Propriétés de chaînes de format et de NumberFormatInfo

Chaque opération de mise en forme utilise une chaîne standard ou de format numérique personnalisé pour produire une chaîne de résultat d'un nombre. Dans certains cas, l'utilisation d'une chaîne de format afin de produire une chaîne de résultat est explicite, comme dans l'exemple suivant. Ce code appelle la méthode Decimal.ToString(IFormatProvider) pour convertir une valeur de Decimal à plusieurs des représentations sous forme de chaîne en utilisant les 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


Dans d'autres cas, l'utilisation d'une chaîne de format est implicite. Par exemple, dans les appels de méthode suivant à la méthode Decimal.ToString() par défaut ou sans paramètre, la valeur de l'instance de Decimal est mise en forme en utilisant du spécificateur de format général (« G ») et des conventions de la culture actuelle, ici 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


Chaque chaîne de format numérique standard utilise une ou plusieurs propriétés NumberFormatInfo pour déterminer 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èrent des symboles dans la chaîne de résultat définis par les propriétés NumberFormatInfo. Le tableau suivant décrit les spécificateurs de format standard et de format numériques personnalisés et leurs propriétés NumberFormatInfo associées. Pour modifier l'apparence de la chaîne de résultat d'une culture particulière, consultez la section Modification des propriétés de 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 de milliers.

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

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

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

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

NegativeSign , pour définir le signe négatif.

"D" ou "d" (Spécificateur de format décimal)

NegativeSign , pour définir le signe négatif.

« E » ou « e » (spécificateur de format exponentiel ou scientifique)

NegativeSign , pour définir le 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 signe positif dans l'exposant.

"F" ou "f" (Spécificateur de format à virgule fixe)

NegativeSign , pour définir le 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 signe négatif.

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

PositiveSign , pour définir le 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 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 groupe ou le séparateur de symboles (milliers).

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

NumberNegativePattern , pour définir le format de valeurs négatives.

"P" ou "p" (Spécificateur de format pourcentage)

NegativeSign , pour définir le 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 la position du symbole de pourcentage et le symbole négatif pour les valeurs négatives.

PercentPositivePattern , pour définir la position 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 signe négatif.

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

PositiveSign , pour définir le 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 groupe ou le séparateur de symboles (milliers).

« % » (spécificateur de format personnalisé de l'espace réservé de pourcentage)

PercentSymbol , pour définir le symbole de pourcentage.

« ‰ » (spécificateur de format personnalisé de l'espace réservé " pour mille ")

PerMilleSymbol , pour définir le symbole " pour mille ".

« E » (spécificateur de format personnalisé de notation exponentielle)

NegativeSign , pour définir le signe négatif dans la mantisse et l'exposant.

PositiveSign , pour définir le signe positif dans l'exposant.

Notez que la classe NumberFormatInfo inclut une propriété NativeDigits qui spécifie les chiffres de base 10 utilisés par une culture spécifique. Toutefois, la propriété n'est pas utilisée dans les opérations de mise en forme ; uniquement des chiffres latins de base 0 (U+0030) à 9 (U+0039) sont utilisés dans la chaîne de résultat. En outre, pour Single et Double de NaN, en PositiveInfinity, et NegativeInfinity, la chaîne de résultat se compose exclusivement de symboles définis par NaNSymbol, PositiveInfinitySymbol, et les propriétés NegativeInfinitySymbol, respectivement.

Modifier des propriétés NumberFormatInfo

Modifiez les propriétés d'un objet NumberFormatInfo pour personnaliser la chaîne de résultat produite dans une opération de mise en forme numérique. Pour cela :

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

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

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

RemarqueRemarque

Au lieu de modifier dynamiquement les valeurs de propriété d'une culture chaque fois qu'une application lancée, utilisez la classe CultureAndRegionInfoBuilder pour définir une culture personnalisée (culture qui possède un nom unique et qui remplit les cultures existantes) ou une culture de remplacement (une utilisée au lieu d'une culture spécifique).

Les sections suivantes fournissent des exemples.

2xdwt6xx.collapse_all(fr-fr,VS.110).gifModification du symbole monétaire et du modèle

L'exemple suivant modifie un objet NumberFormatInfo qui représente les conventions de mise en forme de la culture en-US. Il assigne le symbole monétaire ISO-4217 à la propriété CurrencySymbol et définit un modèle pour les valeurs monétaires qui inclut le 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


2xdwt6xx.collapse_all(fr-fr,VS.110).gifMise en forme d'un numéro d'identification national

Beaucoup de numéros d'identification nationaux son composés exclusivement de chiffres et peuvent ainsi être facilement mis en forme en modifiant les propriétés d'un objet NumberFormatInfo. Par exemple, un numéro de sécurité sociale aux États-Unis se compose de 9 chiffres disposés comme suit : XXX-XX-XXXX. L'exemple suivant suppose que les numéros de sécurité sociale sont stockés en tant que valeurs entières et les met en forme correctement.


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


Analyse de chaînes numériques

L'analyse consiste à convertir la représentation sous forme de chaîne d'un nombre en un nombre. Chaque type numérique dans le .NET Framework inclut deux méthodes d'analyse surchargées : Parse et TryParse. La méthode Parse convertit une chaîne en un nombre et lève une exception si la conversion échoue. La méthode TryParse convertit une chaîne en un nombre, assigne le nombre à un argument out, et retourne une valeur de Boolean qui indique si la conversion a réussi.

Les méthodes d'analyse utilisent implicitement ou explicitement une valeur d'énumération NumberStyles pour déterminer quels éléments de style (tels que les séparateurs de groupe, un séparateur décimal, ou un symbole monétaire) peuvent être présents dans une chaîne si l'opération d'analyse est vouée à réussir. Si une valeur de NumberStyles n'est pas fournie dans l'appel de méthode, la valeur par défaut est une valeur de NumberStyles qui inclut des signaux Float et AllowThousands, spécifie que la chaîne analysée peut inclure des symboles de groupe, des séparateurs décimaux, un signe négatif, et des espaces blancs, ou peut être 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 objet NumberFormatInfo qui définit les symboles et modèles spécifiques qui peuvent être rencontrés dans la chaîne à analyser. Si un objet NumberFormatInfo n'est pas fourni, la valeur par défaut est NumberFormatInfo pour la culture du thread actuel. Pour plus d'informations sur l'analyse, consultez les différentes méthodes d'analyse, 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. Il tente d'analyser une chaîne qui incluent des séparateurs de milliers en utilisant les conventions issues de en-US, fr-FR, et les cultures indifférentes. Une chaîne qui inclut la virgule en tant que séparateur de groupes et le point en tant que séparateur décimal ne parvient pas à analyser dans la culture fr-FR, et une chaîne avec l'espace en tant que séparateur de groupes et la virgule en tant que séparateur décimal ne parvient pas à analyser dans la culture en-US et les cultures indifférentes.


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)


L'analyse se produit généralement dans deux contextes :

  • En tant qu'opération conçue pour convertir l'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ées comme une chaîne.

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

2xdwt6xx.collapse_all(fr-fr,VS.110).gifAnalyser les chaînes utilisateur

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

L'exemple suivant illustre la différence entre une opération d'analyse qui reflète les paramètres de culture d'utilisateur et une qui ne le fait pas. Dans ce cas, la culture par défaut du système est en-US, mais l'utilisateur a défini « , » comme symbole décimal et « . » comme séparateur de groupes dans Panneau de configuration, Région et langue. Normalement, 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 la chaîne est analysée par un objet NumberFormatInfo qui reflète également les paramètres utilisateur (substitutions), l'opération d'analyse retourne un résultat approprié. Toutefois, lorsque la chaîne est analysée par un objet NumberFormatInfo qui reflète les paramètres de culture en-US standard, elle confond le symbole de séparateur avec 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


2xdwt6xx.collapse_all(fr-fr,VS.110).gifSérialisation et désérialisation de données numériques

Lorsque des données numériques sont sérialisées au format de chaîne puis désérialisées et analysées, les chaînes doivent être générées et analysées à l'aide des conventions de la culture indifférente. La mise en forme et les opérations d'analyse ne doivent jamais refléter les conventions d'une culture spécifique. Si des paramètres spécifiques à la culture sont utilisés, la portabilité des données est strictement limitée ; elle peut être correctement désérialisée 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 correctement désérialisées sur le système 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 dans 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 d'en-GB. Dans ce cas, bien que chaque opération d'analyse aboutisse, les données ne font pas d'aller-retour avec succès et une altération des données se produit. Dans d'autres cas, une opération d'analyse échoue et une exception de FormatException 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()
   {
      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


L'exemple suivant montre comment récupérer un objet NumberFormatInfo pour un objet CultureInfo correspondant et utilise l'objet récupéré pour interroger les informations de mise en forme des nombres pour la culture spécifique.


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'


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft