Byte.Parse 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 sa représentation Byte équivalente.

Surcharges

Parse(String, NumberStyles, IFormatProvider)	Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation Byte équivalente.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convertit la représentation sous forme de plage d’un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation Byte équivalente.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analyse une étendue de caractères UTF-8 dans une valeur.
Parse(String, IFormatProvider)	Convertit la représentation sous forme de chaîne d'un nombre, ayant un format spécifique à la culture spécifié, en sa représentation Byte équivalente.
Parse(String, NumberStyles)	Convertit la représentation d'un nombre sous forme de chaîne dans un style spécifié en son équivalent Byte.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analyse une étendue de caractères dans une valeur.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analyse une étendue de caractères UTF-8 dans une valeur.
Parse(String)	Convertit la représentation sous forme de chaîne d'un nombre en sa représentation Byte équivalente.

Parse(String, NumberStyles, IFormatProvider)

Source:

Byte.cs

Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation Byte équivalente.

public:
 static System::Byte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::Byte>::Parse;

public static byte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

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

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Byte

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 typique à spécifier est Integer.

provider

IFormatProvider

Objet qui fournit des informations spécifiques à la culture concernant le format de s. Si provider est null, la culture actuelle du thread est utilisée.

Retours

Byte

Valeur d'octet qui équivaut au nombre contenu dans s.

Implémente

Parse(String, NumberStyles, IFormatProvider)

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

Le format de s est incorrect.

OverflowException

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

- ou -

s inclut des chiffres fractionnaires différents de zéro.

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

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

Exemples

L’exemple de code suivant analyse les représentations sous forme de chaîne de Byte valeurs avec cette surcharge de la Byte.Parse(String, NumberStyles, IFormatProvider) méthode .

NumberStyles style;
CultureInfo^ culture;
String^ value;
Byte number;

// Parse number with decimals.
// NumberStyles.Float includes NumberStyles.AllowDecimalPoint.
style = NumberStyles::Float;     
culture = CultureInfo::CreateSpecificCulture("fr-FR");
value = "12,000";

number = Byte::Parse(value, style, culture);
Console::WriteLine("Converted '{0}' to {1}.", value, number);

culture = CultureInfo::CreateSpecificCulture("en-GB");
try
{
   number = Byte::Parse(value, style, culture);
   Console::WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", value); }   

value = "12.000";
number = Byte::Parse(value, style, culture);
Console::WriteLine("Converted '{0}' to {1}.", value, number);
// The example displays the following output to the console:
//       Converted '12,000' to 12.
//       Unable to parse '12,000'.
//       Converted '12.000' to 12.

NumberStyles style;
CultureInfo culture;
string value;
byte number;

// Parse number with decimals.
// NumberStyles.Float includes NumberStyles.AllowDecimalPoint.
style = NumberStyles.Float;
culture = CultureInfo.CreateSpecificCulture("fr-FR");
value = "12,000";

number = Byte.Parse(value, style, culture);
Console.WriteLine("Converted '{0}' to {1}.", value, number);

culture = CultureInfo.CreateSpecificCulture("en-GB");
try
{
   number = Byte.Parse(value, style, culture);
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", value); }

value = "12.000";
number = Byte.Parse(value, style, culture);
Console.WriteLine("Converted '{0}' to {1}.", value, number);
// The example displays the following output to the console:
//       Converted '12,000' to 12.
//       Unable to parse '12,000'.
//       Converted '12.000' to 12.

// Parse number with decimals.
// NumberStyles.Float includes NumberStyles.AllowDecimalPoint.
let style = NumberStyles.Float
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
let value = "12,000"

let number = Byte.Parse(value, style, culture)
printfn $"Converted '{value}' to {number}."

let culture = CultureInfo.CreateSpecificCulture "en-GB"
try
    let number = Byte.Parse(value, style, culture)
    printfn $"Converted '{value}' to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."

let value = "12.000"
let number = Byte.Parse(value, style, culture)
printfn $"Converted '{value}' to {number}."

// The example displays the following output to the console:
//       Converted '12,000' to 12.
//       Unable to parse '12,000'.
//       Converted '12.000' to 12.

Dim style As NumberStyles
Dim culture As CultureInfo
Dim value As String
Dim number As Byte

' Parse number with decimals.
' NumberStyles.Float includes NumberStyles.AllowDecimalPoint.
style = NumberStyles.Float       
culture = CultureInfo.CreateSpecificCulture("fr-FR")
value = "12,000"

number = Byte.Parse(value, style, culture)
Console.WriteLine("Converted '{0}' to {1}.", value, number)

culture = CultureInfo.CreateSpecificCulture("en-GB")
Try
   number = Byte.Parse(value, style, culture)
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)   
End Try      

value = "12.000"
number = Byte.Parse(value, style, culture)
Console.WriteLine("Converted '{0}' to {1}.", value, number)
' The example displays the following output to the console:
'       Converted '12,000' to 12.
'       Unable to parse '12,000'.
'       Converted '12.000' to 12.

Remarques

Le style paramètre 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 style inclut l’indicateur NumberStyles.AllowTrailingWhite .
$	Symbole monétaire spécifique à la culture. Sa position dans la chaîne est définie par la NumberFormatInfo.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 s si style inclut l’indicateur NumberStyles.AllowCurrencySymbol .
sign	Signe positif facultatif. (La méthode lève un OverflowException 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 inclut l’indicateur NumberStyles.AllowTrailingSign .
chiffres	Séquence de chiffres de 0 à 9.
.	Symbole décimal spécifique à la culture. Le symbole décimal de la culture spécifiée par provider peut apparaître dans s si style inclut l’indicateur NumberStyles.AllowDecimalPoint .
fractional_digits	Une ou plusieurs occurrences du chiffre 0. Les chiffres fractionnaires peuvent apparaître dans s 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. Le paramètre s 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 au NumberStyles.None style) s’analyse toujours correctement. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être mais qui ne doivent pas ê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 dans s en plus des chiffres
NumberStyles.None	Chiffres décimaux uniquement.
NumberStyles.AllowDecimalPoint	Éléments . et fractional_digits . Toutefois, fractional_digits ne doit comporter qu’un ou plusieurs chiffres ou un OverflowException est levée.
NumberStyles.AllowExponent	Le s paramètre peut également utiliser la notation exponentielle.
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, l’utilisation de parenthèses dans s entraîne un OverflowException.
NumberStyles.AllowThousands	Bien que le symbole de séparation de groupe puisse apparaître dans s, il ne peut être précédé que d’un ou plusieurs chiffres 0.
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 dans style sont NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles a un style numérique composite, NumberStyles.HexNumber, qui inclut les deux indicateurs d’espace blanc.)

