Informations
Le sujet que vous avez demandé est indiqué ci-dessous. Toutefois, ce sujet ne figure pas dans la bibliothèque.

Single.Parse, méthode (String, IFormatProvider)

Convertit la chaîne d'un nombre dans un format propre à la culture spécifiée en nombre à virgule flottante simple précision équivalent.

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

public static float Parse (
	string s,
	IFormatProvider provider
)
public static float Parse (
	String s, 
	IFormatProvider provider
)
public static function Parse (
	s : String, 
	provider : IFormatProvider
) : float
Non applicable.

Paramètres

s

Chaîne représentant un nombre à convertir.

provider

IFormatProvider qui fournit des informations de format propres à la culture concernant s.

Valeur de retour

Nombre à virgule flottante simple précision équivalant à la valeur numérique ou au symbole spécifié dans s.

Type d'exceptionCondition

ArgumentNullException

s est référence Null (Nothing en Visual Basic).

FormatException

s n'est pas un nombre au format valide.

OverflowException

s représente un nombre inférieur à MinValue ou supérieur à MaxValue.

Le paramètre s peut contenir PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol ou une chaîne se présentant comme suit :

[ws][signe]chiffres intégraux[.[chiffres fractionnaires]][e[signe]chiffres exponentiels][ws]

Les éléments facultatifs sont encadrés par des crochets ([ et ]). Les éléments contenant le terme « chiffres » consistent en une série de caractères numériques compris entre 0 et 9.

ws

Série d'espaces blancs.

signe

Symbole négatif ou positif.

chiffres intégraux

Série de chiffres spécifiant la partie intégrale du nombre. Des séquences de chiffres intégraux peuvent être partitionnées par un symbole séparateur de groupe. (Par exemple, dans certaines cultures, une virgule (,) sépare les groupes de milliers.) Les chiffres intégraux peuvent être absents s'il y a des chiffres fractionnaires.

'.'

Symbole de séparateur décimal spécifique à la culture.

chiffres fractionnaires

Série de chiffres spécifiant la partie fractionnaire du nombre.

'e'

Caractère 'e' en majuscule ou minuscule, indiquant la notation (scientifique) exponentielle.

chiffres exponentiels

Série de chiffres spécifiant un exposant.

Voici quelques exemples de s : "100", "-123 456 789", "123.45e+6", "+500", "5e2", "3,1416", "600", "-0,123" et "-Infini".

Cette version de Parse utilise les valeurs NumberStyles, Float et AllowThousands, ainsi que les informations sur le format numérique spécifiées. Si provider est référence Null (Nothing en Visual Basic) ou si NumberFormatInfo ne peut pas être obtenu, les informations de mise en forme relatives à la culture système en cours sont alors utilisées.

Pour plus d'informations sur les formats numériques, consultez la rubrique Vue d'ensemble des formats.

Si un séparateur est rencontré dans le paramètre s au cours d'une opération d'analyse et que la devise ou le nombre décimal applicables et les séparateurs de groupes sont identiques, l'opération d'analyse suppose que le séparateur est un séparateur décimal plutôt qu'un séparateur de groupes. Pour plus d'informations sur les séparateurs, consultez CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator et NumberGroupSeparator.

L'exemple de code suivant analyse des représentations String de valeurs Single avec la méthode Parse, à l'aide d'un objet IFormatProvider.

// Example of the Single.Parse( ) methods.
using System;
using System.Globalization;

class SingleParseDemo
{
    // Get the exception type name; remove the namespace prefix.
    static string GetExceptionType( Exception ex )
    {
        string exceptionType = ex.GetType( ).ToString( );
        return exceptionType.Substring( 
            exceptionType.LastIndexOf( '.' )+1 );
    }

