SByte.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 son équivalent entier 8 bits signé.

Surcharges

Parse(String, NumberStyles, IFormatProvider)	Convertit la chaîne d'un nombre dans un style et un format propre à une culture spécifiés en équivalent signé 8 bits.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convertit la chaîne d'un nombre dans un style et un format propre à une culture spécifiés en équivalent signé 8 bits.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analyse une étendue de caractères UTF-8 dans une valeur.
Parse(String, IFormatProvider)	Convertit la représentation d'un nombre sous forme de chaîne dans un format propre à une culture spécifié en entier 8 bits signé équivalent.
Parse(String)	Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 8 bits signé.
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, NumberStyles)	Convertit une représentation d'un nombre sous forme de chaîne dans un style spécifié en entier 8 bits signé équivalent.

Parse(String, NumberStyles, IFormatProvider)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS

System.Int16.Parse(String, NumberStyles, IFormatProvider)

Convertit la chaîne d'un nombre dans un style et un format propre à une culture spécifiés en équivalent signé 8 bits.

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

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

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

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

Paramètres

s

String

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

style

NumberStyles

Combinaison de bits des 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 de mise en forme propres à la culture sur s. Si provider est null, la culture actuelle du thread est utilisée.

Retours

SByte

Valeur d'octet signée 8 bits équivalente au nombre spécifié dans le paramètre s.

Implémente

Parse(String, NumberStyles, IFormatProvider)

Exceptions

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

style n’est pas une combinaison de AllowHexSpecifier et HexNumber.

ArgumentNullException

s a la valeur null.

FormatException

s n’est pas dans un format compatible avec style.

OverflowException

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

- ou -

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

Exemples

L’exemple suivant illustre l’utilisation de la Parse(String, NumberStyles, IFormatProvider) méthode pour convertir diverses représentations sous forme de chaîne de nombres en valeurs entières signées.

using System;
using System.Globalization;

public class SByteConversion
{
   NumberFormatInfo provider = NumberFormatInfo.CurrentInfo;

   public static void Main()
   {
      string stringValue;
      NumberStyles style;

      stringValue = "   123   ";
      style = NumberStyles.None;     
      CallParseOperation(stringValue, style);
      
      stringValue = "000,000,123";
      style = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallParseOperation(stringValue, style);
      
      stringValue = "-100";
      style = NumberStyles.AllowLeadingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "100-";
      style = NumberStyles.AllowLeadingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "100-";
      style = NumberStyles.AllowTrailingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "$100";
      style = NumberStyles.AllowCurrencySymbol;
      CallParseOperation(stringValue, style);
      
      style = NumberStyles.Integer;
      CallParseOperation(stringValue, style);
      
      style = NumberStyles.AllowDecimalPoint;
      CallParseOperation("100.0", style);
      
      stringValue = "1e02";
      style = NumberStyles.AllowExponent;
      CallParseOperation(stringValue, style);
      
      stringValue = "(100)";
      style = NumberStyles.AllowParentheses;
      CallParseOperation(stringValue, style);
   }
   
   private static void CallParseOperation(string stringValue, 
                                          NumberStyles style)
   {                                          
      sbyte number;
      
      if (stringValue == null)
         Console.WriteLine("Cannot parse a null string...");
         
      try
      {
         number = sbyte.Parse(stringValue, style);
         Console.WriteLine("SByte.Parse('{0}', {1})) = {2}", 
                           stringValue, style, number);   
      }
      catch (FormatException)
      {
         Console.WriteLine("'{0}' and {1} throw a FormatException", 
                           stringValue, style);   
      }      
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is outside the range of a signed byte",
                           stringValue);
      }
   }
}
// The example displays the following information to the console:
//       '   123   ' and None throw a FormatException
//       SByte.Parse('000,000,123', Integer, AllowThousands)) = 123
//       SByte.Parse('-100', AllowLeadingSign)) = -100
//       '100-' and AllowLeadingSign throw a FormatException
//       SByte.Parse('100-', AllowTrailingSign)) = -100
//       SByte.Parse('$100', AllowCurrencySymbol)) = 100
//       '$100' and Integer throw a FormatException
//       SByte.Parse('100.0', AllowDecimalPoint)) = 100
//       SByte.Parse('1e02', AllowExponent)) = 100
//       SByte.Parse('(100)', AllowParentheses)) = -100

open System
open System.Globalization

let provider = NumberFormatInfo.CurrentInfo
   
