Byte.TryParse Méthode

Définition

Espace de noms:: System

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assemblys:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Tente de convertir la représentation sous forme de chaîne d’un nombre en son Byte équivalent et retourne une valeur qui indique si la conversion a réussi.

Surcharges

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

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.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::Byte % result) = IUtf8SpanParsable<System::Byte>::TryParse;

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

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

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Byte) 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 spécifiques à la culture sur utf8Text.

result: Byte

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

Retours

Boolean

true si utf8Text elle a été analysée avec succès ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Char>, Byte)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Tente de convertir la représentation d’étendue d’un nombre en son Byte équivalent et retourne une valeur qui indique si la conversion a réussi.

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

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

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

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

Paramètres

s: ReadOnlySpan<Char>

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

result: Byte

Lorsque cette méthode est retournée, contient la Byte valeur équivalente au nombre contenu dans s le cas où la conversion a réussi ou zéro si la conversion a échoué. Ce paramètre est passé non initialisé ; toute valeur fournie result à l’origine sera remplacée.

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false.

S’applique à

TryParse(String, Byte)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Tente de convertir la représentation sous forme de chaîne d’un nombre en son Byte équivalent et retourne une valeur qui indique si la conversion a réussi.

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

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

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

static member TryParse : string * byte -> bool

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

Paramètres

s: String

Chaîne qui contient un nombre à convertir.

result: Byte

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false.

Exemples

L’exemple suivant appelle la TryParse(String, Byte) méthode avec un certain nombre de valeurs de chaîne différentes.

using System;

public class ByteConversion
{
   public static void Main()
   {
      string[] byteStrings = { null, string.Empty, "1024",
                               "100.1", "100", "+100", "-100",
                               "000000000000000100", "00,100",
                               "   20   ", "FF", "0x1F" };

      foreach (var byteString in byteStrings)
      {
          CallTryParse(byteString);
      }
   }

   private static void CallTryParse(string stringToConvert)
   {
      byte byteValue;
      bool success = Byte.TryParse(stringToConvert, out byteValue);
      if (success)
      {
         Console.WriteLine("Converted '{0}' to {1}",
                        stringToConvert, byteValue);
      }
      else
      {
         Console.WriteLine("Attempted conversion of '{0}' failed.",
                           stringToConvert);
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.

open System

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

let byteStrings = 
    [ null; String.Empty; "1024"
      "100.1"; "100"; "+100"; "-100"
      "000000000000000100"; "00,100"
      "   20   "; "FF"; "0x1F" ]

for byteString in byteStrings do
    callTryParse byteString

// The example displays the following output to the console:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.

Module ByteConversion
   Public Sub Main()
      Dim byteStrings() As String = { Nothing, String.Empty, "1024", 
                                    "100.1", "100", "+100", "-100",
                                    "000000000000000100", "00,100",
                                    "   20   ", "FF", "0x1F"}

      For Each byteString As String In byteStrings
        CallTryParse(byteString)
      Next
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String)  
      Dim byteValue As Byte
      Dim success As Boolean = Byte.TryParse(stringToConvert, byteValue)
      If success Then
         Console.WriteLine("Converted '{0}' to {1}", _
                        stringToConvert, byteValue)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           stringToConvert)
      End If                        
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '' failed.
'       Attempted conversion of '' failed.
'       Attempted conversion of '1024' failed.
'       Attempted conversion of '100.1' failed.
'       Converted '100' to 100
'       Converted '+100' to 100
'       Attempted conversion of '-100' failed.
'       Converted '000000000000000100' to 100
'       Attempted conversion of '00,100' failed.
'       Converted '   20   ' to 20
'       Attempted conversion of 'FF' failed.
'       Attempted conversion of '0x1F' failed.

Remarques

La conversion échoue et la méthode retourne false si le s paramètre n’est pas au format correct, s’il est null ou String.Empty, ou s’il représente un nombre inférieur MinValue ou supérieur à MaxValue.

La Byte.TryParse(String, Byte) méthode est similaire à la Byte.Parse(String) méthode, sauf qu’elle TryParse(String, Byte) ne lève pas d’exception si la conversion échoue.

Le s paramètre doit être la représentation sous forme de chaîne d’un nombre 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.
signe	Signe positif facultatif, tel que spécifié par la NumberFormatInfo.PositiveSign propriété de la culture actuelle.
Chiffres	Séquence de chiffres décimaux allant de 0 à 9.

Le s paramètre est interprété à l’aide du Integer style. Outre les chiffres décimaux de la valeur d’octet, seuls les espaces de début et de fin avec un signe de début sont autorisés. (Si le signe est présent, il doit s’agir d’un signe positif ou la méthode lève un OverflowException.) 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 s, utilisez la Byte.Parse(String, NumberStyles, IFormatProvider) méthode.

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

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

Voir aussi

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

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

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

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

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

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

Paramètres

s: ReadOnlySpan<Char>

Étendue de caractères à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s.

result: Byte

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

Retours

Boolean

true si s elle a été analysée avec succès ; sinon, false.

S’applique à

TryParse(String, IFormatProvider, Byte)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

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

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

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

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

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

Paramètres

s: String

Chaîne à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s.

result: Byte

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

Retours

Boolean

true si s elle a été analysée avec succès ; sinon, false.

S’applique à

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

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.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::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

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

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

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

Paramètres

utf8Text: ReadOnlySpan<Byte>

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

style: NumberStyles

Combinaison de bits de styles numériques qui peuvent être présents dans utf8Text.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur utf8Text.

result: Byte

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

Retours

Boolean

true si utf8Text elle a été analysée avec succès ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Byte>, Byte)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.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 non signé 8 bits équivalent.

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

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

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

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