Le provider paramètre est une IFormatProvider implémentation, telle qu’un NumberFormatInfo objet ou CultureInfo . Le provider paramètre fournit des informations spécifiques à la culture utilisées dans l’analyse. Si provider est null, la culture actuelle du thread est utilisée.

Voir aussi

• ToString()
• MaxValue
• MinValue
• NumberStyles
• NumberFormatInfo
• IFormatProvider
• Mettre en forme des types dans .NET

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:

Byte.cs

Convertit la représentation sous forme de plage d’un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation Byte équivalente.

public static byte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

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

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Byte

Paramètres

s

ReadOnlySpan<Char>

Étendue contenant les caractères représentant la valeur à convertir.

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 typique à spécifier est Integer.

provider

IFormatProvider

Objet qui fournit des informations spécifiques à la culture concernant le format de s. Si provider est null, la culture actuelle du thread est utilisée.

Retours

Byte

Valeur d'octet qui équivaut au nombre contenu dans s.

Implémente

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:

Byte.cs

Analyse une étendue de caractères UTF-8 dans une valeur.

public static byte Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

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

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Byte

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.

Retours

Byte

Résultat de l’analyse de utf8Text.

Implémente

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Source:

Byte.cs

Convertit la représentation sous forme de chaîne d'un nombre, ayant un format spécifique à la culture spécifié, en sa représentation Byte équivalente.

public:
 static System::Byte Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::Byte>::Parse;

public static byte Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> byte

Public Shared Function Parse (s As String, provider As IFormatProvider) As Byte

Paramètres

s

String

Chaîne contenant un nombre à convertir. La chaîne est interprétée à l'aide du style Integer.

provider

IFormatProvider

Objet qui fournit des informations d'analyse spécifiques à la culture concernant s. Si provider est null, la culture actuelle du thread est utilisée.

Retours

Byte

Valeur d'octet qui équivaut au nombre contenu dans s.

Implémente

Parse(String, IFormatProvider)

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

Le format de s est incorrect.

OverflowException

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

Exemples

L’exemple suivant analyse les représentations sous forme de chaîne de Byte valeurs avec la Parse méthode .

String^ stringToConvert; 
Byte byteValue;

