SByte.TryParse Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 8 bits signé. Un code de retour indique si la conversion a réussi ou a échoué.

Surcharges

TryParse(ReadOnlySpan<Byte>, IFormatProvider, SByte)	Tente d’analyser une étendue de caractères UTF-8 en une valeur.
TryParse(ReadOnlySpan<Char>, SByte)	Essaie de convertir la représentation sous forme de plage d’un nombre en son équivalent SByte et retourne une valeur indiquant si la conversion a réussi.
TryParse(String, SByte)	Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent SByte et retourne une valeur indiquant si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, IFormatProvider, SByte)	Tente d’analyser une étendue de caractères dans une valeur.
TryParse(String, IFormatProvider, SByte)	Tente d’analyser une chaîne en une valeur.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, SByte)	Tente d’analyser une étendue de caractères UTF-8 en une valeur.
TryParse(ReadOnlySpan<Byte>, SByte)	Tente de convertir une étendue de caractères UTF-8 contenant la représentation sous forme de chaîne d’un nombre en entier signé 8 bits équivalent.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, SByte)	Essaie de convertir la représentation sous forme de plage d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent SByte et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, NumberStyles, IFormatProvider, SByte)	Essaie de convertir la représentation sous forme de chaîne d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent SByte et retourne une valeur qui indique si la conversion a réussi.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, SByte)

Source:

SByte.cs

Tente d’analyser une étendue de caractères UTF-8 en une valeur.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = IUtf8SpanParsable<System::SByte>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out sbyte result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As SByte) As Boolean

Paramètres

utf8Text

ReadOnlySpan<Byte>

Étendue de caractères UTF-8 à analyser.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant utf8Text.

result

SByte

Au retour, contient le résultat d’une analyse utf8Text réussie ou une valeur non définie en cas d’échec.

Retours

Boolean

true si utf8Text a été correctement analysé ; sinon, false.

TryParse(ReadOnlySpan<Char>, SByte)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Essaie de convertir la représentation sous forme de plage d’un nombre en son équivalent SByte et retourne une valeur indiquant si la conversion a réussi.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] System::SByte % result);

public static bool TryParse (ReadOnlySpan<char> s, out sbyte result);

static member TryParse : ReadOnlySpan<char> * sbyte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As SByte) As Boolean

Paramètres

s

ReadOnlySpan<Char>

Plage contenant les caractères représentant le nombre à convertir.

result

SByte

Quand cette méthode est retournée, contient la valeur de l'entier 8 bits signé équivalente au nombre contenu dans s si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le s paramètre est null ou Empty, n’est pas au format correct ou représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie initialement dans result sera remplacée.

Retours

Boolean

true si la conversion de s est réussie ; sinon, false.

TryParse(String, SByte)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent SByte et retourne une valeur indiquant si la conversion a réussi.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] System::SByte % result);

public static bool TryParse (string? s, out sbyte result);

static member TryParse : string * sbyte -> bool

Public Shared Function TryParse (s As String, ByRef result As SByte) As Boolean

Paramètres

s

String

Chaîne contenant un nombre à convertir.

result

SByte

Quand cette méthode est retournée, contient la valeur de l'entier 8 bits signé équivalente au nombre contenu dans s si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le s paramètre est null ou Empty, n’est pas au format correct ou représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie initialement dans result sera remplacée.

Retours

Boolean

true si la conversion de s est réussie ; sinon, false.

Exemples

L’exemple suivant tente de convertir les chaînes d’un tableau SByte en valeurs en appelant la TryParse(String, SByte) méthode .

string[] numericStrings = {"-3.6", "12.8", "+16.7", "    3   ", "(17)", 
                           "-17", "+12", "18-", "987", "1,024", "  127 "};
