SByte.Parse Méthode
Définition
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.
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
- Source:
- SByte.cs
- 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);
public:
static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::SByte>::Parse;
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> sbyte
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
Valeur d'octet signée 8 bits équivalente au nombre spécifié dans le paramètre s
.
Implémente
- Attributs
Exceptions
style
n’est pas une valeur NumberStyles.
- ou -
style
n’est pas une combinaison de AllowHexSpecifier et HexNumber.
s
a la valeur null
.
s
n’est pas dans un format compatible avec style
.
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é.
S’applique à
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Source:
- SByte.cs
- Source:
- SByte.cs
- 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);
[System.CLSCompliant(false)]
public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
[System.CLSCompliant(false)]
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
[<System.CLSCompliant(false)>]
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
Valeur d'octet signée 8 bits équivalente au nombre spécifié dans le paramètre s
.
Implémente
- Attributs
S’applique à
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Source:
- SByte.cs
- 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
Résultat de l’analyse .utf8Text
Implémente
S’applique à
Parse(String, IFormatProvider)
- Source:
- SByte.cs
- Source:
- SByte.cs
- 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);
public:
static System::SByte Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::SByte>::Parse;
[System.CLSCompliant(false)]
public static sbyte Parse (string s, IFormatProvider provider);
public static sbyte Parse (string s, IFormatProvider? provider);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, IFormatProvider? provider);
[<System.CLSCompliant(false)>]
static member Parse : string * IFormatProvider -> sbyte
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
Entier 8 bits signé qui est équivalent au nombre spécifié dans s
.
Implémente
- Attributs
Exceptions
s
a la valeur null
.
Le format de s
est incorrect.
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
S’applique à
Parse(String)
- Source:
- SByte.cs
- Source:
- SByte.cs
- 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);
[System.CLSCompliant(false)]
public static sbyte Parse (string s);
public static sbyte Parse (string s);
[<System.CLSCompliant(false)>]
static member Parse : string -> sbyte
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
Entier 8 bits signé qui est équivalent au nombre figurant dans le paramètre s
.
- Attributs
Exceptions
s
a la valeur null
.
s
n’est pas constitué d’un signe facultatif suivi d’une séquence de chiffres (zéro à neuf).
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
S’applique à
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Source:
- SByte.cs
- Source:
- SByte.cs
- 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
Résultat de l’analyse .s
Implémente
S’applique à
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Source:
- SByte.cs
- 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
Résultat de l’analyse .utf8Text
Implémente
S’applique à
Parse(String, NumberStyles)
- Source:
- SByte.cs
- Source:
- SByte.cs
- 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);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style);
public static sbyte Parse (string s, System.Globalization.NumberStyles style);
[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles -> sbyte
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
Entier 8 bits signé qui est équivalent au nombre spécifié dans s
.
- Attributs
Exceptions
s
a la valeur null
.
s
n’est pas dans un format compatible avec style
.
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.
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
S’applique à
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de l’année 2024, nous abandonnerons progressivement le mécanisme de retour d’information GitHub Issues pour le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez :Soumettre et afficher des commentaires pour