NumberFormatInfo Classe
Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

NumberFormatInfo, classe

 

Publication: mars 2016

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

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

System.Object
  System.Globalization.NumberFormatInfo

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

NomDescription
System_CAPS_pubmethodNumberFormatInfo()

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

NomDescription
System_CAPS_pubpropertyCurrencyDecimalDigits

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

System_CAPS_pubpropertyCurrencyDecimalSeparator

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

System_CAPS_pubpropertyCurrencyGroupSeparator

Obtient ou définit la chaîne qui sépare les groupes de chiffres à gauche du séparateur décimal dans les valeurs de devise.

System_CAPS_pubpropertyCurrencyGroupSizes

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

System_CAPS_pubpropertyCurrencyNegativePattern

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

System_CAPS_pubpropertyCurrencyPositivePattern

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

System_CAPS_pubpropertyCurrencySymbol

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

System_CAPS_pubpropertySystem_CAPS_staticCurrentInfo

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

System_CAPS_pubpropertyDigitSubstitution

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

System_CAPS_pubpropertySystem_CAPS_staticInvariantInfo

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

System_CAPS_pubpropertyIsReadOnly

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

System_CAPS_pubpropertyNaNSymbol

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

System_CAPS_pubpropertyNativeDigits

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

System_CAPS_pubpropertyNegativeInfinitySymbol

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

System_CAPS_pubpropertyNegativeSign

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

System_CAPS_pubpropertyNumberDecimalDigits

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

System_CAPS_pubpropertyNumberDecimalSeparator

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

System_CAPS_pubpropertyNumberGroupSeparator

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.

System_CAPS_pubpropertyNumberGroupSizes

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

System_CAPS_pubpropertyNumberNegativePattern

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

System_CAPS_pubpropertyPercentDecimalDigits

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

System_CAPS_pubpropertyPercentDecimalSeparator

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

System_CAPS_pubpropertyPercentGroupSeparator

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.

System_CAPS_pubpropertyPercentGroupSizes

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

System_CAPS_pubpropertyPercentNegativePattern

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

System_CAPS_pubpropertyPercentPositivePattern

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

System_CAPS_pubpropertyPercentSymbol

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

System_CAPS_pubpropertyPerMilleSymbol

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

System_CAPS_pubpropertyPositiveInfinitySymbol

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

System_CAPS_pubpropertyPositiveSign

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

NomDescription
System_CAPS_pubmethodClone()

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

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodGetFormat(Type)

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

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticGetInstance(IFormatProvider)

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

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticReadOnly(NumberFormatInfo)

Retourne un wrapper NumberFormatInfo en lecture seule.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

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

Vous pouvez instancier un NumberFormatInfo objet pour la culture du thread en cours d'une des manières suivantes. Dans chaque cas, le code NumberFormatInfo objet est en lecture seule.

L'exemple suivant utilise ces trois méthodes de création NumberFormatInfo objets qui représentent les conventions de mise en forme de la culture actuelle. Elle récupère également la valeur de la IsReadOnly propriété montrer 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 en écriture NumberFormatInfo objet qui représente les conventions de la culture du thread en cours d'une des manières suivantes :

  • En récupérant un NumberFormatInfo objet de la manière illustrée dans l'exemple de code précédent et l'appel du Clone méthode retourné NumberFormatInfo objet. Cette opération crée une copie de l'original NumberFormatInfo de l'objet, à ceci près que son IsReadOnly propriété est false.

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