sbyte number;
foreach (string numericString in numericStrings)
{
   if (sbyte.TryParse(numericString, out number)) 
      Console.WriteLine("Converted '{0}' to {1}.", numericString, number);
   else
      Console.WriteLine("Cannot convert '{0}' to an SByte.", numericString);
}
// The example displays the following output to the console:
//       Cannot convert '-3.6' to an SByte.
//       Cannot convert '12.8' to an SByte.
//       Cannot convert '+16.7' to an SByte.
//       Converted '    3   ' to 3.
//       Cannot convert '(17)' to an SByte.
//       Converted '-17' to -17.
//       Converted '+12' to 12.
//       Cannot convert '18-' to an SByte.
//       Cannot convert '987' to an SByte.
//       Cannot convert '1,024' to an SByte.
//       Converted '  127 ' to 127.

open System

let numericStrings = 
    [| "-3.6"; "12.8"; "+16.7"; "    3   "; "(17)" 
       "-17"; "+12"; "18-"; "987"; "1,024"; "  127 " |]

for numericString in numericStrings do
    match SByte.TryParse numericString with 
    | true, number ->
        printfn $"Converted '{numericString}' to {number}."
    | _ ->
        printfn $"Cannot convert '{numericString}' to an SByte."
// The example displays the following output to the console:
//       Cannot convert '-3.6' to an SByte.
//       Cannot convert '12.8' to an SByte.
//       Cannot convert '+16.7' to an SByte.
//       Converted '    3   ' to 3.
//       Cannot convert '(17)' to an SByte.
//       Converted '-17' to -17.
//       Converted '+12' to 12.
//       Cannot convert '18-' to an SByte.
//       Cannot convert '987' to an SByte.
//       Cannot convert '1,024' to an SByte.
//       Converted '  127 ' to 127.

Dim numericStrings() As String = {"-3.6", "12.8", "+16.7", "    3   ", _
                                  "(17)", "-17", "+12", "18-", "987", _
                                  "1,024", "  127 "}
Dim number As SByte
For Each numericString As String In numericStrings
   If SByte.TryParse(numericString, number) Then
      Console.WriteLine("Converted '{0}' to {1}.", numericString, number)
   Else
      Console.WriteLine("Cannot convert '{0}' to an SByte.", numericString)
   End If      
Next
' The example displays the following output to the console:
'       Cannot convert '-3.6' to an SByte.
'       Cannot convert '12.8' to an SByte.
'       Cannot convert '+16.7' to an SByte.
'       Converted '    3   ' to 3.
'       Cannot convert '(17)' to an SByte.
'       Converted '-17' to -17.
'       Converted '+12' to 12.
'       Cannot convert '18-' to an SByte.
'       Cannot convert '987' to an SByte.
'       Cannot convert '1,024' to an SByte.
'       Converted '  127 ' to 127.

Remarques

La SByte.TryParse(String, SByte) méthode est semblable à la SByte.Parse(String) méthode, sauf qu’elle ne lève pas d’exception si la conversion échoue. Cette méthode élimine la nécessité d’utiliser la gestion des exceptions pour tester un FormatException si value n’est pas valide et ne peut pas être analysé avec succès.

Le s paramètre doit être la représentation sous forme de chaîne d’un nombre décimal sous la forme suivante :

[ws] [sign] digits[ws]

Les éléments entre crochets ([ et ]) sont facultatifs. Le tableau suivant décrit chaque élément.

Élément	Description
ws	Espace blanc facultatif.
sign	Signe facultatif. Les caractères de signe valides sont déterminés par les NumberFormatInfo.NegativeSign propriétés et NumberFormatInfo.PositiveSign de la culture actuelle.
chiffres	Séquence de chiffres décimaux compris entre 0 et 9.

Notes

La chaîne spécifiée par le value paramètre ne peut pas contenir de séparateurs de groupe ou de séparateur décimal, et elle ne peut pas avoir de partie décimale.

Le s paramètre est interprété à l’aide du NumberStyles.Integer style . En plus des chiffres décimaux, seuls les espaces de début et de fin avec un signe de début sont autorisés. Pour définir explicitement les éléments de style avec les informations de mise en forme spécifiques à la culture qui peuvent être présentes dans value, appelez la TryParse(String, NumberStyles, IFormatProvider, SByte) méthode .