let callParseOperation stringValue (style: NumberStyles) =
    if stringValue = null then
        printfn "Cannot parse a null string..."
    else
        try
            let number = SByte.Parse(stringValue, style)
            printfn $"SByte.Parse('{stringValue}', {style})) = {number}" 
        with
        | :? FormatException ->
            printfn $"'{stringValue}' and {style} throw a FormatException"
        | :? OverflowException ->
            printfn $"'{stringValue}' is outside the range of a signed byte"

[<EntryPoint>]
let main _ =
    let stringValue = "   123   "
    let style = NumberStyles.None     
    callParseOperation stringValue style
    
    let stringValue = "000,000,123"
    let style = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callParseOperation stringValue style
    
    let stringValue = "-100"
    let style = NumberStyles.AllowLeadingSign
    callParseOperation stringValue style
    
    let stringValue = "100-"
    let style = NumberStyles.AllowLeadingSign
    callParseOperation stringValue style
    
    let stringValue = "100-"
    let style = NumberStyles.AllowTrailingSign
    callParseOperation stringValue style
    
    let stringValue = "$100"
    let style = NumberStyles.AllowCurrencySymbol
    callParseOperation stringValue style
    
    let style = NumberStyles.Integer
    callParseOperation stringValue style
    
    let style = NumberStyles.AllowDecimalPoint
    callParseOperation "100.0" style
    
    let stringValue = "1e02"
    let style = NumberStyles.AllowExponent
    callParseOperation stringValue style
    
    let stringValue = "(100)"
    let style = NumberStyles.AllowParentheses
    callParseOperation stringValue style
    0

// The example displays the following information to the console:
//       '   123   ' and None throw a FormatException
//       SByte.Parse('000,000,123', Integer, AllowThousands)) = 123
//       SByte.Parse('-100', AllowLeadingSign)) = -100
//       '100-' and AllowLeadingSign throw a FormatException
//       SByte.Parse('100-', AllowTrailingSign)) = -100
//       SByte.Parse('$100', AllowCurrencySymbol)) = 100
//       '$100' and Integer throw a FormatException
//       SByte.Parse('100.0', AllowDecimalPoint)) = 100
//       SByte.Parse('1e02', AllowExponent)) = 100
//       SByte.Parse('(100)', AllowParentheses)) = -100

Imports System.Globalization

Module modMain
   Public Sub Main()
      Dim byteString As String 
      
      byteString = " 123"
      ParseString(byteString, NumberStyles.None)
      ParseString(byteString, NumberStyles.Integer)
      
      byteString = "3A"
      ParseString(byteString, NumberStyles.AllowHexSpecifier) 
      
      byteString = "21"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.AllowHexSpecifier)
      
      byteString = "-22"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.AllowParentheses)
      
      byteString = "(45)"
      ParseString(byteString, NumberStyles.AllowParentheses)
     
      byteString = "000,000,056"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.Integer Or NumberStyles.AllowThousands)
   End Sub
   
   Private Sub ParseString(value As String, style As NumberStyles)
      Dim number As SByte
      
      If value Is Nothing Then Console.WriteLine("Cannot parse a null string...") 
      
      Try
         number = SByte.Parse(value, style, NumberFormatInfo.CurrentInfo)
         Console.WriteLine("SByte.Parse('{0}', {1}) = {2}", value, style, number)   
      Catch e As FormatException
         Console.WriteLine("'{0}' and {1} throw a FormatException", value, style)   
      Catch e As OverflowException
         Console.WriteLine("'{0}' is outside the range of a signed byte",
                           value)
      End Try     
   End Sub
End Module
' The example displays the following information to the console:
'       ' 123' and None throw a FormatException
'       SByte.Parse(" 123", Integer)) = 123
'       SByte.Parse("3A", AllowHexSpecifier)) = 58
'       SByte.Parse("21", Integer)) = 21
'       SByte.Parse("21", AllowHexSpecifier)) = 33
'       SByte.Parse("-22", Integer)) = -22
'       '-22' and AllowParentheses throw a FormatException
'       SByte.Parse("(45)", AllowParentheses)) = -45
'       '000,000,056' and Integer throw a FormatException
'       SByte.Parse("000,000,056", Integer, AllowThousands)) = 56

Remarques

Le style paramètre définit les éléments de style (tels que l’espace blanc ou le symbole de signe positif ou négatif) 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] [$][signe]chiffres[.fractional_digits][E[sign]exponential_digits][ws]