L'exemple suivant illustre ces deux façons d'instancier un NumberFormatInfo de l'objet et affiche la valeur de son IsReadOnly propriété 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 de la NumberFormatInfo utilisées dans numérique mise en forme et l'analyse des opérations à l'aide des valeurs de propriété du région et langue élément dans le panneau de configuration. Par exemple, un utilisateur dont la culture est anglais (États-Unis) peut choisir Afficher les valeurs de devise comme 1.1 USD au lieu de la valeur par défaut de $1.1. Le NumberFormatInfo des objets récupérés dans les méthodes abordées précédemment reflètent tous ces substitutions par l'utilisateur. Si ce n'est pas souhaitable, vous pouvez créer un NumberFormatInfo objet qui ne reflète pas les substitutions par l'utilisateur (et qui est également en lecture/écriture plutôt qu'en lecture seule) en appelant le CultureInfo.CultureInfo(String, Boolean) constructeur et fournissant la valeur false pour la useUserOverride argument. 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 devenu la valeur par défaut de $ (USD).

using System;
using System.Globalization;

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

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

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

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

La culture dite indifférente représente une culture qui est indépendante de la culture. Il est basé sur la langue anglaise, mais pas sur n'importe quel pays/région de spécifique anglophones. Bien que les données de cultures spécifiques peuvent être dynamiques et peuvent changer pour refléter les nouvelles conventions culturelles ou les préférences de l'utilisateur, les données de la culture dite indifférente ne changent pas. Un NumberFormatInfo objet qui représente les conventions de mise en forme de la culture dite indifférente peut être utilisé pour mettre en forme des opérations dans le résultat de chaînes ne doivent pas varier selon la culture.

Vous pouvez instancier un NumberFormatInfo objet qui représente les conventions de mise en forme de la culture dite indifférente comme suit :

  • En récupérant la valeur de la InvariantInfo propriété. Retourné NumberFormatInfo objet est en lecture seule.

  • En récupérant la valeur de la CultureInfo.NumberFormat propriété à partir de la CultureInfo objet qui est retourné par la CultureInfo.InvariantCulture propriété. Retourné NumberFormatInfo objet est en lecture seule.

  • En appelant sans paramètre NumberFormatInfo constructeur de classe. Retourné NumberFormatInfo objet est en lecture/écriture.

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

using System;
using System.Globalization;

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

      nfi = System.Globalization.NumberFormatInfo.InvariantInfo;
      Console.WriteLine(nfi.IsReadOnly);               

      nfi = CultureInfo.InvariantCulture.NumberFormat;
      Console.WriteLine(nfi.IsReadOnly);               

      nfi = New NumberFormatInfo();
      Console.WriteLine(nfi.IsReadOnly);               
   }
}
// The example displays the following output:
//       True
//       True
//       False

Une culture spécifique représente une langue qui est lu dans un pays/une région particulière. Par exemple, en-US est une culture spécifique qui représente l'anglais parlé aux États-Unis et fr-CA est une culture spécifique qui représente l'anglais parlé au Canada. Vous pouvez instancier un NumberFormatInfo objet qui représente les conventions de mise en forme d'une culture spécifique comme suit :

L'exemple suivant utilise ces quatre méthodes pour créer un NumberFormatInfo objet qui reflète les conventions de mise en forme de la culture indonésien (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

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

System_CAPS_noteRemarque

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

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

Vous pouvez utiliser le code suivant pour déterminer les conventions de mise en forme de la culture spécifique 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();
   }
}

Les données spécifiques à la culture pour mettre en forme des valeurs numériques fournies par le NumberFormatInfo classe est dynamique, comme les données de culturels fournies par le CultureInfo (classe). Vous ne devez pas faire d'hypothèses sur la stabilité des valeurs pour NumberFormatInfo les objets qui sont associés aux particuliers CultureInfo objets. Seules les données fournies par la culture dite indifférente et qui lui sont associés NumberFormatInfo objet est stable. Autres données peuvent changer entre les sessions de l'application, ou même au sein d'une seule session, pour les raisons suivantes :

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

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

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

  • Préférences de l'utilisateur. Les utilisateurs de votre application peuvent remplacer certaines des valeurs associées à la culture système actuelle via les options régionales et linguistiques dans le 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 CultureInfo.UseUserOverride est définie sur true (valeur par défaut), les propriétés de la NumberFormatInfo objet sont également récupérées à partir des paramètres utilisateur.

À compter du .NET Framework 2.0, toutes les propriétés substituables par l'utilisateur d'un NumberFormatInfo objet sont initialisées lorsque l'objet est créé. Il existe toujours un risque d'incohérence, étant donné que ni la création de l'objet ni le processus de remplacement d'utilisateur n'est atomique et les valeurs pertinentes peuvent changer pendant la création d'objets. Toutefois, ces incohérences sont très rares.