Le s paramètre est analysé à l’aide des informations de mise en forme d’un NumberFormatInfo objet pour la culture actuelle. Pour plus d'informations, consultez NumberFormatInfo.CurrentInfo.

Cette surcharge interprète tous les chiffres du value paramètre comme des chiffres décimaux. Pour analyser la représentation sous forme de chaîne d’un nombre hexadécimal, appelez plutôt la TryParse(String, NumberStyles, IFormatProvider, SByte) surcharge.

Voir aussi

• Exemple : utilitaire de mise en forme .NET Core WinForms (C#)
• Exemple : utilitaire de mise en forme .NET Core WinForms (Visual Basic)

TryParse(ReadOnlySpan<Char>, IFormatProvider, SByte)

Source:

SByte.cs

Tente d’analyser une étendue de caractères dans une valeur.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = ISpanParsable<System::SByte>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out sbyte result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As SByte) As Boolean

Paramètres

s

ReadOnlySpan<Char>

Étendue des caractères à analyser.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant s.

result

SByte

Lorsque cette méthode retourne, contient le résultat de l’analyse sréussie ou une valeur non définie en cas d’échec.

Retours

Boolean

true si s a été correctement analysé ; sinon, false.

TryParse(String, IFormatProvider, SByte)

Source:

SByte.cs

Tente d’analyser une chaîne en une valeur.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = IParsable<System::SByte>::TryParse;

public static bool TryParse (string? s, IFormatProvider? provider, out sbyte result);

static member TryParse : string * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As SByte) As Boolean

Paramètres

s

String

Chaîne à analyser.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant s.

result

SByte

Lorsque cette méthode retourne, contient le résultat d’une analyse s réussie ou une valeur non définie en cas d’échec.

Retours

Boolean

true si s a été correctement analysé ; sinon, false.

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, SByte)

Source:

SByte.cs

Tente d’analyser une étendue de caractères UTF-8 en une valeur.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = System::Numerics::INumberBase<System::SByte>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out sbyte result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As SByte) As Boolean

Paramètres

utf8Text

ReadOnlySpan<Byte>

Étendue de caractères UTF-8 à analyser.

style

NumberStyles

Combinaison de styles numériques au niveau du bit qui peut être présente dans utf8Text.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant utf8Text.

result

SByte

Au retour, contient le résultat d’une analyse utf8Text réussie ou une valeur non définie en cas d’échec.

Retours

Boolean

true si utf8Text a été correctement analysé ; sinon, false.

TryParse(ReadOnlySpan<Byte>, SByte)

Source:

SByte.cs

Tente de convertir une étendue de caractères UTF-8 contenant la représentation sous forme de chaîne d’un nombre en entier signé 8 bits équivalent.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] System::SByte % result);

public static bool TryParse (ReadOnlySpan<byte> utf8Text, out sbyte result);

static member TryParse : ReadOnlySpan<byte> * sbyte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As SByte) As Boolean

Paramètres

utf8Text

ReadOnlySpan<Byte>

Étendue contenant les caractères UTF-8 représentant le nombre à convertir.

result

SByte

Lorsque cette méthode retourne, contient la valeur entière signée 8 bits équivalente au nombre contenu dans utf8Text si la conversion a réussi ou zéro si la conversion a échoué. Ce paramètre est passé sous forme non initialisée. Toute valeur fournie initialement dans le résultat sera remplacée.

Retours

Boolean

true si la conversion de utf8Text est réussie ; sinon, false.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, SByte)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Essaie de convertir la représentation sous forme de plage d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent SByte et retourne une valeur qui indique si la conversion a réussi.

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = System::Numerics::INumberBase<System::SByte>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out sbyte result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As SByte) As Boolean

Paramètres

s

ReadOnlySpan<Char>

Plage contenant les caractères représentant le nombre à convertir.

style

NumberStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre s. Une valeur typique à spécifier est Integer.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur s.

result

SByte