Si style inclut AllowHexSpecifier, le s 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 s si style inclut l’indicateur NumberStyles.AllowLeadingWhite , et il peut apparaître à 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 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 facultatif. Le signe peut apparaître au début de s si style inclut l’indicateur NumberStyles.AllowLeadingSign , et il peut apparaître à la fin de s si style inclut l’indicateur NumberStyles.AllowTrailingSign . Vous pouvez utiliser des parenthèses dans s pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses .
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 à 9 si style inclut l’indicateur NumberStyles.AllowExponent , ou une ou plusieurs occurrences du chiffre 0 si ce n’est pas le cas. 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 (scientifique). Le s 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 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 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 s.

Valeurs non composites NumberStyles	Éléments autorisés en s plus des chiffres
NumberStyles.None	Chiffres décimaux uniquement.
NumberStyles.AllowDecimalPoint	Éléments décimaux (.) et fractional_digits . Toutefois, si le style n’inclut pas l’indicateur NumberStyles.AllowExponent , fractional_digits ne doit comporter qu’un ou plusieurs chiffres ; sinon, un OverflowException est levée.
NumberStyles.AllowExponent	Caractère « e » ou « E », qui indique une notation exponentielle, ainsi que exponential_digits.
NumberStyles.AllowLeadingWhite	Élément ws au début de s.
NumberStyles.AllowTrailingWhite	Élément ws à la fin de s.
NumberStyles.AllowLeadingSign	Signe positif avant les chiffres.
NumberStyles.AllowTrailingSign	Signe positif après les chiffres.
NumberStyles.AllowParentheses	Parenthèses avant et après les chiffres pour indiquer une valeur négative.
NumberStyles.AllowThousands	Élément séparateur de groupe (,). Bien que le séparateur de groupe puisse apparaître dans s, il doit être précédé d’un ou plusieurs chiffres 0.
NumberStyles.AllowCurrencySymbol	Élément currency ($).

Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, s 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 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.)

Notes

Si le s paramètre est la représentation sous forme de chaîne d’un nombre hexadécimal, il ne peut pas être précédé d’une décoration (telle que 0x ou &h) qui le différencie en tant que nombre hexadécimal. L’opération d’analyse lève alors une exception.

Si s représente un nombre hexadécimal, la Parse(String, NumberStyles) méthode interprète le bit d’ordre élevé de l’octet comme un bit de signe.

Le provider paramètre est une IFormatProvider implémentation dont GetFormat la méthode retourne un NumberFormatInfo objet qui fournit des informations spécifiques à la culture sur le format de s. Il existe trois façons d’utiliser le provider paramètre pour fournir des informations de mise en forme personnalisées à l’opération d’analyse :

• Vous pouvez passer l’objet réel NumberFormatInfo qui fournit des informations de mise en forme. (Son implémentation de GetFormat retourne simplement elle-même.)

• Vous pouvez passer un CultureInfo objet qui spécifie la culture dont la mise en forme doit être utilisée. Sa NumberFormat propriété fournit des informations de mise en forme.

• Vous pouvez passer une implémentation personnalisée IFormatProvider . Sa GetFormat méthode doit instancier et renvoyer l’objet NumberFormatInfo qui fournit des informations de mise en forme.

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

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Convertit la chaîne d'un nombre dans un style et un format propre à une culture spécifiés en équivalent signé 8 bits.

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

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

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

Paramètres

s

ReadOnlySpan<Char>

Plage contenant les caractères représentant le nombre à convertir. La plage est interprétée à l'aide du style spécifié par style.

style

NumberStyles

Combinaison de bits des 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 de mise en forme propres à la culture sur s. Si provider est null, la culture actuelle du thread est utilisée.

Retours

SByte

Valeur d'octet signée 8 bits équivalente au nombre spécifié dans le paramètre s.

Implémente

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:

SByte.cs

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

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

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

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

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

SByte

Résultat de l’analyse .utf8Text

Implémente

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS

System.Int16.Parse(String)

Convertit la représentation d'un nombre sous forme de chaîne dans un format propre à une culture spécifié en entier 8 bits signé équivalent.

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

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

static member Parse : string * IFormatProvider -> sbyte

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

Paramètres

s

String

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

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur s. Si provider est null, la culture actuelle du thread est utilisée.

Retours

SByte