Vous pouvez contrôler si les substitutions par l'utilisateur sont reflétées dans NumberFormatInfo objets qui représentent la même culture que la culture du thread actuel. Le tableau suivant répertorie la manière dont un NumberFormatInfo objet peut être récupéré et indique si l'objet résultant reflète les substitutions par l'utilisateur.

Source d'objet CultureInfo et NumberFormatInfo

Reflète les substitutions par l'utilisateur

Propriété CultureInfo.CurrentCulture.NumberFormat

Oui

Propriété NumberFormatInfo.CurrentInfo

Oui

Méthode CultureInfo.CreateSpecificCulture

Oui

Méthode CultureInfo.GetCultureInfo

Non

Constructeur CultureInfo(String)

Oui

Constructeur CultureInfo.CultureInfo(String, Boolean)

Valeur de useUserOverride paramètre

Sauf s'il existe une bonne raison de procéder autrement, vous devez respecter les substitutions par l'utilisateur lorsque vous utilisez la NumberFormatInfo objet dans les applications clientes à mettre en forme et d'analyser l'entrée utilisateur ou pour afficher des données numériques. Pour les applications serveur ou applications sans assistance, vous devez respectent pas substitutions par l'utilisateur. Toutefois, si vous utilisez la NumberFormatInfo objet soit explicitement ou implicitement pour rendre persistantes des données numériques sous forme de chaîne, vous devez utiliser un NumberFormatInfo objet qui reflète les conventions de mise en forme de la culture dite indifférente, ou vous devez spécifier une chaîne de format numérique personnalisée que vous utilisez, quelle que soit la culture.

Un NumberFormatInfo est utilisé implicitement ou explicitement dans numérique de toutes les opérations de mise en forme. Elles incluent notamment les appels aux méthodes suivantes :

Toutes les opérations de mise en forme numérique utilisent un IFormatProvider mise en œuvre. Le IFormatProvider interface inclut une méthode unique, GetFormat(Type). Il s'agit d'une méthode de rappel qui est passée un Type objet qui représente le type requis pour fournir des informations de mise en forme. La méthode est chargée de retourner une instance de ce type ou null, s'il ne peut pas fournir une instance du type. Le .NET Framework fournit deux IFormatProvider implémentations de mise en forme des nombres :

  • La CultureInfo classe qui représente une culture spécifique (ou une langue spécifique dans un pays/région spécifique). Dans une valeur numérique mise en forme d'opération, le CultureInfo.GetFormat méthode renvoie le NumberFormatInfo objet associé à son CultureInfo.NumberFormat propriété.

  • La NumberFormatInfo classe, qui fournit des informations sur les conventions de mise en forme de la culture associée. Le NumberFormatInfo.GetFormat méthode retourne une instance d'elle-même.

Si un IFormatProvider implémentation n'est fournie à une méthode de mise en forme de manière explicite, un CultureInfo objet retourné par la CultureInfo.CurrentCulture propriété qui représente la culture actuelle du thread est utilisée.

L'exemple suivant illustre la relation entre la IFormatProvider interface et la NumberFormatInfo classe mise en forme des opérations en définissant un personnalisé IFormatProvider mise en œuvre. Son GetFormat méthode affiche le nom de type de l'objet demandé par l'opération de mise en forme. Si l'interface demande un NumberFormatInfo de l'objet, cette méthode fournit le NumberFormatInfo objet pour la culture du thread en cours. Comme la sortie de l'exemple, le Decimal.ToString(IFormatProvider) de requêtes de méthode un NumberFormatInfo objet pour fournir des informations de mise en forme, tandis que le String.Format(IFormatProvider, String, Object[]) de requêtes de méthode NumberFormatInfo et DateTimeFormatInfo objets ainsi qu'un ICustomFormatter mise en œuvre.

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