    // Parse each string in the singleFormats array, using 
    // NumberStyles and IFormatProvider, if specified.
    static void SingleParse( NumberStyles styles, 
        IFormatProvider provider )
    {
        string[ ] singleFormats = {
            " 987.654E-2",   " 987,654E-2",    "(98765,43210)", 
            "9,876,543.210", "9.876.543,210",  "98_76_54_32,19" };
            
        foreach( string singleString in singleFormats )
        {
            float singleNumber;

            // Display the first part of the output line.
            Console.Write( "  Parse of {0,-20}", 
                String.Format( "\"{0}\"", singleString ) );

            try
            {
                // Use the appropriate Single.Parse overload, based 
                // on the parameters that are specified.
                if( provider == null )
                {
                    if( styles < 0 )
                        singleNumber = Single.Parse( singleString );
                    else
                        singleNumber = 
                            Single.Parse( singleString, styles );
                }
                else if( styles < 0 )
                    singleNumber = 
                        Single.Parse( singleString, provider );
                else
                    singleNumber = 
                        Single.Parse( singleString, styles, provider );
                
                // Display the resulting value if Parse succeeded.
                Console.WriteLine( "success: {0}", singleNumber );
            }
            catch( Exception ex )
            {
                // Display the exception type if Parse failed.
                Console.WriteLine( "failed:  {0}", 
                    GetExceptionType( ex ) );
            }
        }
    }
    
    public static void Main( )
    {
        Console.WriteLine( "This example of\n" +
            "  Single.Parse( String ),\n" +
            "  Single.Parse( String, NumberStyles ),\n" +
            "  Single.Parse( String, IFormatProvider ), and\n" +
            "  Single.Parse( String, NumberStyles, " +
            "IFormatProvider )\ngenerates the " +
            "following output when run in the [{0}] culture.", 
            CultureInfo.CurrentCulture.Name );
        Console.WriteLine( "Several string representations " +
            "of Single values are parsed." );

        // Do not use IFormatProvider or NumberStyles.
        Console.WriteLine( "\nNumberStyles and IFormatProvider " +
            "are not used; current culture is [{0}]:", 
            CultureInfo.CurrentCulture.Name );
        SingleParse( ( (NumberStyles)( -1 ) ), null );

        // Use the NumberStyle for Currency.
        Console.WriteLine( "\nNumberStyles.Currency " +
            "is used; IFormatProvider is not used:" );
        SingleParse( NumberStyles.Currency, null );
            
        // Create a CultureInfo object for another culture. Use
        // [Dutch - The Netherlands] unless the current culture
        // is Dutch language. In that case use [English - U.S.].
        string cultureName = 
            CultureInfo.CurrentCulture.Name.Substring( 0, 2 ) == "nl" ?
                "en-US" : "nl-NL";
        CultureInfo culture = new CultureInfo( cultureName );
            
        Console.WriteLine( "\nNumberStyles is not used; " +
            "[{0}] culture IFormatProvider is used:", 
            culture.Name );
        SingleParse( ( (NumberStyles)( -1 ) ), culture );
            
        // Get the NumberFormatInfo object from CultureInfo, and
        // then change the digit group size to 2 and the digit
        // separator to '_'.
        NumberFormatInfo numInfo = culture.NumberFormat;
        numInfo.NumberGroupSizes = new int[ ] { 2 };
        numInfo.NumberGroupSeparator = "_";
            
        // Use the NumberFormatInfo object as the IFormatProvider.
        Console.WriteLine( "\nNumberStyles.Currency is used, " +
            "group size = 2, separator = \"_\":" );
        SingleParse( NumberStyles.Currency, numInfo );
    }
}