stringToConvert = " 214 ";
try {
   byteValue = Byte::Parse(stringToConvert, CultureInfo::InvariantCulture);
   Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException^) {
   Console::WriteLine("'{0}' is greater than {1} or less than {2}.", 
                     stringToConvert, Byte::MaxValue, Byte::MinValue); }

stringToConvert = " + 214 ";
try {
   byteValue = Byte::Parse(stringToConvert, CultureInfo::InvariantCulture);
   Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException^) {
   Console::WriteLine("'{0}' is greater than {1} or less than {2}.", 
                     stringToConvert, Byte::MaxValue, Byte::MinValue); }

stringToConvert = " +214 ";
try {
   byteValue = Byte::Parse(stringToConvert, CultureInfo::InvariantCulture);
   Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException^) {
   Console::WriteLine("'{0}' is greater than {1} or less than {2}.", 
                     stringToConvert, Byte::MaxValue, Byte::MinValue); }
// The example displays the following output to the console:
//       Converted ' 214 ' to 214.
//       Unable to parse ' + 214 '.
//       Converted ' +214 ' to 214.

string stringToConvert;
byte byteValue;

stringToConvert = " 214 ";
try {
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException) {
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.",
                     stringToConvert, Byte.MaxValue, Byte.MinValue); }

stringToConvert = " + 214 ";
try {
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException) {
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.",
                     stringToConvert, Byte.MaxValue, Byte.MinValue); }

stringToConvert = " +214 ";
try {
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException) {
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.",
                     stringToConvert, Byte.MaxValue, Byte.MinValue); }
// The example displays the following output to the console:
//       Converted ' 214 ' to 214.
//       Unable to parse ' + 214 '.
//       Converted ' +214 ' to 214.

let stringToConvert = " 214 "
try
    let byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {byteValue}." 
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is greater than {Byte.MaxValue} or less than {Byte.MinValue}." 

let stringToConvert = " + 214 "
try
    let byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {byteValue}." 
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is greater than {Byte.MaxValue} or less than {Byte.MinValue}." 

let stringToConvert = " +214 "
try
    let byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {byteValue}." 
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is greater than {Byte.MaxValue} or less than {Byte.MinValue}." 

// The example displays the following output to the console:
//       Converted ' 214 ' to 214.
//       Unable to parse ' + 214 '.
//       Converted ' +214 ' to 214.

Dim stringToConvert As String 
Dim byteValue As Byte

stringToConvert = " 214 "
Try
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.", _
                     stringToConvert, Byte.MaxValue, Byte.MinValue)
End Try  

stringToConvert = " + 214 "
Try
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.", _
                     stringToConvert, Byte.MaxValue, Byte.MinValue)
End Try  

stringToConvert = " +214 "
Try
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.", _
                     stringToConvert, Byte.MaxValue, Byte.MinValue)
End Try
' The example displays the following output to the console:
'       Converted ' 214 ' to 214.
'       Unable to parse ' + 214 '.
'       Converted ' +214 ' to 214.

Remarques

Le s paramètre contient un certain nombre de la forme :