Paramètres

utf8Text: ReadOnlySpan<Byte>

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

result: Byte

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

Retours

Boolean

true si utf8Text elle a été convertie avec succès ; sinon, false.

S’applique à

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

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Convertit la représentation d’étendue d’un nombre dans un style et un format spécifique à la culture spécifiés en son Byte équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

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

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

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

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

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

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

Paramètres

s: ReadOnlySpan<Char>

Étendue contenant les caractères représentant le nombre à convertir. L’étendue est interprétée à l’aide du Integer style.

style: NumberStyles

Combinaison de bits de valeurs d’énumération qui indique les éléments de style qui peuvent être présents dans s. Une valeur classique à spécifier est Integer.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s. Si provider c’est nullle cas, la culture actuelle du thread est utilisée.

result: Byte

Lorsque cette méthode est retournée, contient la valeur entière non signée 8 bits équivalente au nombre contenu si s la conversion a réussi, ou zéro si la conversion a échoué. La conversion échoue si le s paramètre est ou Emptyn’est null pas du format correct, ou représente un nombre inférieur à Byte.MinValue ou supérieur à Byte.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie result à l’origine sera remplacée.

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false.

S’applique à

TryParse(String, NumberStyles, IFormatProvider, Byte)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en son Byte équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result);

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

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

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

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

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

Paramètres

s: String

Chaîne contenant un nombre à convertir. La chaîne est interprétée à l’aide du style spécifié par style.

style: NumberStyles

Combinaison de bits de valeurs d’énumération qui indique les éléments de style qui peuvent être présents dans s. Une valeur classique à spécifier est Integer.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s. Si provider c’est nullle cas, la culture actuelle du thread est utilisée.

result: Byte

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false.

Exceptions

ArgumentException

style n’est pas une NumberStyles valeur.

- ou -

stylen’est pas une combinaison de AllowHexSpecifier valeurs.HexNumber

Exemples

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

using System;
using System.Globalization;

public class ByteConversion2
{
   public static void Main()
   {
      string byteString;
      NumberStyles styles;

      byteString = "1024";
      styles = NumberStyles.Integer;
      CallTryParse(byteString, styles);

      byteString = "100.1";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(byteString, styles);

      byteString = "100.0";
      CallTryParse(byteString, styles);

      byteString = "+100";
      styles = NumberStyles.Integer | NumberStyles.AllowLeadingSign
               | NumberStyles.AllowTrailingSign;
      CallTryParse(byteString, styles);

      byteString = "-100";
      CallTryParse(byteString, styles);

      byteString = "000000000000000100";
      CallTryParse(byteString, styles);

      byteString = "00,100";
      styles = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallTryParse(byteString, styles);

      byteString = "2E+3   ";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(byteString, styles);

      byteString = "FF";
      styles = NumberStyles.HexNumber;
      CallTryParse(byteString, styles);

      byteString = "0x1F";
      CallTryParse(byteString, styles);
   }

   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      Byte byteValue;
      bool result = Byte.TryParse(stringToConvert, styles,
                                  null as IFormatProvider, out byteValue);
      if (result)
         Console.WriteLine("Converted '{0}' to {1}",
                        stringToConvert, byteValue);
      else
         Console.WriteLine("Attempted conversion of '{0}' failed.",
                           stringToConvert.ToString());
   }
}
// The example displays the following output to the console:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.