/*
This example of
  Single.Parse( String ),
  Single.Parse( String, NumberStyles ),
  Single.Parse( String, IFormatProvider ), and
  Single.Parse( String, NumberStyles, IFormatProvider )
generates the following output when run in the [en-US] culture.
Several string representations of Single values are parsed.

NumberStyles and IFormatProvider are not used; current culture is [en-US]:
  Parse of " 987.654E-2"       success: 9.87654
  Parse of " 987,654E-2"       success: 9876.54
  Parse of "(98765,43210)"     failed:  FormatException
  Parse of "9,876,543.210"     success: 9876543
  Parse of "9.876.543,210"     failed:  FormatException
  Parse of "98_76_54_32,19"    failed:  FormatException

NumberStyles.Currency is used; IFormatProvider is not used:
  Parse of " 987.654E-2"       failed:  FormatException
  Parse of " 987,654E-2"       failed:  FormatException
  Parse of "(98765,43210)"     success: -9.876543E+09
  Parse of "9,876,543.210"     success: 9876543
  Parse of "9.876.543,210"     failed:  FormatException
  Parse of "98_76_54_32,19"    failed:  FormatException

NumberStyles is not used; [nl-NL] culture IFormatProvider is used:
  Parse of " 987.654E-2"       success: 9876.54
  Parse of " 987,654E-2"       success: 9.87654
  Parse of "(98765,43210)"     failed:  FormatException
  Parse of "9,876,543.210"     failed:  FormatException
  Parse of "9.876.543,210"     success: 9876543
  Parse of "98_76_54_32,19"    failed:  FormatException

NumberStyles.Currency is used, group size = 2, separator = "_":
  Parse of " 987.654E-2"       failed:  FormatException
  Parse of " 987,654E-2"       failed:  FormatException
  Parse of "(98765,43210)"     success: -98765.43
  Parse of "9,876,543.210"     failed:  FormatException
  Parse of "9.876.543,210"     success: 9876543
  Parse of "98_76_54_32,19"    success: 9.876543E+07
*/ 

// Example of the Single.Parse( ) methods.
import System.*;
import System.Globalization.*;
import System.Exception;

class SingleParseDemo
{
    // Get the exception type name; remove the namespace prefix.
    static String GetExceptionType(Exception ex)
    {
        String exceptionType = ex.GetType().ToString();

        return exceptionType.Substring((exceptionType.LastIndexOf('.') + 1));
    } //GetExceptionType

    // Parse each string in the singleFormats array, using 
    // NumberStyles and IFormatProvider, if specified.
    static void SingleParse(NumberStyles styles, IFormatProvider provider)
    {
        String singleFormats[] = {" 987.654E-2", " 987,654E-2", 
            "(98765,43210)", "9,876,543.210", "9.876.543,210", 
            "98_76_54_32,19" };
        for(int iCtr = 0; iCtr < singleFormats.length; iCtr++) {
            String singleString = singleFormats[iCtr];
            float singleNumber;

            // Display the first part of the output line.
            Console.Write("  Parse of {0,-20}", String.Format("\"{0}\"", 
                singleString));
            try {
                // Use the appropriate Single.Parse overload, based 
                // on the parameters that are specified.
                if(provider == null) {
                    if(styles.GetHashCode() < 0) {
                        singleNumber = Single.Parse(singleString);
                    }
                    else {
                        singleNumber = Single.Parse(singleString, styles);
                    }
                }
                else {
                    if(styles.GetHashCode() < 0) {
                        singleNumber = Single.Parse(singleString, provider);
                    }
                    else {
                        singleNumber = Single.Parse(singleString, styles, 
                            provider);
                    }
                }

                // Display the resulting value if Parse succeeded.
                Console.WriteLine("success: {0}", 
                    new Object[] { new Float(singleNumber) });
            }
            catch(System.Exception ex) {
                // Display the exception type if Parse failed.
                Console.WriteLine("failed:  {0}", GetExceptionType(ex));
            }
        }
    } //SingleParse