Entier 8 bits signé qui est équivalent au nombre spécifié 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 à SByte.MinValue ou supérieur à SByte.MaxValue.

Exemples

L’exemple suivant définit un objet personnalisé NumberFormatInfo qui définit le tilde (~) comme signe négatif. Il analyse ensuite un certain nombre de chaînes numériques à l’aide de cet objet personnalisé NumberFormatInfo ainsi que d’un CultureInfo objet qui représente la culture invariante.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo nf = new NumberFormatInfo();
      nf.NegativeSign = "~"; 
      
      string[] values = { "-103", "+12", "~16", "  1", "~255" };
      IFormatProvider[] providers = { nf, CultureInfo.InvariantCulture };
      
      foreach (IFormatProvider provider in providers)
      {
         Console.WriteLine("Conversions using {0}:", ((object) provider).GetType().Name);
         foreach (string value in values)
         {
            try {
               Console.WriteLine("   Converted '{0}' to {1}.", 
                                 value, SByte.Parse(value, provider));
            }                     
            catch (FormatException) {
               Console.WriteLine("   Unable to parse '{0}'.", value);   
            }
            catch (OverflowException) {
               Console.WriteLine("   '{0}' is out of range of the SByte type.", value);         
            }
         }
      }      
   }
}
// The example displays the following output:
//       Conversions using NumberFormatInfo:
//          Unable to parse '-103'.
//          Converted '+12' to 12.
//          Converted '~16' to -16.
//          Converted '  1' to 1.
//          '~255' is out of range of the SByte type.
//       Conversions using CultureInfo:
//          Converted '-103' to -103.
//          Converted '+12' to 12.
//          Unable to parse '~16'.
//          Converted '  1' to 1.
//          Unable to parse '~255'.

open System
open System.Globalization

let nf = NumberFormatInfo()
nf.NegativeSign <- "~" 

let values = [| "-103"; "+12"; "~16"; "  1"; "~255" |]
let providers: IFormatProvider[] = [| nf; CultureInfo.InvariantCulture |]

for provider in providers do
    printfn $"Conversions using {(box provider).GetType().Name}:"
    for value in values do
        try
            printfn $"   Converted '{value}' to {SByte.Parse(value, provider)}."
        with
        | :? FormatException ->
            printfn $"   Unable to parse '{value}'."
        | :? OverflowException ->
            printfn $"   '{value}' is out of range of the SByte type."

// The example displays the following output:
//       Conversions using NumberFormatInfo:
//          Unable to parse '-103'.
//          Converted '+12' to 12.
//          Converted '~16' to -16.
//          Converted '  1' to 1.
//          '~255' is out of range of the SByte type.
//       Conversions using CultureInfo:
//          Converted '-103' to -103.
//          Converted '+12' to 12.
//          Unable to parse '~16'.
//          Converted '  1' to 1.
//          Unable to parse '~255'.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nf As New NumberFormatInfo()
      nf.NegativeSign = "~" 
      
      Dim values() As String = { "-103", "+12", "~16", "  1", "~255" }
      Dim providers() As IFormatProvider = { nf, CultureInfo.InvariantCulture }
      
      For Each provider As IFormatProvider In providers
         Console.WriteLine("Conversions using {0}:", CObj(provider).GetType().Name)
         For Each value As String In values
            Try
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 value, SByte.Parse(value, provider))
            Catch e As FormatException
               Console.WriteLine("   Unable to parse '{0}'.", value)   
            Catch e As OverflowException
               Console.WriteLine("   '{0}' is out of range of the SByte type.", value)         
            End Try
         Next
      Next      
   End Sub
End Module
' The example displays '
'       Conversions using NumberFormatInfo:
'          Unable to parse '-103'.
'          Converted '+12' to 12.
'          Converted '~16' to -16.
'          Converted '  1' to 1.
'          '~255' is out of range of the SByte type.
'       Conversions using CultureInfo:
'          Converted '-103' to -103.
'          Converted '+12' to 12.
'          Unable to parse '~16'.
'          Converted '  1' to 1.
'          Unable to parse '~255'.

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 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 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 s, utilisez la Parse(String, NumberStyles, IFormatProvider) méthode .

Le provider paramètre est une IFormatProvider implémentation dont GetFormat la méthode retourne un NumberFormatInfo objet qui fournit des informations spécifiques à la culture sur le format de s. Il existe trois façons d’utiliser le provider paramètre pour fournir des informations de mise en forme personnalisées à l’opération d’analyse :