Quand cette méthode est retournée, contient la valeur de l'entier 8 bits signé équivalente au nombre contenu dans s si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le s paramètre est null ou Empty, n’est pas dans un format conforme à style, ou représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie initialement dans result sera remplacée.

Retours

Boolean

true si la conversion de s est réussie ; sinon, false.

TryParse(String, NumberStyles, IFormatProvider, SByte)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS

System.Int16.TryParse(String, Int16)

Essaie de convertir la représentation sous forme de chaîne d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent SByte et retourne une valeur qui indique si la conversion a réussi.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = System::Numerics::INumberBase<System::SByte>::TryParse;

public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out sbyte result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As SByte) As Boolean

Paramètres

s

String

Chaîne représentant un nombre à convertir.

style

NumberStyles

Combinaison d'opérations de bits de valeurs d'énumération qui indique le format autorisé du paramètre s. Une valeur typique à spécifier est Integer.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur s.

result

SByte

Quand cette méthode est retournée, contient la valeur de l'entier 8 bits signé équivalente au nombre contenu dans s si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le s paramètre est null ou Empty, n’est pas dans un format conforme à styleou représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie initialement dans result sera remplacée.

Retours

Boolean

true si la conversion de s est réussie ; sinon, false.

Exceptions

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

style n’est pas une combinaison des valeurs AllowHexSpecifier et HexNumber.

Exemples

L’exemple suivant appelle la TryParse(String, NumberStyles, IFormatProvider, SByte) méthode avec un certain nombre de chaînes et NumberStyles de valeurs différentes.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string numericString;
      NumberStyles styles;
      
      numericString = "106";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);
      
      numericString = "-106";
      styles = NumberStyles.None;
      CallTryParse(numericString, styles);
      
      numericString = "103.00";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);
      
      numericString = "103.72";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10E-01";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(numericString, styles); 
      
      numericString = "12E-01";
      CallTryParse(numericString, styles);
          
      numericString = "12E01";
      CallTryParse(numericString, styles); 
      
      numericString = "C8";
      CallTryParse(numericString, NumberStyles.HexNumber);
      
      numericString = "0x8C";
      CallTryParse(numericString, NumberStyles.HexNumber);
   }
   
   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      sbyte number;
      bool result = SByte.TryParse(stringToConvert, styles, 
                                   CultureInfo.InvariantCulture, out number);
      if (result)
         Console.WriteLine($"Converted '{stringToConvert}' to {number}.");
      else
         Console.WriteLine($"Attempted conversion of '{stringToConvert}' failed.");
   }
}
// The example displays the following output:
//       Converted '106' to 106.
//       Attempted conversion of '-106' failed.
//       Converted '103.00' to 103.
//       Attempted conversion of '103.72' failed.
//       Converted '10E-01' to 1.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E01' to 120.
//       Converted 'C8' to -56.
//       Attempted conversion of '0x8C' failed.

open System
open System.Globalization

let callTryParse (stringToConvert: string) styles =
    match SByte.TryParse(stringToConvert, styles, CultureInfo.InvariantCulture) with
    | true, number ->
        printfn $"Converted '{stringToConvert}' to {number}."
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."

[<EntryPoint>]
let main _ =
    let numericString = "106"
    let styles = NumberStyles.Integer
    callTryParse numericString styles
    
    let numericString = "-106"
    let styles = NumberStyles.None
    callTryParse numericString styles
    
    let numericString = "103.00"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles
    
    let numericString = "103.72"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "10E-01"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse numericString styles 
    
    let numericString = "12E-01"
    callTryParse numericString styles
        
    let numericString = "12E01"
    callTryParse numericString styles 
    
    let numericString = "C8"
    callTryParse numericString NumberStyles.HexNumber
    
    let numericString = "0x8C"
    callTryParse numericString NumberStyles.HexNumber
    0

// The example displays the following output:
//       Converted '106' to 106.
//       Attempted conversion of '-106' failed.
//       Converted '103.00' to 103.
//       Attempted conversion of '103.72' failed.
//       Converted '10E-01' to 1.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E01' to 120.
//       Converted 'C8' to -56.
//       Attempted conversion of '0x8C' failed.