Chaque opération de mise en forme utilise un standard ou une chaîne de format numérique personnalisée pour générer une chaîne de résultat à partir d'un nombre. Dans certains cas, l'utilisation d'une chaîne de format pour générer une chaîne de résultat est explicite, comme dans l'exemple suivant. Ce code appelle la Decimal.ToString(IFormatProvider) méthode pour convertir un Decimal valeur à un certain nombre de représentations sous forme de chaîne différentes 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 sans paramètre Decimal.ToString() (méthode), la valeur de la Decimal instance est mise en forme à l'aide du spécificateur de format général (« G ») et des conventions de la culture actuelle, dans ce cas est la culture en-US.

using System;

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

      foreach (var value in values) {
         string resultString = value.ToString();
         Console.WriteLine(resultString);
         Console.WriteLine();      
      }   
   }
}
// The example displays the following output:
//       1345.6538
//       
//       1921651.16

Chaque chaîne de format numérique standard utilise un ou plusieurs NumberFormatInfo Propriétés afin de déterminer le modèle ou les symboles utilisés dans la chaîne de résultat. De même, chaque spécificateur de format numérique personnalisée, sauf « 0 » et « # » insérer des symboles dans la chaîne de résultat qui sont définis par NumberFormatInfo Propriétés. Le tableau suivant répertorie la norme et les spécificateurs de format numériques personnalisés et leur sont associées NumberFormatInfo Propriétés. Pour modifier l'apparence de la chaîne de résultat pour une culture particulière, consultez la Propriétés NumberFormatInfo modification section. Pour plus d'informations sur l'utilisation de ces spécificateurs de format, consultez la page 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 de chiffres fractionnaires.

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

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

CurrencyGroupSizes, pour définir la taille des groupes intégrés.

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

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

CurrencySymbol, pour définir le symbole de devise.

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

« D » ou « d » (spécificateur de format décimal)

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

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

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

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

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

« F » ou « f » (spécificateur de format à virgule fixe)

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

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

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

« G » ou « g » (spécificateur de format général)

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

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

PositiveSign, pour définir le symbole du signe positif pour les chaînes de résultat au format exponentiel.

« N » ou « n » (spécificateur de format numérique)

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

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

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

NumberGroupSeparator, pour définir le symbole de séparateur (en milliers) de groupe.

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

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

« P » ou « p » (spécificateur de format pourcentage)

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

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

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

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

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

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

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

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

PositiveSign, pour définir le symbole du 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é d'un séparateur de groupe)

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

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

PercentSymbol, pour définir le symbole de pourcentage.

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

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

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

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

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

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

Vous pouvez modifier les propriétés d'un NumberFormatInfo objet pour personnaliser la chaîne de résultat produite dans l'opération de mise en forme numérique. Pour ce faire :

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

  2. Modifier les propriétés qui permettent de générer la chaîne de résultat souhaité. Pour plus d'informations sur l'utilisation de méthodes mise en forme NumberFormatInfo les propriétés pour définir des chaînes de résultat, consultez le mettre en forme les chaînes et les propriétés NumberFormatInfo section.

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

System_CAPS_noteRemarque