    public static void main(String[] args)
    {
        Console.WriteLine("This example of\n" 
            + "  Single.Parse( String ),\n" 
            + "  Single.Parse( String, NumberStyles ),\n" 
            + "  Single.Parse( String, IFormatProvider ), and\n" 
            + "  Single.Parse( String, NumberStyles, " 
            + "IFormatProvider )\ngenerates the " 
            + "following output when run in the [{0}] culture.", 
            CultureInfo.get_CurrentCulture().get_Name());
        Console.WriteLine(("Several string representations "
            + "of Single values are parsed."));

        // Do not use IFormatProvider or NumberStyles.
        Console.WriteLine("\nNumberStyles and IFormatProvider " 
            + "are not used; current culture is [{0}]:", 
            CultureInfo.get_CurrentCulture().get_Name());
        SingleParse(((NumberStyles)(-1)), null);

        // Use the NumberStyle for Currency.
        Console.WriteLine(("\nNumberStyles.Currency "
            + "is used; IFormatProvider is not used:"));
        SingleParse(NumberStyles.Currency, null);

        // Create a CultureInfo object for another culture. Use
        // [Dutch - The Netherlands] unless the current culture
        // is Dutch language. In that case use [English - U.S.].
        String cultureName = (CultureInfo.get_CurrentCulture().
            get_Name().Substring(0, 2).equalsIgnoreCase("nl")) 
            ? "en-US" : "nl-NL";
        CultureInfo culture = new CultureInfo(cultureName);
        Console.WriteLine("\nNumberStyles is not used; " + 
            "[{0}] culture IFormatProvider is used:", culture.get_Name());
        SingleParse(((NumberStyles)(-1)), culture);

        // Get the NumberFormatInfo object from CultureInfo, and
        // then change the digit group size to 2 and the digit
        // separator to '_'.
        NumberFormatInfo numInfo = culture.get_NumberFormat();
        numInfo.set_NumberGroupSizes(new int[] { 2 });
        numInfo.set_NumberGroupSeparator("_");

        // Use the NumberFormatInfo object as the IFormatProvider.
        Console.WriteLine(("\nNumberStyles.Currency is used, "
            + "group size = 2, separator = \"_\":"));
        SingleParse(NumberStyles.Currency, numInfo);
    } //main
} //SingleParseDemo

/*
This example of
  Single.Parse( String ),
  Single.Parse( String, NumberStyles ),
  Single.Parse( String, IFormatProvider ), and
  Single.Parse( String, NumberStyles, IFormatProvider )
generates the following output when run in the [en-US] culture.
Several string representations of Single values are parsed.

NumberStyles and IFormatProvider are not used; current culture is [en-US]:
  Parse of " 987.654E-2"       success: 9.87654
  Parse of " 987,654E-2"       success: 9876.54
  Parse of "(98765,43210)"     failed:  FormatException
  Parse of "9,876,543.210"     success: 9876543
  Parse of "9.876.543,210"     failed:  FormatException
  Parse of "98_76_54_32,19"    failed:  FormatException

NumberStyles.Currency is used; IFormatProvider is not used:
  Parse of " 987.654E-2"       failed:  FormatException
  Parse of " 987,654E-2"       failed:  FormatException
  Parse of "(98765,43210)"     success: -9.876543E+9
  Parse of "9,876,543.210"     success: 9876543
  Parse of "9.876.543,210"     failed:  FormatException
  Parse of "98_76_54_32,19"    failed:  FormatException

NumberStyles is not used; [nl-NL] culture IFormatProvider is used:
  Parse of " 987.654E-2"       success: 9876.54
  Parse of " 987,654E-2"       success: 9.87654
  Parse of "(98765,43210)"     failed:  FormatException
  Parse of "9,876,543.210"     failed:  FormatException
  Parse of "9.876.543,210"     success: 9876543
  Parse of "98_76_54_32,19"    failed:  FormatException

NumberStyles.Currency is used, group size = 2, separator = "_":
  Parse of " 987.654E-2"       failed:  FormatException
  Parse of " 987,654E-2"       failed:  FormatException
  Parse of "(98765,43210)"     success: -98765.43
  Parse of "9,876,543.210"     failed:  FormatException
  Parse of "9.876.543,210"     success: 9876543
  Parse of "98_76_54_32,19"    success: 9.876543E+7
*/

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 est pris en charge sur Windows Vista, Microsoft Windows XP SP2 et Windows Server 2003 SP1.

.NET Framework

Prise en charge dans : 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Prise en charge dans : 2.0, 1.0

XNA Framework

Prise en charge dans : 1.0

Ajouts de la communauté

Afficher:
© 2014 Microsoft