[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 positif facultatif.
chiffres	Séquence de chiffres compris entre 0 et 9.

Le s paramètre est interprété à l’aide du Integer style . En plus des chiffres décimaux de la valeur d’octet, seuls les espaces de début et de fin ainsi qu’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 fourni par provider. Le provider paramètre est une IFormatProvider implémentation telle qu’un NumberFormatInfo objet ou CultureInfo . Le provider paramètre fournit des informations spécifiques à la culture utilisées dans l’analyse. Si provider est null, la culture actuelle du thread est utilisée.

Voir aussi

• ToString()
• TryParse
• MaxValue
• MinValue
• NumberStyles
• NumberFormatInfo
• IFormatProvider
• Mettre en forme des types dans .NET

Parse(String, NumberStyles)

Source:

Byte.cs

Convertit la représentation d'un nombre sous forme de chaîne dans un style spécifié en son équivalent Byte.

public:
 static System::Byte Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static byte Parse (string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> byte

Public Shared Function Parse (s As String, style As NumberStyles) As Byte

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 typique à spécifier est Integer.

Retours

Byte

Valeur d'octet qui équivaut au nombre contenu dans s.

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

Le format de s est incorrect.

OverflowException

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

- ou -

s inclut des chiffres fractionnaires différents de zéro.

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

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

Exemples

L’exemple suivant analyse les représentations sous forme de chaîne de Byte valeurs avec la Byte.Parse(String, NumberStyles) méthode . La culture actuelle de l’exemple est en-US.

String^ value;
NumberStyles style;
Byte number;

// Parse value with no styles allowed.
style = NumberStyles::None;
value = " 241 ";
try
{
   number = Byte::Parse(value, style);
   Console::WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", value); }   

// Parse value with trailing sign.
style = NumberStyles::Integer | NumberStyles::AllowTrailingSign;
value = " 163+";
number = Byte::Parse(value, style);
Console::WriteLine("Converted '{0}' to {1}.", value, number);

// Parse value with leading sign.
value = "   +253  ";
number = Byte::Parse(value, style);
Console::WriteLine("Converted '{0}' to {1}.", value, number);
// This example displays the following output to the console:
//       Unable to parse ' 241 '.
//       Converted ' 163+' to 163.
//       Converted '   +253  ' to 253.

string value;
NumberStyles style;
byte number;

// Parse value with no styles allowed.
style = NumberStyles.None;
value = " 241 ";
try
{
   number = Byte.Parse(value, style);
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", value); }

// Parse value with trailing sign.
style = NumberStyles.Integer | NumberStyles.AllowTrailingSign;
value = " 163+";
number = Byte.Parse(value, style);
Console.WriteLine("Converted '{0}' to {1}.", value, number);

// Parse value with leading sign.
value = "   +253  ";
number = Byte.Parse(value, style);
Console.WriteLine("Converted '{0}' to {1}.", value, number);
// This example displays the following output to the console:
//       Unable to parse ' 241 '.
//       Converted ' 163+' to 163.
//       Converted '   +253  ' to 253.

// Parse value with no styles allowed.
let style = NumberStyles.None
let value = " 241 "
try
    let number = Byte.Parse(value, style);
    printfn $"Converted '{value}' to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."

// Parse value with trailing sign.
let style = NumberStyles.Integer ||| NumberStyles.AllowTrailingSign
let value = " 163+"
let number = Byte.Parse(value, style)
printfn $"Converted '{value}' to {number}."

// Parse value with leading sign.
let value = "   +253  "
let number = Byte.Parse(value, style)
printfn $"Converted '{value}' to {number}."

// This example displays the following output to the console:
//       Unable to parse ' 241 '.
//       Converted ' 163+' to 163.
//       Converted '   +253  ' to 253.

Dim value As String
Dim style As NumberStyles
Dim number As Byte

' Parse value with no styles allowed.
style = NumberStyles.None
value = " 241 "
Try
   number = Byte.Parse(value, style)
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)   
End Try
  
' Parse value with trailing sign.
style = NumberStyles.Integer Or NumberStyles.AllowTrailingSign
value = " 163+"
number = Byte.Parse(value, style)
Console.WriteLine("Converted '{0}' to {1}.", value, number)

' Parse value with leading sign.
value = "   +253  "
number = Byte.Parse(value, style)
Console.WriteLine("Converted '{0}' to {1}.", value, number)
' This example displays the following output to the console:
'       Unable to parse ' 241 '.
'       Converted ' 163+' to 163.
'       Converted '   +253  ' to 253.

Remarques

Le style paramètre 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 style 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 spécifique à la culture. Sa position dans la chaîne est définie par la NumberFormatInfo.CurrencyPositivePattern propriété de la culture actuelle. Le symbole monétaire de la culture actuelle peut apparaître dans s si style inclut l’indicateur NumberStyles.AllowCurrencySymbol .
sign	Signe positif facultatif. (La méthode lève un OverflowException 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 inclut l’indicateur NumberStyles.AllowTrailingSign .
chiffres	Séquence de chiffres de 0 à 9.
.	Symbole décimal spécifique à la culture. Le symbole décimal de la culture actuelle peut apparaître dans s si style inclut l’indicateur NumberStyles.AllowDecimalPoint .
fractional_digits	Une ou plusieurs occurrences du chiffre 0. Les chiffres fractionnaires peuvent apparaître dans s 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. Le s 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 au NumberStyles.None style) s’analyse toujours correctement. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être mais qui ne doivent pas ê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 dans s en plus des chiffres
NumberStyles.None	Chiffres décimaux uniquement.
NumberStyles.AllowDecimalPoint	Éléments . et fractional_digits . Toutefois, fractional_digits ne doit comporter qu’un ou plusieurs chiffres ou un OverflowException est levée.
NumberStyles.AllowExponent	Le s paramètre peut également utiliser la notation exponentielle.
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, l’utilisation de parenthèses dans s entraîne un OverflowException.
NumberStyles.AllowThousands	Bien que le symbole de séparation de groupe puisse apparaître dans s, il ne peut être précédé que d’un ou plusieurs chiffres 0.
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 combinés avec lui sont NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles inclut un style numérique composite, NumberStyles.HexNumber, qui inclut les deux indicateurs d’espace blanc.)

Le s paramètre est analysé à l’aide des informations de mise en forme d’un NumberFormatInfo objet initialisé pour la culture système actuelle. Pour utiliser les informations de mise en forme d’une autre culture, appelez la Byte.Parse(String, NumberStyles, IFormatProvider) surcharge.

Voir aussi

• ToString()
• TryParse
• MaxValue
• MinValue
• NumberStyles
• NumberFormatInfo
• IFormatProvider
• Mettre en forme des types dans .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:

Byte.cs

Analyse une étendue de caractères dans une valeur.

public:
 static System::Byte Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<System::Byte>::Parse;

public static byte Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> byte

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Byte

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.

Retours

Byte

Résultat de l’analyse .s

Implémente

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:

Byte.cs

Analyse une étendue de caractères UTF-8 dans une valeur.

public:
 static System::Byte Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<System::Byte>::Parse;

public static byte Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> byte

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Byte

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.

Retours

Byte

Résultat de l’analyse .utf8Text

Implémente

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String)

Source:

Byte.cs

Convertit la représentation sous forme de chaîne d'un nombre en sa représentation Byte équivalente.

public:
 static System::Byte Parse(System::String ^ s);

public static byte Parse (string s);

static member Parse : string -> byte

Public Shared Function Parse (s As String) As Byte

Paramètres

s

String

Chaîne contenant un nombre à convertir. La chaîne est interprétée à l'aide du style Integer.

Retours

Byte

Valeur d'octet qui équivaut au nombre contenu dans s.

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

Le format de s est incorrect.

OverflowException

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

Exemples

L’exemple suivant montre comment convertir une valeur de chaîne en valeur d’octet à l’aide de la Byte.Parse(String) méthode . La valeur d’octet résultante est ensuite affichée dans la console.

String^ stringToConvert = " 162";
Byte byteValue;
try
{
   byteValue = Byte::Parse(stringToConvert);
   Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}   
catch (FormatException^)
{
   Console::WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException^)
{
   Console::WriteLine("'{0}' is greater than {1} or less than {2}.", 
                     stringToConvert, Byte::MaxValue, Byte::MinValue);
}  
// The example displays the following output to the console:
//       Converted ' 162' to 162.

string stringToConvert = " 162";
byte byteValue;
try
{
   byteValue = Byte.Parse(stringToConvert);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException)
{
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.",
                     stringToConvert, Byte.MaxValue, Byte.MinValue);
}
// The example displays the following output to the console:
//       Converted ' 162' to 162.