• Vous pouvez passer l’objet réel NumberFormatInfo qui fournit des informations de mise en forme. (Son implémentation de GetFormat retourne simplement elle-même.)

• Vous pouvez passer un CultureInfo objet qui spécifie la culture dont la mise en forme doit être utilisée. Sa NumberFormat propriété fournit des informations de mise en forme.

• Vous pouvez passer une implémentation personnalisée IFormatProvider . Sa GetFormat méthode doit instancier et renvoyer l’objet NumberFormatInfo qui fournit des informations de mise en forme.

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

Voir aussi

• ToString()
• TryParse
• Analyse de chaînes numériques dans .NET

Parse(String)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS

System.Int16.Parse(String)

Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 8 bits signé.

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

public static sbyte Parse (string s);

static member Parse : string -> sbyte

Public Shared Function Parse (s As String) As SByte

Paramètres

s

String

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

Retours

SByte

Entier 8 bits signé qui est équivalent au nombre figurant dans le paramètre s.

Exceptions

ArgumentException

s a la valeur null.

FormatException

s n’est pas constitué d’un signe facultatif suivi d’une séquence de chiffres (zéro à neuf).

OverflowException

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

Exemples

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

// Define an array of numeric strings.
string[] values = { "-16", "  -3", "+ 12", " +12 ", "  12  ",
                    "+120", "(103)", "192", "-160" };
                           
// Parse each string and display the result.
foreach (string value in values)
{
   try {
      Console.WriteLine("Converted '{0}' to the SByte value {1}.",
                        value, SByte.Parse(value));
   }
   catch (FormatException) {
      Console.WriteLine("'{0}' cannot be parsed successfully by SByte type.",
                        value);
   }                              
   catch (OverflowException) {
      Console.WriteLine("'{0}' is out of range of the SByte type.",
                        value);
   }                                                                        
}
// The example displays the following output:
//       Converted '-16' to the SByte value -16.
//       Converted '  -3' to the SByte value -3.
//       '+ 12' cannot be parsed successfully by SByte type.
//       Converted ' +12 ' to the SByte value 12.
//       Converted '  12  ' to the SByte value 12.
//       Converted '+120' to the SByte value 120.
//       '(103)' cannot be parsed successfully by SByte type.
//       '192' is out of range of the SByte type.
//       '-160' is out of range of the SByte type.

open System

// Define an array of numeric strings.
let values = 
    [| "-16"; "  -3"; "+ 12"; " +12 "; "  12  "
       "+120"; "(103)"; "192"; "-160" |]
                            
// Parse each string and display the result.
for value in values do
    try
        printfn $"Converted '{value}' to the SByte value {SByte.Parse value}."
    with
    | :? FormatException ->
        printfn $"'{value}' cannot be parsed successfully by SByte type."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the SByte type."
        
// The example displays the following output:
//       Converted '-16' to the SByte value -16.
//       Converted '  -3' to the SByte value -3.
//       '+ 12' cannot be parsed successfully by SByte type.
//       Converted ' +12 ' to the SByte value 12.
//       Converted '  12  ' to the SByte value 12.
//       Converted '+120' to the SByte value 120.
//       '(103)' cannot be parsed successfully by SByte type.
//       '192' is out of range of the SByte type.
//       '-160' is out of range of the SByte type.

' Define an array of numeric strings.
Dim values() As String = { "-16", "  -3", "+ 12", " +12 ", "  12  ", _
                           "+120", "(103)", "192", "-160" }
                           
' Parse each string and display the result.
For Each value As String In values
   Try
      Console.WriteLine("Converted '{0}' to the SByte value {1}.", _
                        value, SByte.Parse(value))
   Catch e As FormatException
      Console.WriteLine("'{0}' cannot be parsed successfully by SByte type.", _
                        value)
   Catch e As OverflowException
      Console.WriteLine("'{0}' is out of range of the SByte type.", _
                        value)
   End Try                                                                        
Next        
' The example displays the following output:
'       Converted '-16' to the SByte value -16.
'       Converted '  -3' to the SByte value -3.
'       '+ 12' cannot be parsed successfully by SByte type.
'       Converted ' +12 ' to the SByte value 12.
'       Converted '  12  ' to the SByte value 12.
'       Converted '+120' to the SByte value 120.
'       '(103)' cannot be parsed successfully by SByte type.
'       '192' is out of range of the SByte type.
'       '-160' is out of range of the SByte type.

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 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 positif ou négatif de début sont autorisés. Pour définir explicitement les éléments de style qui peuvent être présents dans s, utilisez la Parse(String, NumberStyles) méthode ou Parse(String, NumberStyles, IFormatProvider) .

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

