NumberFormatInfo Classe

Définition

public ref class NumberFormatInfo sealed : IFormatProvider

public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider

public sealed class NumberFormatInfo : IFormatProvider

public sealed class NumberFormatInfo : ICloneable, IFormatProvider

[System.Serializable]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider

type NumberFormatInfo = class
    interface IFormatProvider

type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider

[<System.Serializable>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider

Public NotInheritable Class NumberFormatInfo
Implements IFormatProvider

Public NotInheritable Class NumberFormatInfo
Implements ICloneable, IFormatProvider

Héritage

Object

NumberFormatInfo

Attributs

SerializableAttribute ComVisibleAttribute

Implémente

IFormatProvider ICloneable

Remarques

La NumberFormatInfo classe contient des informations propres à la culture utilisées lorsque vous mettez en forme et analysez des valeurs numériques. Ces informations incluent le symbole monétaire, le symbole décimal, le symbole séparateur de groupe et les symboles des signes positifs et négatifs.

Instancier un objet NumberFormatInfo

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

Instancier un objet NumberFormatInfo pour la culture actuelle

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

• En récupérant un objet CultureInfo à partir de la propriété CultureInfo.CurrentCulture qui représente la culture actuelle, et en récupérant l'objet NumberFormatInfo à partir de sa propriété CultureInfo.NumberFormat.

• En récupérant l’objet NumberFormatInfo retourné par la propriété static (Shared en Visual Basic) CurrentInfo.

• En appelant la méthode GetInstance avec un objet CultureInfo qui représente la culture actuelle.

L’exemple suivant utilise ces trois façons de créer NumberFormatInfo des objets qui représentent les conventions de mise en forme de la culture actuelle. Il récupère également la valeur de la IsReadOnly propriété pour illustrer que chaque objet est en lecture seule.

using System;
using System.Globalization;

public class InstantiateEx1
{
    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 NumberFormatInfo inscriptible qui représente les conventions de la culture actuelle de l'une des manières suivantes :

• En récupérant un NumberFormatInfo objet de l’une des façons illustrées dans l’exemple de code précédent et en appelant la Clone méthode sur l’objet retourné NumberFormatInfo . Cela crée une copie de l’objet d’origine NumberFormatInfo , sauf que sa IsReadOnly propriété est false.

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

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

using System;
using System.Globalization;

public class InstantiateEx2
{
    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 remplacer certaines des valeurs de propriété utilisées dans les opérations de NumberFormatInfo mise en forme et d’analyse numériques via l’élément Région et Langue dans le Panneau de configuration. Par exemple, un utilisateur dont la culture est l’anglais (États-Unis) peut choisir d’afficher les valeurs monétaires sous la forme de 1,1 USD au lieu de la valeur par défaut de 1,1 $. Les objets NumberFormatInfo récupérés de la manière précédemment décrite reflètent tous ces remplacements effectués par utilisateur. Si cela n’est pas souhaitable, vous pouvez créer un objet NumberFormatInfo qui ne reflète pas les remplacements utilisateur (et qui est également en lecture/écriture plutôt qu’en lecture seule) en appelant le constructeur CultureInfo.CultureInfo(String, Boolean) et en fournissant une valeur false pour l’argument useUserOverride. L’exemple suivant fournit une illustration d’un système dont la culture actuelle est l’anglais (États-Unis) et dont le symbole monétaire a été modifié de la valeur par défaut de $ à USD.

using System;
using System.Globalization;

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

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

        culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
        Console.WriteLine($"Culture Name:    {culture.Name}");
        Console.WriteLine($"User Overrides:  {culture.UseUserOverride}");
        Console.WriteLine($"Currency Symbol: {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 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 ne sont pas compatibles avec la culture associée à l’objet CultureInfo (par exemple, si le calendrier sélectionné n’est pas l’un des calendriers répertoriés par la OptionalCalendars propriété), les résultats des méthodes et les valeurs des propriétés ne sont pas définis.

Instancier un objet NumberFormatInfo pour la culture invariante

La culture invariante représente une culture qui ne dépend pas de la culture. Il est basé sur la langue anglaise, mais pas sur un pays/région anglophone spécifique. Même si les données de cultures spécifiques peuvent être dynamiques et peuvent changer pour refléter de nouvelles conventions culturelles ou des préférences utilisateur, les données de la culture invariante ne changent pas. Un NumberFormatInfo objet qui représente les conventions de mise en forme de la culture invariante peut être utilisé pour les opérations de mise en forme dans lesquelles les chaînes de résultat ne doivent pas varier selon la culture.

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

• En extrayant la valeur de la propriété InvariantInfo. L’objet NumberFormatInfo retourné est en lecture seule.

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

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

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

using System;
using System.Globalization;

public class InstantiateEx4
{
    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

Instancier un objet NumberFormatInfo pour une culture spécifique

Une culture spécifique représente une langue parlée dans un pays ou une région spécifique. Par exemple, en-US est une culture spécifique qui représente la langue anglaise parlée aux États-Unis, et en-CA est une culture spécifique qui représente la langue anglaise parlée au 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 :

• En appelant la méthode CultureInfo.GetCultureInfo(String) et en récupérant la valeur de la propriété CultureInfo de l’objet NumberFormat retourné. L’objet NumberFormatInfo retourné est en lecture seule.

• En transmettant un objet CultureInfo qui représente la culture dont vous souhaitez récupérer l'objet NumberFormatInfo à la méthode statique GetInstance. L’objet NumberFormatInfo retourné est en lecture/écriture.

• En appelant la méthode CultureInfo.CreateSpecificCulture et en récupérant la valeur de la propriété CultureInfo de l’objet NumberFormat retourné. L’objet NumberFormatInfo retourné est en lecture/écriture.

• En appelant l'un des constructeurs de la classe CultureInfo.CultureInfo et en récupérant la valeur de la propriété CultureInfo de l'objet NumberFormat retourné. L’objet NumberFormatInfo retourné est en lecture/écriture.

L’exemple suivant utilise ces quatre façons de 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 InstantiateEx5
{
    public static void Main()
    {
        CultureInfo culture;
        NumberFormatInfo nfi;

        nfi = CultureInfo.GetCultureInfo("id-ID").NumberFormat;
        Console.WriteLine($"Read-only: {nfi.IsReadOnly}");

        culture = new CultureInfo("id-ID");
        nfi = NumberFormatInfo.GetInstance(culture);
        Console.WriteLine($"Read-only: {nfi.IsReadOnly}");

        culture = CultureInfo.CreateSpecificCulture("id-ID");
        nfi = culture.NumberFormat;
        Console.WriteLine($"Read-only: {nfi.IsReadOnly}");

        culture = new CultureInfo("id-ID");
        nfi = culture.NumberFormat;
        Console.WriteLine($"Read-only: {nfi.IsReadOnly}");
    }
}
// The example displays the following output:
//       Read-only: True
//       Read-only: False
//       Read-only: False
//       Read-only: False

Instancier un objet NumberFormatInfo pour une culture neutre

Une culture neutre représente une culture ou une langue indépendante d’un pays/région. Il est habituellement la source d'une ou plusieurs cultures spécifiques. Par exemple, fr est une culture neutre pour la langue française et est la base 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.

Toutefois, étant donné qu’elle est indépendante d’un pays/région spécifique, une culture neutre n’a pas d’informations de mise en forme propres à la culture. Au lieu de remplir l’objet NumberFormatInfo avec des valeurs génériques, .NET retourne un NumberFormatInfo objet qui reflète les conventions de mise en forme d’une culture spécifique qui est un enfant de la culture neutre. Par exemple, l’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 du code comme suit pour déterminer quelles conventions de mise en forme de la culture spécifique représentent chaque culture neutre.

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

public class InstantiateEx6
{
    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 '{name}' matches '{ci.Name}'");
                hasOneMatch = true;
            }
        }
        if (!hasOneMatch)
            Console.WriteLine($"NumberFormatInfo object for '{name}' --> No Match");

        Console.WriteLine();
    }
}

Données dynamiques

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

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

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

• Modifications en cascade des valeurs de propriété. Un certain nombre de propriétés liées à la culture peuvent changer au moment de l’exécution, ce qui, à son tour, entraîne NumberFormatInfo la modification des données. Par exemple, la culture actuelle peut être changée par programmation ou via une action de l’utilisateur. Quand cela se produit, l’objet NumberFormatInfo retourné par la propriété CurrentInfo devient un objet associé à la culture actuelle.

• Préférences de l’utilisateur. Les utilisateurs de votre application peuvent remplacer certaines des valeurs associées à la culture système actuelle par le biais de la région et des options de langue dans le Panneau de configuration. Par exemple, les utilisateurs peuvent choisir un symbole monétaire différent ou un autre symbole de séparateur décimal. Si la CultureInfo.UseUserOverride propriété est définie true sur (sa valeur par défaut), les propriétés de l’objet NumberFormatInfo sont également récupérées à partir des paramètres utilisateur.

Toutes les propriétés substituables par l’utilisateur d’un NumberFormatInfo objet sont initialisées lors de la création de l’objet. Il existe toujours une possibilité d’incohérence, car ni la création d’objets ni le processus de remplacement de l’utilisateur n’est atomique, et les valeurs pertinentes peuvent changer lors de la création d’objets. Toutefois, ces incohérences devraient être extrêmement rares.

Vous pouvez contrôler si les remplacements de l’utilisateur sont reflétés dans les objets NumberFormatInfo représentant la même culture que celle de la culture actuelle. Le tableau suivant répertorie les façons dont un objet NumberFormatInfo peut être récupéré et indique si l'objet résultant reflète les modifications effectuées par l'utilisateur.

Source de l’objet CultureInfo et NumberFormatInfo	Reflète les remplacements de l’utilisateur
propriété CultureInfo.CurrentCulture.NumberFormat	Yes
propriété NumberFormatInfo.CurrentInfo	Yes
méthode CultureInfo.CreateSpecificCulture	Yes
méthode CultureInfo.GetCultureInfo	No
Constructeur CultureInfo(String)	Yes
Constructeur CultureInfo.CultureInfo(String, Boolean)	Dépend de la valeur du paramètre useUserOverride

Sauf s'il existe une raison convaincante de faire autrement, vous devez respecter les paramètres personnalisés de l'utilisateur lorsque vous utilisez l'objet NumberFormatInfo dans les applications clientes pour formater et analyser les données saisies par l'utilisateur ou pour afficher des données numériques. Pour les applications serveur ou les applications sans assistance, vous ne devez pas respecter les remplacements utilisateur. Toutefois, si vous utilisez l’objet NumberFormatInfo explicitement ou implicitement pour conserver 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 invariante, ou 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 NumberFormatInfo objet est utilisé implicitement ou explicitement dans toutes les opérations de mise en forme numérique. Ceci inclut les appels aux méthodes suivantes :

• Toutes les méthodes de mise en forme numériques, telles que Int32.ToString, Double.ToStringet Convert.ToString(Int32).

• Méthode de mise en forme composite principale, String.Format.

• Autres méthodes de mise en forme composite, telles que Console.WriteLine(String, Object[]) et StringBuilder.AppendFormat(String, Object[]).

Toutes les opérations de mise en forme numérique utilisent une IFormatProvider implémentation. L’interface IFormatProvider comprend une seule méthode, GetFormat(Type). Il s’agit d’une fonction de rappel qui reçoit un objet Type représentant le type nécessaire pour fournir des informations sur la mise en forme. La méthode est chargée de retourner une instance de ce type ou null, si elle ne peut pas fournir une instance du type. .NET fournit deux IFormatProvider implémentations pour la mise en forme des nombres :

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

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

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

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

using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
    public Object GetFormat(Type formatType)
    {
        Console.WriteLine($"Requesting an object of type {formatType.Name}");
        if (formatType == typeof(NumberFormatInfo))
            return NumberFormatInfo.CurrentInfo;
        else if (formatType == typeof(DateTimeFormatInfo))
            return DateTimeFormatInfo.CurrentInfo;
        else
            return null;
    }
}

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

Mettre en forme des chaînes et des propriétés NumberFormatInfo

Chaque opération de mise en forme utilise une chaîne de format numérique standard ou personnalisée pour produire une chaîne de résultat à partir d’un nombre. Dans certains cas, l’utilisation d’une chaîne de format pour produire une chaîne de résultat est explicite, comme dans l’exemple suivant. Ce code appelle la Decimal.ToString(IFormatProvider) méthode pour convertir une Decimal valeur en plusieurs représentations sous forme de chaînes à l’aide des conventions de mise en forme de la culture en-US.

using System;
using System.Globalization;

public class PropertiesEx1
{
    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 suivants à la méthode par défaut ou sans Decimal.ToString() paramètre, la valeur de l’instance Decimal est mise en forme à l’aide du spécificateur de format général (« G ») et des conventions de la culture actuelle, qui, dans ce cas, est la culture en-US.

using System;

public class PropertiesEx2
{
    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 NumberFormatInfo propriétés pour déterminer le modèle ou les symboles utilisés dans la chaîne de résultat. De même, chaque spécificateur de format numérique personnalisé, sauf « 0 » et « # », insèrent des symboles dans la chaîne de résultats définis par les propriétés de NumberFormatInfo. Le tableau suivant répertorie les spécificateurs de format numérique standard et personnalisés et leurs propriétés associées NumberFormatInfo . Pour modifier l’apparence de la chaîne de résultat pour une culture particulière, consultez la section Modifier les propriétés NumberFormatInfo . Pour plus d’informations sur l’utilisation de ces spécificateurs de format, consultez Chaînes de format numérique standard et chaînes de format numérique 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 fractionnels. CurrencyDecimalSeparator, pour définir le symbole de séparateur décimal. CurrencyGroupSeparator, pour définir le séparateur de groupes ou de milliers. CurrencyGroupSizes, pour définir les tailles des groupes intégraux. CurrencyNegativePattern, pour définir le modèle de valeurs monétaires négatives. CurrencyPositivePattern, pour définir le modèle de valeurs monétaires positives. CurrencySymbol, pour définir le symbole monétaire. NegativeSign, pour définir le symbole de signe négatif.
« D » ou « d » (spécificateur de format décimal)	NegativeSign, pour définir le symbole de signe négatif.
« E » ou « e » (spécificateur de format exponentiel ou scientifique)	NegativeSign, pour définir le symbole de signe négatif de la mantisse et de l’exposant. NumberDecimalSeparator, pour définir le symbole de séparateur décimal. PositiveSign, pour définir le symbole de signe positif dans l’exposant.
« F » ou « f » (spécificateur de format à virgule fixe).	NegativeSign, pour définir le symbole de signe négatif. NumberDecimalDigits, pour définir le nombre par défaut de chiffres fractionnels. NumberDecimalSeparator, pour définir le symbole de séparateur décimal.
« G » ou « g » (spécificateur de format général)	NegativeSign, pour définir le symbole de signe négatif. NumberDecimalSeparator, pour définir le symbole de séparateur décimal. PositiveSign, pour définir le symbole de signe positif pour les chaînes de résultat au format exponentiel.
« N » ou « n » (spécificateur de format de nombre)	NegativeSign, pour définir le symbole de signe négatif. NumberDecimalDigits, pour définir le nombre par défaut de chiffres fractionnels. NumberDecimalSeparator, pour définir le symbole de séparateur décimal. NumberGroupSeparator, pour définir le symbole séparateur de groupe (milliers). NumberGroupSizes, pour définir le nombre de chiffres intégraux dans un groupe. NumberNegativePattern, pour définir le format des valeurs négatives.
« P » ou « p » (spécificateur de format pourcentage)	NegativeSign, pour définir le symbole de signe négatif. PercentDecimalDigits, pour définir le nombre par défaut de chiffres fractionnels. 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 dans un groupe. PercentNegativePattern, pour définir le placement du symbole de pourcentage et le symbole négatif pour les valeurs négatives. PercentPositivePattern, pour définir le placement du symbole de pourcentage pour les valeurs positives. PercentSymbol, pour définir le symbole de pourcentage.
« R » ou « r » (spécificateur de format aller-retour)	NegativeSign, pour définir le symbole de signe négatif. NumberDecimalSeparator, pour définir le symbole de séparateur décimal. PositiveSign, pour définir le symbole de signe positif dans un exposant.
« X » ou « x » (spécificateur de format hexadécimal)	None.
« . » (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 groupe)	NumberGroupSeparator, pour définir le symbole de séparateur de groupes (milliers).
« % » (spécificateur de format personnalisé d’espace réservé de pourcentage)	PercentSymbol, pour définir le symbole de pourcentage.
« ‰ » (spécificateur de format personnalisé d’espace réservé pour mille)	PerMilleSymbol, pour définir le symbole pour mille.
« E » (spécificateur de format personnalisé de notation exponentielle)	NegativeSign, pour définir le symbole de signe négatif de la mantisse et de l’exposant. PositiveSign, pour définir le symbole de signe positif dans l’exposant.

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

Modifier les propriétés NumberFormatInfo

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

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

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

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

Les sections suivantes fournissent quelques exemples.

Modifier le symbole et le modèle monétaire

L’exemple suivant modifie un NumberFormatInfo objet qui représente les conventions de mise en forme de la culture en-US. Il affecte le symbole monétaire ISO-4217 à la CurrencySymbol propriété et définit un modèle pour les valeurs monétaires qui se compose du symbole monétaire suivi d’un espace et d’une valeur numérique.

using System;
using System.Globalization;

public class Example
{
    public static void Main()
    {
        // Retrieve a writable NumberFormatInfo object.
        CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
        NumberFormatInfo nfi = enUS.NumberFormat;

        // Use the ISO currency symbol instead of the native currency symbol.
        nfi.CurrencySymbol = (new RegionInfo(enUS.Name)).ISOCurrencySymbol;
        // Change the positive currency pattern to <code><space><value>.
        nfi.CurrencyPositivePattern = 2;
        // Change the negative currency pattern to <code><space><sign><value>.
        nfi.CurrencyNegativePattern = 12;

        // Produce the result strings by calling ToString.
        Decimal[] values = { 1065.23m, 19.89m, -.03m, -175902.32m };
        foreach (var value in values)
            Console.WriteLine(value.ToString("C", enUS));

        Console.WriteLine();

        // Produce the result strings by calling a composite formatting method.
        foreach (var value in values)
            Console.WriteLine(String.Format(enUS, "{0:C}", value));
    }
}
// The example displays the following output:
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32
//
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32

Mettre en forme un numéro d’identification national

De nombreux numéros d’identification nationaux se composent exclusivement de chiffres et peuvent donc être facilement mis en forme en modifiant les propriétés d’un NumberFormatInfo objet. Par exemple, un numéro de sécurité sociale aux États-Unis se compose de 9 chiffres organisés comme suit : XXX-XX-XXXX. L’exemple suivant part du principe que les numéros de sécurité sociale sont stockés sous forme de valeurs entières et les mettez en forme de manière appropriée.

using System;
using System.Globalization;

public class CustomizeSSNEx
{
    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

Analyser des chaînes de nombres

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

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

Les méthodes d’analyse utilisent aussi implicitement ou explicitement un objet NumberFormatInfo qui définit les symboles et les modèles spécifiques qui peuvent se trouver dans la chaîne à analyser. Si un NumberFormatInfo objet n'est pas fourni, la valeur par défaut correspond à NumberFormatInfo pour la culture actuelle. Pour plus d’informations sur l’analyse, consultez les méthodes d’analyse individuelles, telles que Int16.Parse(String), , Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double)et BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

L’exemple suivant illustre la nature sensible à la culture de l'analyse syntaxique des chaînes. Il tente d’analyser une chaîne qui inclut des milliers de séparateurs à l’aide des conventions du en-US, fr-FR et des cultures invariantes. Une chaîne qui inclut la virgule en tant que séparateur de groupe et le point comme séparateur décimal ne parvient pas à analyser dans la culture fr-FR, et une chaîne avec un espace blanc comme séparateur de groupe et une virgule comme séparateur décimal ne parvient pas à analyser dans les cultures en-US et invariantes.

using System;
using System.Globalization;

public class ParseEx1
{
    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($"'{value}' --> {amount} ({name})");
                }
                catch (FormatException)
                {
                    Console.WriteLine($"'{value}': FormatException ({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 utilisateur en valeur numérique.

• En tant qu'opération conçue pour effectuer un aller-retour d'une valeur numérique, c'est-à-dire pour désérialiser une valeur numérique qui a été précédemment sérialisée sous forme de chaîne.

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

Analyser les chaînes de caractères utilisateur

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

L’exemple suivant illustre la différence entre une opération d’analyse qui reflète les paramètres culturels de l’utilisateur et l’autre qui ne le fait pas. Dans ce cas, la culture système par défaut est en-US, mais l’utilisateur a défini « », comme symbole décimal et « . » comme séparateur de groupe dans le Panneau de configuration, la région et la langue. En règle générale, ces symboles sont inversés dans la culture en-US par défaut. Lorsque l’utilisateur entre une chaîne qui reflète les paramètres utilisateur et que la chaîne est analysée par un NumberFormatInfo objet qui reflète également les paramètres utilisateur (remplacements), l’opération d’analyse retourne un résultat correct. Toutefois, lorsque la chaîne est analysée par un NumberFormatInfo objet qui reflète des paramètres culturels standard en-US, il trompe le symbole de virgule pour un séparateur de groupe et retourne un résultat incorrect.

using System;
using System.Globalization;

public class ParseUserEx
{
    public static void Main()
    {
        CultureInfo stdCulture = CultureInfo.GetCultureInfo("en-US");
        CultureInfo custCulture = CultureInfo.CreateSpecificCulture("en-US");

        String value = "310,16";
        try
        {
            Console.WriteLine($"{stdCulture.Name} culture reflects user overrides: {stdCulture.UseUserOverride}");
            Decimal amount = Decimal.Parse(value, stdCulture);
            Console.WriteLine($"'{value}' --> {amount.ToString(CultureInfo.InvariantCulture)}");
        }
        catch (FormatException)
        {
            Console.WriteLine($"Unable to parse '{value}'");
        }
        Console.WriteLine();

        try
        {
            Console.WriteLine($"{custCulture.Name} culture reflects user overrides: {custCulture.UseUserOverride}");
            Decimal amount = Decimal.Parse(value, custCulture);
            Console.WriteLine($"'{value}' --> {amount.ToString(CultureInfo.InvariantCulture)}");
        }
        catch (FormatException)
        {
            Console.WriteLine($"Unable to parse '{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

Sérialiser et désérialiser des données numériques

Lorsque les données numériques sont sérialisées au format de chaîne et qu’elles sont désérialisées et analysées ultérieurement, les chaînes doivent être générées et analysées à l’aide des conventions de la culture invariante. Les opérations de mise en forme et 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 désérialisée uniquement sur un thread dont les paramètres propres à la culture sont identiques à ceux du thread sur lequel il a été sérialisé. Dans certains cas, cela signifie que les données ne peuvent même pas être désérialisées avec succès sur le même système sur lequel elles ont été sérialisées.

L’exemple suivant illustre ce qui peut se produire lorsque ce principe est violé. Les valeurs à virgule flottante d’un tableau sont converties en chaînes lorsque le thread actuel utilise les paramètres spécifiques à la culture en-US. Les données sont ensuite analysées par un thread qui utilise les paramètres spécifiques à la culture pt-BR. Dans ce cas, bien que chaque opération d'analyse réussisse, les données ne sont pas renvoyées correctement et une corruption des données se produit. Dans d’autres cas, une opération d’analyse peut échouer et une FormatException exception peut être levée.

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

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

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

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

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

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

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

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

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

Example

  The following example shows how to retrieve a <xref:System.Globalization.NumberFormatInfo> object for a corresponding <xref:System.Globalization.CultureInfo> object, and use the retrieved object to query number formatting information for the particular culture.

  :::code language="csharp" source="~/snippets/csharp/System.Globalization/NumberFormatInfo/Overview/NumberFormatInfo.cs" id="Snippet1":::
  :::code language="vb" source="~/snippets/visualbasic/System.Globalization/NumberFormatInfo/Overview/numberformatinfo.vb" id="Snippet1":::

Voir aussi

• CultureInfo
• IFormatProvider
• Chaînes de format numérique personnalisées