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
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

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 StoreNumberFormatInfo Initialise 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 StoreCurrencyDecimalDigits Obtient 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 StoreCurrencyDecimalSeparator Obtient 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 StoreCurrencyGroupSeparator Obtient 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 StoreCurrencyGroupSizes Obtient 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 StoreCurrencyNegativePattern Obtient 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 StoreCurrencyPositivePattern Obtient 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 StoreCurrencySymbol Obtient 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 StoreCurrentInfo Obtient un NumberFormatInfo en lecture seule qui met en forme les valeurs en fonction de la culture en cours.
Propriété publiqueDigitSubstitution Obtient 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 StoreInvariantInfo Obtient 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 StoreIsReadOnly Obtient 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 StoreNaNSymbol Obtient ou définit la chaîne représentant la valeur IEEE NaN (pas un nombre).
Propriété publiqueNativeDigits Obtient 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 StoreNegativeInfinitySymbol Obtient 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 StoreNegativeSign Obtient 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 StoreNumberDecimalDigits Obtient 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 StoreNumberDecimalSeparator Obtient 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 StoreNumberGroupSeparator 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.
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 StoreNumberGroupSizes Obtient 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 StoreNumberNegativePattern Obtient 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 StorePercentDecimalDigits Obtient 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 StorePercentDecimalSeparator Obtient 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 StorePercentGroupSeparator 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.
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 StorePercentGroupSizes Obtient 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 StorePercentNegativePattern Obtient 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 StorePercentPositivePattern Obtient 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 StorePercentSymbol Obtient 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 StorePerMilleSymbol Obtient 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 StorePositiveInfinitySymbol Obtient 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 StorePositiveSign Obtient 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 StoreClone Cré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 StoreGetFormat Obtient 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 StoreGetInstance Obtient 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 StoreReadOnly Retourne 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 d'NumberFormatInfo contient des informations spécifiques à la culture utilisées lorsque vous mettez en forme et l'analyse 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 de NumberFormatInfo

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

Instanciation d'un objet de NumberFormatInfo pour la culture actuelle

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

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


Vous pouvez créer un objet accessible en écriture d'un NumberFormatInfo 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 en appelant la méthode Clone sur l'objet retourné par NumberFormatInfo. Cela crée une copie de l'objet d'origine NumberFormatInfo, sauf que sa propriété de IsReadOnly est false.

  • En appelant la méthode CultureInfo.CreateSpecificCulture pour créer un objet CultureInfo qui représente la culture actuelle, et à sa propriété d'CultureInfo.NumberFormat puis 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é d'un 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é d'NumberFormatInfo utilisées dans la mise en forme numérique opérations d'analyse et via l'élément Région et langue du Panneau de configuration. Par exemple, un utilisateur dont la culture est force Anglais (États-Unis) choisissez d'afficher des valeurs monétaires comme 1,1 USD au lieu de la valeur par défaut de $1,1. Tous les objets d'NumberFormatInfo extraits des méthodes ont expliqué précédemment reflètent ces substitutions d'utilisateur. Si c'est indésirable, vous pouvez créer 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 de CultureInfo.CultureInfo(String, Boolean) et en fournissant une valeur d'false pour l'argument d'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 sont incompatibles avec la culture associée à l'objet CultureInfo (par exemple, si le calendrier sélectionné n'est pas l'un des calendriers répertoriés par la propriété d'OptionalCalendars ), les résultats des méthodes et les valeurs des propriétés sont éliminées.

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 tout pays/région d'expression anglaise spécifiques. Bien que les données des cultures spécifiques soient dynamiques et puissent modifier pour refléter de nouvelles conventions culturelles ou préférences de l'utilisateur, les données de la culture dite indifférente ne change 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.

Vous pouvez instancier un objet NumberFormatInfo qui représente les conventions de mise en forme de la culture indifférente des façons suivantes :

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

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

  • En appelant le constructeur sans paramètre de classe d'NumberFormatInfo. L'objet retourné par NumberFormatInfo 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é 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-US autorité de certification est une culture spécifique qui représente la langue anglaise parlée du Canada. Vous pouvez instancier un objet NumberFormatInfo qui représente les conventions de mise en forme d'une culture spécifique des 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'un 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 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 d'NotSupportedException.

Toutefois, car il est indépendant 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 remplissant objet NumberFormatInfo avec les valeurs génériques, le .NET Framework retourne un objet NumberFormatInfo 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'objet NumberFormatInfo pour 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.

Vous pouvez utiliser un code semblable au suivant pour déterminer les conventions spécifiques de mise en forme de la culture 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 d'NumberFormatInfo est dynamique, comme les données selon la culture fournies par la classe d'CultureInfo. Vous ne devez effectuer aucune hypothèse concernant la stabilité des valeurs pour les objets d'NumberFormatInfo associés aux objets particuliers d'CultureInfo. Seuls les données fournies par la culture indifférente et son objet associé d'NumberFormatInfo est stable. 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 au fil du temps. Lorsque cela se produit, Windows Update inclut des modifications à la valeur de propriété d'NumberFormatInfo pour une culture spécifique.

  • Cultures de remplacement. La classe d'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, eux-mêmes, provoque des données d'NumberFormatInfo à la modification. Par exemple, la culture actuelle peut être modifiée par programme ou via l'action utilisateur. Lorsque cela se produit, l'objet NumberFormatInfo retourné par la propriété d'CurrentInfo devient un objet associé à la culture actuelle.

  • Préférences de l'utilisateur. Les utilisateurs de votre application peuvent substituer certaines des valeurs associées à la culture système en cours via la zone et des options de langue du Panneau de configuration. Par exemple, les utilisateurs peuvent choisir un symbole monétaire différent ou un symbole différent de séparateur décimal. Si la propriété d'CultureInfo.UseUserOverride a 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 par substituables d'un objet NumberFormatInfo sont initialisées lorsque l'objet est créé. Il existe toujours la possibilité d'incohérence, car ni la création d'objet ni le processus de priorité d'utilisateur n'est atomique, et les valeurs appropriées peuvent changer pendant la création d'objet. Toutefois, ces incohérences doivent être très rares.