Imports System.Globalization

Module StringParsing
   Public Sub Main()
      Dim numericString As String
      Dim styles As NumberStyles
      
      numericString = "106"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      numericString = "-106"
      styles = NumberStyles.None
      CallTryParse(numericString, styles)
      
      numericString = "103.00"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)
      
      numericString = "103.72"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)

      numericString = "10E-01"
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(numericString, styles) 
      
      numericString = "12E-01"
      CallTryParse(numericString, styles)
          
      numericString = "12E01"
      CallTryParse(numericString, styles) 
      
      numericString = "C8"
      CallTryParse(numericString, NumberStyles.HexNumber)
      
      numericString = "0x8C"
      CallTryParse(numericString, NumberStyles.HexNumber)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles AS NumberStyles)
      Dim number As SByte
      Dim result As Boolean = SByte.TryParse(stringToConvert, styles, _
                                             CultureInfo.InvariantCulture, number)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           Convert.ToString(stringToConvert))
      End If                                                                           
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '106' to 106.
'       Attempted conversion of '-106' failed.
'       Converted '103.00' to 103.
'       Attempted conversion of '103.72' failed.
'       Converted '10E-01' to 1.
'       Attempted conversion of '12E-01' failed.
'       Converted '12E01' to 120.
'       Converted 'C8' to -56.
'       Attempted conversion of '0x8C' failed.

Remarques

La TryParse(String, NumberStyles, IFormatProvider, SByte) méthode est semblable à la Parse(String, NumberStyles, IFormatProvider) méthode , sauf qu’elle ne lève pas d’exception si la conversion échoue. Cette méthode élimine la nécessité d’utiliser la gestion des exceptions pour tester un FormatException si value n’est pas valide et ne peut pas être analysé correctement.

Le style paramètre définit les éléments de style (tels que l’espace blanc ou un signe positif ou négatif) autorisés dans le value paramètre pour que l’opération d’analyse réussisse. Il doit s’agir d’une combinaison d’indicateurs de bits de l’énumération NumberStyles . Selon la valeur de style, le value paramètre peut inclure les éléments suivants :

[ws] [$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]

Si le style paramètre inclut AllowHexSpecifier, le value paramètre peut inclure les éléments suivants :

[ws] hexdigits[ws]

Les éléments entre crochets ([ et ]) sont facultatifs. Le tableau suivant décrit chaque élément.

Élément	Description
ws	Espace blanc facultatif. L’espace blanc peut apparaître au début de value si style inclut l’indicateur NumberStyles.AllowLeadingWhite , ou à la fin de value si style inclut l’indicateur NumberStyles.AllowTrailingWhite .
$	Symbole monétaire spécifique à la culture. Sa position dans la chaîne est définie par la CurrencyPositivePattern propriété de l’objet NumberFormatInfo retournée par la GetFormat méthode du provider paramètre . Le symbole monétaire peut apparaître dans value si style inclut l’indicateur NumberStyles.AllowCurrencySymbol .
sign	Signe facultatif. Le signe peut apparaître au début de value si style inclut l’indicateur NumberStyles.AllowLeadingSign , et il peut apparaître à la fin de value si style inclut l’indicateur NumberStyles.AllowTrailingSign . Vous pouvez utiliser des parenthèses dans value pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses .
chiffres	Séquence de chiffres de 0 à 9.
,	Séparateur de groupe spécifique à la culture. Le séparateur de groupe de la culture spécifiée par provider peut apparaître dans value si style inclut l’indicateur NumberStyles.AllowThousands .
.	Symbole décimal spécifique à la culture. Le symbole décimal de la culture spécifiée par provider peut apparaître dans value si style inclut l’indicateur NumberStyles.AllowDecimalPoint .
fractional_digits	Une ou plusieurs occurrences du chiffre 0. Les chiffres fractionnaires peuvent apparaître dans value uniquement si style inclut l’indicateur NumberStyles.AllowDecimalPoint .
E	Caractère « e » ou « E », qui indique que la valeur est représentée en notation exponentielle (scientifique). Le value paramètre peut représenter un nombre en notation exponentielle si style inclut l’indicateur NumberStyles.AllowExponent .
exponential_digits	Séquence de chiffres de 0 à 9. Le value paramètre peut représenter un nombre en notation exponentielle si style inclut l’indicateur NumberStyles.AllowExponent .
hexdigits	Séquence de chiffres hexadécimaux de 0 à f ou de 0 à F.