open System
open System.Globalization

let callTryParse (stringToConvert: string) (styles: NumberStyles) =
    match Byte.TryParse(stringToConvert, styles, null) with
    | true, byteValue ->
        printfn $"Converted '{stringToConvert}' to {byteValue}"
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."
                        
[<EntryPoint>]
let main _ =
    let byteString = "1024"
    let styles = NumberStyles.Integer
    callTryParse byteString styles

    let byteString = "100.1"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse byteString styles

    let byteString = "100.0"
    callTryParse byteString styles

    let byteString = "+100"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowLeadingSign ||| NumberStyles.AllowTrailingSign
    callTryParse byteString styles

    let byteString = "-100"
    callTryParse byteString styles

    let byteString = "000000000000000100"
    callTryParse byteString styles

    let byteString = "00,100"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callTryParse byteString styles

    let byteString = "2E+3   "
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse byteString styles

    let byteString = "FF"
    let styles = NumberStyles.HexNumber
    callTryParse byteString styles

    let byteString = "0x1F"
    callTryParse byteString styles

    0

// The example displays the following output to the console:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.

Imports System.Globalization

Module ByteConversion2
   Public Sub Main()
      Dim byteString As String 
      Dim styles As NumberStyles
      
      byteString = "1024"
      styles = NumberStyles.Integer
      CallTryParse(byteString, styles)
      
      byteString = "100.1"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(byteString, styles)
      
      byteString = "100.0"
      CallTryParse(byteString, styles)
      
      byteString = "+100"
      styles = NumberStyles.Integer Or NumberStyles.AllowLeadingSign _
               Or NumberStyles.AllowTrailingSign
      CallTryParse(byteString, styles)
      
      byteString = "-100"
      CallTryParse(byteString, styles)
      
      byteString = "000000000000000100"
      CallTryParse(byteString, styles)
      
      byteString = "00,100"      
      styles = NumberStyles.Integer Or NumberStyles.AllowThousands
      CallTryParse(byteString, styles)
      
      byteString = "2E+3   "
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(byteString, styles)
      
      byteString = "FF"
      styles = NumberStyles.HexNumber
      CallTryParse(byteString, styles)
      
      byteString = "0x1F"
      CallTryParse(byteString, styles)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles As NumberStyles)  
      Dim byteValue As Byte
      Dim result As Boolean = Byte.TryParse(stringToConvert, styles, Nothing, _
                                            byteValue)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}", _
                        stringToConvert, byteValue)
      Else
         If stringToConvert Is Nothing Then stringToConvert = ""
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           stringToConvert.ToString())
      End If                        
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '1024' failed.
'       Attempted conversion of '100.1' failed.
'       Converted '100.0' to 100
'       Converted '+100' to 100
'       Attempted conversion of '-100' failed.
'       Converted '000000000000000100' to 100
'       Converted '00,100' to 100
'       Attempted conversion of '2E+3   ' failed.
'       Converted 'FF' to 255
'       Attempted conversion of '0x1F' failed.

Remarques

La TryParse méthode est semblable à la Parse méthode, sauf que la TryParse méthode ne lève pas d’exception si la conversion échoue.

Le s paramètre est analysé à l’aide des informations de mise en forme dans un NumberFormatInfo objet fourni par le provider paramètre.

Le paramètre de style définit les éléments de style (tels que l’espace blanc ou le signe positif) autorisés dans le s 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 s paramètre peut inclure les éléments suivants :

[ws][$][sign]digits[.fractional_digits][e[sign]digits][ws]

Ou, si le style paramètre inclut AllowHexSpecifier:

[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 `s` si `style` inclut l’indicateur NumberStyles.AllowLeadingWhite , ou à la fin de s si le style inclut l’indicateur NumberStyles.AllowTrailingWhite .
$	Symbole monétaire propre à la culture. Sa position dans la chaîne est définie par la NumberFormatInfo.CurrencyPositivePattern propriété de l’objet NumberFormatInfo retourné par la GetFormat méthode du `provider` paramètre. Le symbole monétaire peut apparaître si `sstyle` l’indicateur NumberStyles.AllowCurrencySymbol est inclus.
signe	Signe positif facultatif. (L’opération d’analyse échoue si un signe négatif est présent dans `s`.) Le signe peut apparaître au début de `s` si `style` inclut l’indicateur NumberStyles.AllowLeadingSign , ou à la fin de `s` si `style` elle inclut l’indicateur NumberStyles.AllowTrailingSign .
Chiffres	Séquence de chiffres comprises entre 0 et 9.
.	Symbole décimal spécifique à la culture. Le symbole décimal de la culture spécifiée peut `provider` apparaître si `sstyle` l’indicateur NumberStyles.AllowDecimalPoint est inclus.
fractional_digits	Une ou plusieurs occurrences du chiffre 0. Les chiffres fractionnels peuvent apparaître `s` uniquement si `style` l’indicateur NumberStyles.AllowDecimalPoint est inclus.
e	Caractère e ou E, qui indique que la valeur est représentée en notation exponentielle. Le `s` paramètre peut représenter un nombre en notation exponentielle s’il `style` inclut l’indicateur NumberStyles.AllowExponent .
hexdigits	Séquence de chiffres hexadécimaux de 0 à f, ou de 0 à F.

Note

Les caractères s NUL (U+0000) de fin 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 au NumberStyles.None style) analyse toujours correctement. La plupart des éléments de contrôle membres restants NumberStyles qui peuvent être, mais qui ne sont pas nécessaires pour être présents 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 s.

Valeurs NumberStyles non composites	Éléments autorisés en plus des chiffres
NumberStyles.None	Chiffres décimaux uniquement.
NumberStyles.AllowDecimalPoint	Éléments . et fractional_digits . Toutefois, fractional_digits ne doit contenir qu’un ou plusieurs chiffres ou la méthode retourne `false`.
NumberStyles.AllowExponent	Le `s` paramètre peut également utiliser la notation exponentielle. Si `s` représente un nombre en notation exponentielle, il doit représenter un entier dans la plage du type de Byte données sans composant fractionnaire non zéro.
NumberStyles.AllowLeadingWhite	Élément ws au début de `s`.
NumberStyles.AllowTrailingWhite	Élément ws à la fin de `s`.
NumberStyles.AllowLeadingSign	Un signe positif peut apparaître avant les chiffres.
NumberStyles.AllowTrailingSign	Un signe positif peut apparaître après les chiffres.
NumberStyles.AllowParentheses	Bien que cet indicateur soit pris en charge, la méthode retourne `false` si des parenthèses sont présentes dans `s`.
NumberStyles.AllowThousands	Bien que le symbole de séparateur de groupe puisse apparaître, `s`il peut être précédé d’un ou plusieurs chiffres.
NumberStyles.AllowCurrencySymbol	Élément $ .

Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, s doit être une valeur hexadécimale sans préfixe. Par exemple, « F3 » analyse correctement, mais « 0xF3 » ne le fait pas. Les seuls autres indicateurs qui peuvent être présents sont styleNumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles a un style de nombre composite, NumberStyles.HexNumberqui inclut les deux indicateurs d’espace blanc.)

Le provider paramètre est une IFormatProvider implémentation, telle qu’un CultureInfo objet ou un NumberFormatInfo objet, dont GetFormat la méthode retourne un NumberFormatInfo objet. L’objet NumberFormatInfo fournit des informations spécifiques à la culture sur le format de s.

Voir aussi

S’applique à

Commentaires

Cette page a-t-elle été utile ?

Partager via

Byte.TryParse Méthode

Définition

Surcharges

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Char>, Byte)

Paramètres

Retours

S’applique à

TryParse(String, Byte)

Paramètres

Retours

Exemples

Remarques

Voir aussi

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Paramètres

Retours

S’applique à

TryParse(String, IFormatProvider, Byte)

Paramètres

Retours

S’applique à

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

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Byte>, Byte)

Paramètres

Retours

S’applique à

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

Paramètres

Retours

S’applique à

TryParse(String, NumberStyles, IFormatProvider, Byte)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Commentaires