let stringToConvert = " 162"
try
    let byteValue = Byte.Parse stringToConvert
    printfn $"Converted '{stringToConvert}' to {byteValue}."
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is greater than {Byte.MaxValue} or less than {Byte.MinValue}."

// The example displays the following output to the console:
//       Converted ' 162' to 162.

Dim stringToConvert As String = " 162"
Dim byteValue As Byte
Try
   byteValue = Byte.Parse(stringToConvert)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.", _
                     stringToConvert, Byte.MaxValue, Byte.MinValue)
End Try  
' The example displays the following output to the console:
'       Converted ' 162' to 162.

Remarques

Le s paramètre contient un certain nombre de formes :

[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 positif ou négatif facultatif.
chiffres	Séquence de chiffres compris entre 0 et 9.

Le s paramètre est interprété à l’aide du NumberStyles.Integer style . En plus des 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 qui peuvent être présents dans s, utilisez la Byte.Parse(String, NumberStyles) méthode ou Byte.Parse(String, NumberStyles, IFormatProvider) .

Le s paramètre est analysé à l’aide des informations de mise en forme d’un NumberFormatInfo objet initialisé pour la culture système actuelle. Pour plus d'informations, consultez CurrentInfo. Pour analyser une chaîne à l’aide des informations de mise en forme d’une autre culture, utilisez la Byte.Parse(String, NumberStyles, IFormatProvider) méthode .

Voir aussi

• ToString()
• MaxValue
• MinValue
• NumberStyles
• NumberFormatInfo
• Analyse de chaînes numériques dans .NET
• Mettre en forme des types dans .NET