Notes

Tous les caractères NUL de fin (U+0000) dans s sont ignorés par l’opération d’analyse, quelle que soit la valeur de l’argument style .

Une chaîne avec des chiffres décimaux uniquement (qui correspond à l’indicateur NumberStyles.None ) s’analyse toujours correctement. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être présents, mais qui ne sont pas obligatoires, dans cette chaîne d’entrée. Le tableau suivant indique comment les membres individuels NumberStyles affectent les éléments qui peuvent être présents dans value.

Valeurs non composites NumberStyles	Éléments autorisés en valeur en plus des chiffres
None	Chiffres décimaux uniquement.
AllowDecimalPoint	Éléments décimaux (.) et fractional_digits . Toutefois, fractional_digits ne doit comporter qu’un ou plusieurs chiffres, ou la méthode retourne false.
AllowExponent	Caractère « e » ou « E », qui indique une notation exponentielle, ainsi que exponential_digits. Si value représente un nombre en notation exponentielle, il ne peut pas avoir un composant fractionnaire différent de zéro.
AllowLeadingWhite	Élément ws au début de value.
AllowTrailingWhite	Élément ws à la fin de value.
AllowLeadingSign	Élément sign avant les chiffres.
AllowTrailingSign	Élément sign après les chiffres.
AllowParentheses	Élément sign sous forme de parenthèses englobant la valeur numérique.
AllowThousands	Élément séparateur de groupe (,).
AllowCurrencySymbol	Élément currency ($).
Currency	Tous les éléments. Toutefois, value ne peut pas représenter un nombre hexadécimal ou un nombre en notation exponentielle.
Float	L’élément ws au début ou à la fin de value, signe au début de valueet le symbole décimal (.). Le value paramètre peut également utiliser la notation exponentielle.
Number	Éléments ws, signe, séparateur de groupe (,) et virgule décimale (.).
Any	Tous les éléments. Toutefois, value ne peut pas représenter un nombre hexadécimal.

Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, value doit être une valeur hexadécimale. Les chiffres hexadécimaux valides sont 0-9, a-f et A-F. Les seuls autres indicateurs qui peuvent être présents dans style sont NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles a un style composite, HexNumber, qui inclut les deux indicateurs d’espace blanc.)

Notes

Si value est la représentation sous forme de chaîne d’un nombre hexadécimal, elle ne peut pas être précédée d’une décoration (telle que 0x ou &h) qui le différencie en tant que nombre hexadécimal. Cela entraîne l’échec de la conversion.

Le provider paramètre est une IFormatProvider implémentation. Sa GetFormat méthode retourne un NumberFormatInfo objet qui fournit des informations spécifiques à la culture sur le format de value. Le provider paramètre peut être l’un des éléments suivants :

• Objet CultureInfo qui représente la culture qui fournit des informations de mise en forme. Sa GetFormat méthode retourne l’objet NumberFormatInfo qui fournit des informations de mise en forme numériques pour cette culture.

• Objet NumberFormatInfo qui fournit des informations de mise en forme numérique. (Son implémentation de GetFormat retourne simplement elle-même.)

• Objet personnalisé qui implémente IFormatProvider. Sa GetFormat méthode instancie et retourne l’objet NumberFormatInfo qui fournit des informations de mise en forme.

Si provider a la valeur null, l’objet NumberFormatInfo de la culture actuelle est utilisé.

Voir aussi

• Parse(String, NumberStyles, IFormatProvider)
• Analyse de chaînes numériques dans .NET