Voir aussi

• Analyse de chaînes numériques dans .NET
• Mettre en forme des types dans .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:

SByte.cs

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

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

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

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

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

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

SByte

Résultat de l’analyse .s

Implémente

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:

SByte.cs

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

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

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

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

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

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

SByte

Résultat de l’analyse .utf8Text

Implémente

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String, NumberStyles)

Source:

SByte.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS

System.Int16.Parse(String)

Convertit une représentation d'un nombre sous forme de chaîne dans un style spécifié en entier 8 bits signé équivalent.

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

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

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

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

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 des 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

SByte

Entier 8 bits signé qui est équivalent au nombre spécifié dans s.

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

s n’est pas dans un format compatible avec style.

OverflowException

s représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.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 de chaîne de SByte valeurs avec la Parse(String, NumberStyles) méthode . La culture actuelle de l’exemple est en-US.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberStyles style;
      sbyte number;

      // Parse value with no styles allowed.
      string[] values1 = { " 121 ", "121", "-121" };
      style = NumberStyles.None;
      Console.WriteLine("Styles: {0}", style.ToString());
      foreach (string value in values1)
      {
         try {
            number = SByte.Parse(value, style);
            Console.WriteLine("   Converted '{0}' to {1}.", value, number);
         }   
         catch (FormatException) {
            Console.WriteLine("   Unable to parse '{0}'.", value);
         }
      }
      Console.WriteLine();
            
      // Parse value with trailing sign.
      style = NumberStyles.Integer | NumberStyles.AllowTrailingSign;
      string[] values2 = { " 103+", " 103 +", "+103", "(103)", "   +103  " };
      Console.WriteLine("Styles: {0}", style.ToString());
      foreach (string value in values2)
      {
         try {
            number = SByte.Parse(value, style);
            Console.WriteLine("   Converted '{0}' to {1}.", value, number);
         }   
         catch (FormatException) {
            Console.WriteLine("   Unable to parse '{0}'.", value);
         }      
         catch (OverflowException) {
            Console.WriteLine("   '{0}' is out of range of the SByte type.", value);         
         }
      }      
      Console.WriteLine();
   }
}
// The example displays the following output:
//       Styles: None
//          Unable to parse ' 121 '.
//          Converted '121' to 121.
//          Unable to parse '-121'.
//       
//       Styles: Integer, AllowTrailingSign
//          Converted ' 103+' to 103.
//          Converted ' 103 +' to 103.
//          Converted '+103' to 103.
//          Unable to parse '(103)'.
//          Converted '   +103  ' to 103.

open System
open System.Globalization

// Parse value with no styles allowed.
let values1 = [| " 121 "; "121"; "-121" |]
let style = NumberStyles.None
printfn $"Styles: {style}"
for value in values1 do
    try
        let number = SByte.Parse(value, style)
        printfn $"   Converted '{value}' to {number}."
    with :? FormatException ->
        printfn $"   Unable to parse '{value}'."
printfn ""
            
// Parse value with trailing sign.
let style2 = NumberStyles.Integer ||| NumberStyles.AllowTrailingSign
let values2 = [| " 103+"; " 103 +"; "+103"; "(103)"; "   +103  " |]
printfn $"Styles: {style2}"
for value in values2 do
    try
        let number = SByte.Parse(value, style2)
        printfn $"   Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"   Unable to parse '{value}'."
    | :? OverflowException ->
        printfn $"   '{value}' is out of range of the SByte type."         