Vous pouvez contrôler si les substitutions d'utilisateur sont reflétées dans les objets d'NumberFormatInfo qui représentent la même culture que la culture du thread actuel. Le tableau suivant répertorie les façons d'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 d'useUserOverride

À moins qu'il existe une bonne raison de faire sinon, 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 des substitutions d'utilisateur. Toutefois, si vous utilisez l'objet NumberFormatInfo ou explicitement ou rendre implicitement les données numériques dans la chaîne forment, vous devez soit d'utiliser un objet NumberFormatInfo qui reflète les conventions de mise en forme de la culture indifférente, ou vous devez 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

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

Toutes les opérations de mise en forme numériques utilisent une implémentation d'IFormatProvider. L'interface IFormatProvider inclut une méthode unique, GetFormat(Type). C'est une méthode de rappel qui reçoit un objet Type qui représente 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 ou d'null, si elle ne peut pas fournir une instance du type. . Le.NET Framework fournit deux implémentations d'IFormatProvider pour mettre des nombres en forme :

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

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

L'exemple suivant illustre la relation entre l'interface IFormatProvider et la classe de NumberFormatInfo pour les opérations de mise en forme en définissant une implémentation personnalisée d'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, la méthode Decimal.ToString(IFormatProvider) invite un objet NumberFormatInfo pour fournir des informations de mise en forme, alors que la méthode String.Format(IFormatProvider, String, Object[]) demande d'objets NumberFormatInfo et DateTimeFormatInfo ainsi qu'une implémentation d'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 d'IFormatProvider n'est pas explicitement fourni 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 qui correspond à 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ée pour produire une chaîne de résultat d'un nombre. Dans certains cas, l'utilisation d'une chaîne de format 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 d'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 suivante à la valeur par défaut ou à la méthode sans paramètre d'Decimal.ToString(), la valeur de l'instance d'Decimal est mise en forme en utilisant (« G ») du spécificateur de format général 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 d'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 « # » symboles d'insertion dans la chaîne de résultat définis par les propriétés d'NumberFormatInfo. Le tableau suivant décrit les spécificateurs de format standard et de format numériques personnalisés et les propriétés associées d'NumberFormatInfo. 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 standard)

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 symbole de séparateur de groupes (milliers).

NumberGroupSizes , pour définir le nombre de chiffres intégraux à 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 à 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 symbole de groupe de séparateur (de milliers).

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

PercentSymbol , pour définir le symbole de pourcentage.

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

PerMilleSymbol , pour permettre par 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 d'NumberFormatInfo inclut une propriété d'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 d'Double d'NaN, en PositiveInfinity, et NegativeInfinity, la chaîne de résultat se compose exclusivement composée de symboles définis par NaNSymbol, PositiveInfinitySymbol, et les propriétés de NegativeInfinitySymbol, respectivement.

Modification des propriétés de NumberFormatInfo

Vous pouvez modifier 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 les conventions de mise en forme que vous souhaitez modifier. 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 création des propriétés en forme d'NumberFormatInfo d'utilisation de méthodes 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 personnalisé d'NumberFormatInfo comme argument d'IFormatProvider dans les appels à mettre des méthodes en forme.

RemarqueRemarque

Au lieu de modifier dynamiquement les valeurs de propriété d'une culture chaque fois qu'une application lancée, vous pouvez utiliser la classe d'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é d'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 contiennent exclusivement composée de chiffres etc. peuvent ê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 des mettre 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 des chaînes numériques

L'analyse consiste à convertir la représentation sous forme de chaîne d'un nombre à un nombre. Chaque numérique types dans .NET Framework inclut deux méthodes de 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 d'out, et retourne une valeur d'Boolean qui indique si la conversion a réussi.

Les méthodes d'analyse implicitement ou utilisez 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) peut être présent dans une chaîne si l'opération d'analyse est de réussir. Si une valeur d'NumberStyles n'est pas fournie dans l'appel de méthode, la valeur par défaut est une valeur d'NumberStyles qui inclut Float et AllowThousands signale, qui spécifie que la chaîne analysée peut inclure des symboles de groupe, séparateur décimal, 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 également implicitement ou utilisent explicitement un objet NumberFormatInfo qui définit les symboles et modèles spécifiques qui peuvent se produire 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 l'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 des milliers en utilisant les conventions de en-US, du fr-FR, et les cultures invariantes. Chaîne qui inclut la virgule comme séparateur de groupes et point comme un séparateur décimal n'analyse pas dans la culture fr-FR, et une chaîne avec espace blanc comme séparateur de groupes et virgule comme un séparateur décimal n'analyse pas en-US et les cultures invariantes.


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 à 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 comme une chaîne.

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

2xdwt6xx.collapse_all(fr-fr,VS.110).gifChaînes utilisateur d'analyse

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 l'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 font 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 au Panneau de configuration, Région et langue. Normalement, ces symboles est inversé dans la culture des 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é par un objet NumberFormatInfo qui reflète également des 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 et versions ultérieures désérialisées et analysés, 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ée. Dans certains cas, cela signifie que les données ne peuvent pas même être correctement désérialisées sur le système sur lequel il a été sérialisé.

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 fait pas aller-retour avec succès et altération des données se produisent. Dans d'autres cas, une opération d'analyse échoue et une exception d'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, 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

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.
Tout membre static (Shared en Visual Basic) public de ce type est thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft. Tous droits réservés.