Au lieu de modifier dynamiquement les valeurs de propriété d'une culture chaque démarrage d'une application, vous pouvez utiliser la CultureAndRegionInfoBuilder classe pour définir une culture personnalisée (cultures une culture qui a un nom unique et qui complètent existante) ou une culture de remplacement (celui qui est utilisé au lieu d'une culture spécifique).

Les sections suivantes fournissent des exemples.

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

Nombre de numéros de carte d'être composés exclusivement de chiffres et donc peut facilement être mise en forme en modifiant les propriétés d'un NumberFormatInfo objet. Par exemple, un numéro de sécurité sociale aux États-Unis est composé de 9 chiffres disposés comme suit : XXX-XX-XXXX. L'exemple suivant suppose que les numéros de sécurité sociale sont stockées comme entier, valeurs 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

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és : Parse et TryParse. Le Parse méthode convertit une chaîne en un nombre et lève une exception si la conversion échoue. Le TryParse méthode convertit une chaîne en un nombre, affecte le numéro à un out argument et retourne un Boolean valeur qui indique si la conversion a réussi.

Les méthodes d'analyse implicitement ou explicitement utilisent un NumberStyles valeur d'énumération pour déterminer quels éléments de style (tels que les séparateurs de groupes, un séparateur de décimale ou un symbole de devise) peuvent être présents dans une chaîne si l'opération d'analyse aboutisse. Si un NumberStyles valeur n'est pas fourni dans l'appel de méthode, la valeur par défaut est un NumberStyles valeur qui inclut le Float et AllowThousands indicateurs, qui indique que la chaîne analysée peut inclure des symboles de groupe, un séparateur décimal, un signe négatif et espaces blancs, ou il peut être la représentation sous forme de chaîne d'un nombre en notation exponentielle.

Les méthodes d'analyse également implicitement ou explicitement utilisent un NumberFormatInfo qui définit les symboles spécifiques et des modèles qui peut se produire dans la chaîne à analyser. Si un NumberFormatInfo objet n'est pas fourni, la valeur par défaut est le NumberFormatInfo pour la culture du thread actuel. Pour plus d'informations sur l'analyse, consultez les méthodes d'analyse individuels, tels 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 sensible à la culture de l'analyse de chaînes. Il essaie d'analyser une chaîne qui inclut des milliers séparateurs en utilisant les conventions de l'en-US, fr-FR et culture dite indifférente. Une chaîne qui inclut la virgule comme séparateur de groupes et de la période comme un séparateur décimal ne parvient pas à analyser dans la culture fr-FR et une chaîne avec white space comme un séparateur de groupes et d'une virgule comme séparateur décimal ne parvient pas à analyser dans l'en-US et la culture dite indifférente.

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 en règle générale se produit dans deux contextes :

  • En tant qu'opération qui est conçu pour convertir l'entrée d'utilisateur en une valeur numérique.

  • En tant qu'opération qui est conçue pour effectuer un aller-retour d'une valeur numérique ; Autrement dit, pour désérialiser une valeur numérique qui a été précédemment sérialisée en tant que chaîne.

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

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

L'exemple suivant illustre la différence entre une opération d'analyse qui reflète les paramètres de culture d'utilisateur et l'autre pas. Dans ce cas, la culture par défaut du système est en-US, mais l'utilisateur a défini «, » comme séparateur décimal et «. » comme séparateur de groupe dans le panneau de configuration, région et langue. En règle générale, ces symboles sont inversées 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 NumberFormatInfo objet qui reflète également des paramètres utilisateur (annule), l'opération d'analyse renvoie un résultat correct. Toutefois, lorsque la chaîne est analysée par un NumberFormatInfo objet qui reflète les paramètres de culture en-US standard, il le symbole de virgule un séparateur de groupes des erreurs 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

Lorsque des données numériques sont sérialisées au format de chaîne et plus tard désérialisées et analysées, les chaînes doivent être générés et analysés en utilisant les conventions de la culture dite indifférente. Les opérations de mise en forme et l'analyse ne doivent jamais reflètent les conventions d'une culture spécifique. Si les paramètres spécifiques à la culture sont utilisées, la portabilité des données est strictement limitée ; Il peut être désérialisé avec succès uniquement sur un thread dont les paramètres spécifiques à la culture sont identiques à ceux du thread sur lequel il a été sérialisé. Dans certains cas, cela signifie que les données ne peuvent même être désérialisés avec succès sur le même système que celui 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 le tableau sont convertis 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 en-GB. Dans ce cas, chaque opération d'analyse réussit, les données ne fait pas un aller-retour avec succès et l'endommagement des données. Dans d'autres cas, une opération d'analyse peut échouer et un FormatException exception peut être levée.

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

public class Example
{
   public static void Main()
   {
      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 NumberFormatInfo objet correspondante CultureInfo de l'objet et utilise l'objet récupéré au numéro de requête mise en forme 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'

Universal Windows Platform
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 2.0
Windows Phone Silverlight
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

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

Retour au début
Afficher:
© 2016 Microsoft