printfn ""
// The example displays the following output:
//       Styles: None
//          Unable to parse ' 121 '.
//          Converted '121' to 121.
//          Unable to parse '-121'.
//       
//       Styles: Integer, AllowTrailingSign
//          Converted ' 103+' to 103.
//          Converted ' 103 +' to 103.
//          Converted '+103' to 103.
//          Unable to parse '(103)'.
//          Converted '   +103  ' to 103.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim style As NumberStyles
      Dim number As SByte

      ' Parse value with no styles allowed.
      Dim values1() As String = { " 121 ", "121", "-121" }
      style = NumberStyles.None
      Console.WriteLine("Styles: {0}", style.ToString())
      For Each value As String In values1
         Try
            number = SByte.Parse(value, style)
            Console.WriteLine("   Converted '{0}' to {1}.", value, number)
         Catch e As FormatException
            Console.WriteLine("   Unable to parse '{0}'.", value)   
         End Try
      Next
      Console.WriteLine()
            
      ' Parse value with trailing sign.
      style = NumberStyles.Integer Or NumberStyles.AllowTrailingSign
      Dim values2() As String = { " 103+", " 103 +", "+103", "(103)", "   +103  " }
      Console.WriteLine("Styles: {0}", style.ToString())
      For Each value As String In values2
         Try
            number = SByte.Parse(value, style)
            Console.WriteLine("   Converted '{0}' to {1}.", value, number)
         Catch e As FormatException
            Console.WriteLine("   Unable to parse '{0}'.", value)   
         Catch e As OverflowException
            Console.WriteLine("   '{0}' is out of range of the SByte type.", value)         
         End Try
      Next      
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       Styles: None
'          Unable to parse ' 121 '.
'          Converted '121' to 121.
'          Unable to parse '-121'.
'       
'       Styles: Integer, AllowTrailingSign
'          Converted ' 103+' to 103.
'          Converted ' 103 +' to 103.
'          Converted '+103' to 103.
'          Unable to parse '(103)'.
'          Converted '   +103  ' to 103.

Remarques

Le style paramètre définit les éléments de style (tels que l’espace blanc ou le symbole de signe positif ou négatif) 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] [$][signe]chiffres[.fractional_digits][E[sign]exponential_digits][ws]

Si style inclut NumberStyles.AllowHexSpecifier, le s paramètre peut contenir 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 s si style inclut l’indicateur NumberStyles.AllowLeadingWhite , et il peut apparaître à 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 facultatif. Le signe peut apparaître au début de s si style inclut l’indicateur NumberStyles.AllowLeadingSign , et il peut apparaître à la fin de s si style inclut l’indicateur NumberStyles.AllowTrailingSign . Vous pouvez utiliser des parenthèses dans s pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses .
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 à 9 si style inclut l’indicateur NumberStyles.AllowExponent , ou une ou plusieurs occurrences du chiffre 0 si ce n’est pas le cas. 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 (scientifique). Le s paramètre peut représenter un nombre en notation exponentielle si style inclut l’indicateur NumberStyles.AllowExponent .
exponential_digits	Une ou plusieurs occurrences du chiffre 0-9. 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 présents, mais qui ne sont pas obligatoirement présents, dans la 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 décimaux (.) et fractional_digits . Toutefois, si style n’inclut pas l’indicateur NumberStyles.AllowExponent , fractional_digits ne doit comporter qu’un ou plusieurs chiffres ; sinon, un OverflowException est levée.
NumberStyles.AllowExponent	Caractère « e » ou « E », qui indique une notation exponentielle, ainsi que exponential_digits.
NumberStyles.AllowLeadingWhite	Élément ws au début de s.
NumberStyles.AllowTrailingWhite	Élément ws à la fin de s.
NumberStyles.AllowLeadingSign	Signe positif avant les chiffres.
NumberStyles.AllowTrailingSign	Signe positif après les chiffres.
NumberStyles.AllowParentheses	Élément sign sous forme de parenthèses englobant la valeur numérique.
NumberStyles.AllowThousands	Élément séparateur de groupe (,). Bien que le séparateur de groupe puisse apparaître dans s, il doit être précédé d’un ou plusieurs chiffres 0.
NumberStyles.AllowCurrencySymbol	Élément currency ($).

Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, s doit être une valeur hexadécimale. Les chiffres hexadécimaux valides sont 0-9, a-f et A-F. Un préfixe tel que « 0x » n’est pas pris en charge et provoque l’échec de l’opération d’analyse. Les seuls autres indicateurs qui peuvent être combinés inclus dans style 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.)

Notes

Si le s paramètre est la représentation sous forme de chaîne d’un nombre hexadécimal, il ne peut pas être précédé d’une décoration (telle que 0x ou &h) qui le différencie en tant que nombre hexadécimal. L’opération d’analyse lève alors une exception.

Si s représente un nombre hexadécimal, la Parse(String, NumberStyles) méthode interprète le bit d’ordre élevé de l’octet comme un bit de signe.

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

Voir aussi

• ToString()
• TryParse
• Analyse des chaînes numériques dans .NET
• Mettre en forme des types dans .NET