Int16.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 16 bits signé.
Surcharges
Parse(String, NumberStyles, IFormatProvider) |
Convertit la représentation sous forme de chaîne d'un nombre dans un style et un format propre à une culture spécifiés en entier 16 bits signé équivalent. |
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Convertit la représentation sous forme de plage d'un nombre dans un style et un format propre à une culture spécifiés en entier 16 bits signé équivalent. |
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 16 bits signé équivalent. |
Parse(String) |
Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 16 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 16 bits signé équivalent. |
Parse(String, NumberStyles, IFormatProvider)
- Source:
- Int16.cs
- Source:
- Int16.cs
- Source:
- Int16.cs
Convertit la représentation sous forme de chaîne d'un nombre dans un style et un format propre à une culture spécifiés en entier 16 bits signé équivalent.
public:
static short Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
static short Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<short>::Parse;
public static short Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static short Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> int16
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Short
Paramètres
- s
- String
Chaîne contenant un nombre à 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
IFormatProvider qui fournit des informations de format propres à la culture concernant s
.
Retours
Entier 16 bits signé équivalant au nombre spécifié dans s
.
Implémente
Exceptions
s
a la valeur null
.
style
n’est pas une valeur NumberStyles.
- ou -
style
n’est pas une combinaison des valeurs AllowHexSpecifier et HexNumber.
s
n’est pas dans un format compatible avec style
.
s
représente un nombre inférieur à Int16.MinValue ou supérieur à Int16.MaxValue.
- ou -
s
inclut des chiffres fractionnaires différents de zéro.
Exemples
L’exemple suivant utilise divers style
paramètres et provider
pour analyser les représentations sous forme de chaîne de Int16 valeurs.
String^ value;
Int16 number;
NumberStyles style;
// Parse string using "." as the thousands separator
// and " " as the decimal separator.
value = "19 694,00";
style = NumberStyles::AllowDecimalPoint | NumberStyles::AllowThousands;
CultureInfo^ provider = gcnew CultureInfo("fr-FR");
number = Int16::Parse(value, style, provider);
Console::WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
// '19 694,00' converted to 19694.
try
{
number = Int16::Parse(value, style, CultureInfo::InvariantCulture);
Console::WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
// Unable to parse '19 694,00'.
// Parse string using "$" as the currency symbol for en_GB and
// en-US cultures.
value = "$6,032.00";
style = NumberStyles::Number | NumberStyles::AllowCurrencySymbol;
provider = gcnew CultureInfo("en-GB");
try
{
number = Int16::Parse(value, style, CultureInfo::InvariantCulture);
Console::WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
// Unable to parse '$6,032.00'.
provider = gcnew CultureInfo("en-US");
number = Int16::Parse(value, style, provider);
Console::WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
// '$6,032.00' converted to 6032.
string value;
short number;
NumberStyles style;
CultureInfo provider;
// Parse string using "." as the thousands separator
// and " " as the decimal separator.
value = "19 694,00";
style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
provider = new CultureInfo("fr-FR");
number = Int16.Parse(value, style, provider);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
// '19 694,00' converted to 19694.
try
{
number = Int16.Parse(value, style, CultureInfo.InvariantCulture);
Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
// Unable to parse '19 694,00'.
// Parse string using "$" as the currency symbol for en_GB and
// en-US cultures.
value = "$6,032.00";
style = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
provider = new CultureInfo("en-GB");
try
{
number = Int16.Parse(value, style, CultureInfo.InvariantCulture);
Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
// Unable to parse '$6,032.00'.
provider = new CultureInfo("en-US");
number = Int16.Parse(value, style, provider);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
// '$6,032.00' converted to 6032.
// Parse string using "." as the thousands separator
// and " " as the decimal separator.
let value = "19 694,00"
let style = NumberStyles.AllowDecimalPoint ||| NumberStyles.AllowThousands
let provider = CultureInfo "fr-FR"
let number = Int16.Parse(value, style, provider)
printfn $"'{value}' converted to {number}."
// Displays:
// '19 694,00' converted to 19694.
try
let number = Int16.Parse(value, style, CultureInfo.InvariantCulture)
printfn $"'{value}' converted to {number}."
with :? FormatException ->
printfn $"Unable to parse '{value}'."
// Displays:
// Unable to parse '19 694,00'.
// Parse string using "$" as the currency symbol for en_GB and
// en-US cultures.
let value = "$6,032.00"
let style = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
try
let number = Int16.Parse(value, style, CultureInfo.InvariantCulture)
printfn $"'{value}' converted to {number}."
with :? FormatException ->
printfn $"Unable to parse '{value}'."
// Displays:
// Unable to parse '$6,032.00'.
let provider = CultureInfo "en-US"
let number = Int16.Parse(value, style, provider)
printfn $"'{value}' converted to {number}."
// Displays:
// '$6,032.00' converted to 6032.
Dim value As String
Dim number As Short
Dim style As NumberStyles
Dim provider As CultureInfo
' Parse string using "." as the thousands separator
' and " " as the decimal separator.
value = "19 694,00"
style = NumberStyles.AllowDecimalPoint Or NumberStyles.AllowThousands
provider = New CultureInfo("fr-FR")
number = Int16.Parse(value, style, provider)
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays:
' '19 694,00' converted to 19694.
Try
number = Int16.Parse(value, style, CultureInfo.InvariantCulture)
Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays:
' Unable to parse '19 694,00'.
' Parse string using "$" as the currency symbol for en_GB and
' en-US cultures.
value = "$6,032.00"
style = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
provider = New CultureInfo("en-GB")
Try
number = Int16.Parse(value, style, CultureInfo.InvariantCulture)
Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays:
' Unable to parse '$6,032.00'.
provider = New CultureInfo("en-US")
number = Int16.Parse(value, style, provider)
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays:
' '$6,032.00' converted to 6032.
Remarques
Le style
paramètre définit les éléments de style (tels que l’espace blanc ou le signe positif) qui sont 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,]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. Les espaces blancs peuvent 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é et NumberFormatInfo.CurrencyNegativePattern 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 . Les parenthèses peuvent être utilisées dans s pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses . |
chiffres | Séquence de chiffres comprises entre 0 et 9. |
, | Symbole de séparateur de milliers propre à la culture. Le symbole séparateur de milliers de la culture actuelle peut apparaître dans s si style inclut l’indicateur NumberStyles.AllowThousands . |
. | 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 | Séquence du chiffre 0. Les chiffres fractionnaires peuvent apparaître dans s si style inclut l’indicateur NumberStyles.AllowDecimalPoint . Si un chiffre autre que 0 apparaît dans fractional_digits, la méthode lève un OverflowException. |
e | Caractère « e » ou « E », qui indique que s peut être représenté en notation exponentielle. Le s paramètre peut représenter un nombre en notation exponentielle si style inclut l’indicateur NumberStyles.AllowExponent . Toutefois, le s paramètre doit représenter un nombre dans la plage du type de Int16 données et ne peut pas avoir un composant fractionnaire autre que zéro. |
hexdigits | Séquence de chiffres hexadécimaux de 0 à f ou de 0 à F. |
Notes
Tous les caractères NUL (U+0000) de fin 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 uniquement (qui correspond au NumberStyles.None style) analyse toujours correctement. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être, mais qui ne sont pas obligatoirement 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 0 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 peut apparaître avant les chiffres. |
NumberStyles.AllowTrailingSign | Un signe peut apparaître après les chiffres. |
NumberStyles.AllowParentheses | Élément sign sous la forme de parenthèses englobant la valeur numérique. |
NumberStyles.AllowThousands | Élément , . |
NumberStyles.AllowCurrencySymbol | Élément $. |
Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, s
doit être la représentation sous forme de chaîne d’une valeur hexadécimale sans préfixe. Par exemple, « 9AF3 » analyse correctement, mais « 0x9AF3 » 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 dont GetFormat la méthode obtient un NumberFormatInfo objet. L’objet NumberFormatInfo fournit des informations spécifiques à la culture sur le format de s
. Si provider
est null
, l’objet NumberFormatInfo de la culture actuelle est utilisé.
Voir aussi
S’applique à
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Source:
- Int16.cs
- Source:
- Int16.cs
- Source:
- Int16.cs
Convertit la représentation sous forme de plage d'un nombre dans un style et un format propre à une culture spécifiés en entier 16 bits signé équivalent.
public static short Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
public static short Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> int16
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Short
Paramètres
- s
- ReadOnlySpan<Char>
Plage contenant les caractères représentant le nombre à 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
IFormatProvider qui fournit des informations de format propres à la culture concernant s
.
Retours
Entier 16 bits signé équivalant au nombre spécifié dans s
.
Implémente
S’applique à
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Source:
- Int16.cs
- Source:
- Int16.cs
Analyse une étendue de caractères UTF-8 dans une valeur.
public static short Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> int16
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Short
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:
- Int16.cs
- Source:
- Int16.cs
- Source:
- Int16.cs
Convertit la représentation d'un nombre sous forme de chaîne dans un format propre à une culture spécifié en entier 16 bits signé équivalent.
public:
static short Parse(System::String ^ s, IFormatProvider ^ provider);
public:
static short Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<short>::Parse;
public static short Parse (string s, IFormatProvider provider);
public static short Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> int16
Public Shared Function Parse (s As String, provider As IFormatProvider) As Short
Paramètres
- s
- String
Chaîne contenant un nombre à convertir.
- provider
- IFormatProvider
IFormatProvider qui fournit des informations de format propres à la culture concernant s
.
Retours
Entier 16 bits signé équivalant au nombre spécifié dans s
.
Implémente
Exceptions
s
a la valeur null
.
Le format de s
est incorrect.
s
représente un nombre inférieur à Int16.MinValue ou supérieur à Int16.MaxValue.
Exemples
L’exemple suivant analyse les représentations de chaîne de Int16 valeurs avec la Int16.Parse(String, IFormatProvider) méthode .
String^ stringToConvert;
Int16 number;
stringToConvert = " 214 ";
try
{
number = Int16::Parse(stringToConvert, CultureInfo::InvariantCulture);
Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException ^e)
{
Console::WriteLine("'{0'} is out of range of the Int16 data type.",
stringToConvert);
}
stringToConvert = " + 214";
try
{
number = Int16::Parse(stringToConvert, CultureInfo::InvariantCulture);
Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException ^e)
{
Console::WriteLine("'{0'} is out of range of the Int16 data type.",
stringToConvert);
}
stringToConvert = " +214 ";
try
{
number = Int16::Parse(stringToConvert, CultureInfo::InvariantCulture);
Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException ^e)
{
Console::WriteLine("'{0'} is out of range of the Int16 data type.",
stringToConvert);
}
// The example displays the following output to the console:
// Converted ' 214 ' to 214.
// Unable to parse ' + 214'.
// Converted ' +214 ' to 214.
string stringToConvert;
short number;
stringToConvert = " 214 ";
try
{
number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture);
Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException)
{
Console.WriteLine("'{0'} is out of range of the Int16 data type.",
stringToConvert);
}
stringToConvert = " + 214";
try
{
number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture);
Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException)
{
Console.WriteLine("'{0'} is out of range of the Int16 data type.",
stringToConvert);
}
stringToConvert = " +214 ";
try
{
number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture);
Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException)
{
Console.WriteLine("'{0'} is out of range of the Int16 data type.",
stringToConvert);
}
// 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 number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
printfn $"Converted '{stringToConvert}' to {number}."
with
| :? FormatException ->
printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
printfn $"'{stringToConvert}' is out of range of the Int16 data type."
let stringToConvert = " + 214"
try
let number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
printfn $"Converted '{stringToConvert}' to {number}."
with
| :? FormatException ->
printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
printfn $"'{stringToConvert}' is out of range of the Int16 data type."
let stringToConvert = " +214 "
try
let number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
printfn $"Converted '{stringToConvert}' to {number}."
with
| :? FormatException ->
printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
printfn $"'{stringToConvert}' is out of range of the Int16 data type."
// 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 number As Short
stringToConvert = " 214 "
Try
number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
Catch e As FormatException
Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
Console.WriteLine("'{0'} is out of range of the Int16 data type.", _
stringToConvert)
End Try
stringToConvert = " + 214"
Try
number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
Catch e As FormatException
Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
Console.WriteLine("'{0'} is out of range of the Int16 data type.", _
stringToConvert)
End Try
stringToConvert = " +214 "
Try
number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
Catch e As FormatException
Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
Console.WriteLine("'{0'} is out of range of the Int16 data type.", _
stringToConvert)
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 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, seuls les espaces de début et de fin ainsi qu’un signe de début sont autorisés dans 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 Int16.Parse(String, NumberStyles, IFormatProvider) méthode .
Le provider
paramètre est une IFormatProvider implémentation qui obtient un NumberFormatInfo objet. fournit NumberFormatInfo des informations spécifiques à la culture sur le format de s
. Si provider
est null
, le NumberFormatInfo pour la culture actuelle est utilisé.
Voir aussi
S’applique à
Parse(String)
- Source:
- Int16.cs
- Source:
- Int16.cs
- Source:
- Int16.cs
Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 16 bits signé.
public:
static short Parse(System::String ^ s);
public static short Parse (string s);
static member Parse : string -> int16
Public Shared Function Parse (s As String) As Short
Paramètres
- s
- String
Chaîne contenant un nombre à convertir.
Retours
Entier 16 bits signé équivalant au nombre contenu dans s
.
Exceptions
s
a la valeur null
.
Le format de s
est incorrect.
s
représente un nombre inférieur à Int16.MinValue ou supérieur à Int16.MaxValue.
Exemples
L’exemple suivant montre comment convertir une valeur de chaîne en une valeur entière signée 16 bits à l’aide de la Int16.Parse(String) méthode . La valeur entière résultante est ensuite affichée dans la console.
String^ value;
Int16 number;
value = " 12603 ";
try
{
number = Int16::Parse(value);
Console::WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
value);
}
value = " 16,054";
try
{
number = Int16::Parse(value);
Console::WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
value);
}
value = " -17264";
try
{
number = Int16::Parse(value);
Console::WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
value);
}
// The example displays the following output to the console:
// Converted ' 12603 ' to 12603.
// Unable to convert ' 16,054' to a 16-bit signed integer.
// Converted ' -17264' to -17264.
string value;
short number;
value = " 12603 ";
try
{
number = Int16.Parse(value);
Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
value);
}
value = " 16,054";
try
{
number = Int16.Parse(value);
Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
value);
}
value = " -17264";
try
{
number = Int16.Parse(value);
Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
value);
}
// The example displays the following output to the console:
// Converted ' 12603 ' to 12603.
// Unable to convert ' 16,054' to a 16-bit signed integer.
// Converted ' -17264' to -17264.
let value = " 12603 "
try
let number = Int16.Parse value
printfn $"Converted '{value}' to {number}."
with :? FormatException ->
printfn $"Unable to convert '{value}' to a 16-bit signed integer."
let value = " 16,054"
try
let number = Int16.Parse value
printfn $"Converted '{value}' to {number}."
with :? FormatException ->
printfn "Unable to convert '{value}' to a 16-bit signed integer."
let value = " -17264"
try
let number = Int16.Parse value
printfn $"Converted '{value}' to {number}."
with :? FormatException ->
printfn "Unable to convert '{value}' to a 16-bit signed integer."
// The example displays the following output to the console:
// Converted ' 12603 ' to 12603.
// Unable to convert ' 16,054' to a 16-bit signed integer.
// Converted ' -17264' to -17264.
Dim value As String
Dim number As Short
value = " 12603 "
Try
number = Short.Parse(value)
Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.", _
value)
End Try
value = " 16,054"
Try
number = Short.Parse(value)
Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.", _
value)
End Try
value = " -17264"
Try
number = Short.Parse(value)
Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.", _
value)
End Try
' The example displays the following output to the console:
' Converted ' 12603 ' to 12603.
' Unable to convert ' 16,054' to a 16-bit signed integer.
' Converted ' -17264' to -17264.
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 entière, seuls les espaces de début et de fin ainsi qu’un signe de début sont autorisés. Pour définir explicitement les éléments de style qui peuvent être présents dans s
, utilisez la Int16.Parse(String, NumberStyles) méthode ou Parse .
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 Int16.Parse(String, IFormatProvider)Int16.Parse(String, NumberStyles, IFormatProvider) méthode ou .
Voir aussi
S’applique à
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Source:
- Int16.cs
- Source:
- Int16.cs
- Source:
- Int16.cs
Analyse une étendue de caractères dans une valeur.
public:
static short Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<short>::Parse;
public static short Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> int16
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Short
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:
- Int16.cs
- Source:
- Int16.cs
Analyse une étendue de caractères UTF-8 dans une valeur.
public:
static short Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<short>::Parse;
public static short Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> int16
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Short
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:
- Int16.cs
- Source:
- Int16.cs
- Source:
- Int16.cs
Convertit une représentation d'un nombre sous forme de chaîne dans un style spécifié en entier 16 bits signé équivalent.
public:
static short Parse(System::String ^ s, System::Globalization::NumberStyles style);
public static short Parse (string s, System.Globalization.NumberStyles style);
static member Parse : string * System.Globalization.NumberStyles -> int16
Public Shared Function Parse (s As String, style As NumberStyles) As Short
Paramètres
- s
- String
Chaîne contenant un nombre à convertir.
- 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 16 bits signé équivalant au nombre spécifié dans s
.
Exceptions
s
a la valeur null
.
style
n’est pas une valeur NumberStyles.
- ou -
style
n’est pas une combinaison des valeurs AllowHexSpecifier et HexNumber.
s
n’est pas dans un format compatible avec style
.
s
représente un nombre inférieur à Int16.MinValue ou supérieur à Int16.MaxValue.
- ou -
s
inclut des chiffres fractionnaires différents de zéro.
Exemples
L’exemple suivant utilise la Int16.Parse(String, NumberStyles) méthode pour analyser les représentations de chaîne de valeurs à l’aide de Int16 la culture en-US.
using namespace System;
using namespace System::Globalization;
ref class ParseSample
{
public:
static void Main()
{
String^ value;
NumberStyles style;
// Parse a number with a thousands separator (throws an exception).
value = "14,644";
style = NumberStyles::None;
ParseSample::ParseToInt16(value, style);
style = NumberStyles::AllowThousands;
ParseToInt16(value, style);
// Parse a number with a thousands separator and decimal point.
value = "14,644.00";
style = NumberStyles::AllowThousands | NumberStyles::Integer |
NumberStyles::AllowDecimalPoint;
ParseToInt16(value, style);
// Parse a number with a fractional component (throws an exception).
value = "14,644.001";
ParseToInt16(value, style);
// Parse a number in exponential notation.
value = "145E02";
style = style | NumberStyles::AllowExponent;
ParseToInt16(value, style);
// Parse a number in exponential notation with a positive sign.
value = "145E+02";
ParseToInt16(value, style);
// Parse a number in exponential notation with a negative sign
// (throws an exception).
value = "145E-02";
ParseToInt16(value, style);
}
private:
static void ParseToInt16(String^ value, NumberStyles style)
{
try
{
Int16 number = Int16::Parse(value, style);
Console::WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException ^e)
{
Console::WriteLine("Unable to parse '{0}' with style {1}.", value,
style);
}
catch (OverflowException ^e)
{
Console::WriteLine("'{0}' is out of range of the Int16 type.", value);
}
}
};
int main()
{
ParseSample::Main();
Console::ReadLine();
return 0;
}
// The example displays the following output:
// Unable to parse '14,644' with style None.
// Converted '14,644' to 14644.
// Converted '14,644.00' to 14644.
// '14,644.001' is out of range of the Int16 type.
// Converted '145E02' to 14500.
// Converted '145E+02' to 14500.
// '145E-02' is out of range of the Int16 type.
using System;
using System.Globalization;
public class ParseSample
{
public static void Main()
{
string value;
NumberStyles style;
// Parse a number with a thousands separator (throws an exception).
value = "14,644";
style = NumberStyles.None;
ParseToInt16(value, style);
style = NumberStyles.AllowThousands;
ParseToInt16(value, style);
// Parse a number with a thousands separator and decimal point.
value = "14,644.00";
style = NumberStyles.AllowThousands | NumberStyles.Integer |
NumberStyles.AllowDecimalPoint;
ParseToInt16(value, style);
// Parse a number with a fractional component (throws an exception).
value = "14,644.001";
ParseToInt16(value, style);
// Parse a number in exponential notation.
value = "145E02";
style = style | NumberStyles.AllowExponent;
ParseToInt16(value, style);
// Parse a number in exponential notation with a positive sign.
value = "145E+02";
ParseToInt16(value, style);
// Parse a number in exponential notation with a negative sign
// (throws an exception).
value = "145E-02";
ParseToInt16(value, style);
}
private static void ParseToInt16(string value, NumberStyles style)
{
try
{
short number = Int16.Parse(value, style);
Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException)
{
Console.WriteLine("Unable to parse '{0}' with style {1}.", value,
style.ToString());
}
catch (OverflowException)
{
Console.WriteLine("'{0}' is out of range of the Int16 type.", value);
}
}
}
// The example displays the following output to the console:
// Unable to parse '14,644' with style None.
// Converted '14,644' to 14644.
// Converted '14,644.00' to 14644.
// '14,644.001' is out of range of the Int16 type.
// Converted '145E02' to 14500.
// Converted '145E+02' to 14500.
// '145E-02' is out of range of the Int16 type.
open System
open System.Globalization
let parseToInt16 (value: string) (style: NumberStyles) =
try
let number = Int16.Parse(value, style)
printfn $"Converted '{value}' to {number}."
with
| :? FormatException ->
printfn $"Unable to parse '{value}' with style {style}."
| :? OverflowException ->
printfn $"'{value}' is out of range of the Int16 type."
[<EntryPoint>]
let main _ =
// Parse a number with a thousands separator (throws an exception).
let value = "14,644"
let style = NumberStyles.None
parseToInt16 value style
let style = NumberStyles.AllowThousands
parseToInt16 value style
// Parse a number with a thousands separator and decimal point.
let value = "14,644.00"
let style = NumberStyles.AllowThousands ||| NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
parseToInt16 value style
// Parse a number with a fractional component (throws an exception).
let value = "14,644.001"
parseToInt16 value style
// Parse a number in exponential notation.
let value = "145E02"
let style = style ||| NumberStyles.AllowExponent
parseToInt16 value style
// Parse a number in exponential notation with a positive sign.
let value = "145E+02"
parseToInt16 value style
// Parse a number in exponential notation with a negative sign
// (throws an exception).
let value = "145E-02"
parseToInt16 value style
0
// The example displays the following output to the console:
// Unable to parse '14,644' with style None.
// Converted '14,644' to 14644.
// Converted '14,644.00' to 14644.
// '14,644.001' is out of range of the Int16 type.
// Converted '145E02' to 14500.
// Converted '145E+02' to 14500.
// '145E-02' is out of range of the Int16 type.
Imports System.Globalization
Module ParseSample
Public Sub Main()
Dim value As String
Dim style As NumberStyles
' Parse a number with a thousands separator (throws an exception).
value = "14,644"
style = NumberStyles.None
ParseToInt16(value, style)
style = NumberStyles.AllowThousands
ParseToInt16(value, style)
' Parse a number with a thousands separator and decimal point.
value = "14,644.00"
style = NumberStyles.AllowThousands Or NumberStyles.Integer Or _
NumberStyles.AllowDecimalPoint
ParseToInt16(value, style)
' Parse a number with a fractional component (throws an exception).
value = "14,644.001"
ParseToInt16(value, style)
' Parse a number in exponential notation.
value = "145E02"
style = style Or NumberStyles.AllowExponent
ParseToInt16(value, style)
' Parse a number in exponential notation with a positive sign.
value = "145E+02"
ParseToInt16(value, style)
' Parse a number in exponential notation with a negative sign
' (throws an exception).
value = "145E-02"
ParseToInt16(value, style)
End Sub
Private Sub ParseToInt16(value As String, style As NumberStyles)
Try
Dim number As Short = Int16.Parse(value, style)
Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
Console.WriteLine("Unable to parse '{0}' with style {1}.", value, _
style.ToString())
Catch e As OverflowException
Console.WriteLine("'{0}' is out of range of the Int16 type.", value)
End Try
End Sub
End Module
' The example displays the following output to the console:
' Unable to parse '14,644' with style None.
' Converted '14,644' to 14644.
' Converted '14,644.00' to 14644.
' '14,644.001' is out of range of the Int16 type.
' Converted '145E02' to 14500.
' Converted '145E+02' to 14500.
' '145E-02' is out of range of the Int16 type.
Remarques
Le style
paramètre définit les éléments de style (tels qu’un espace blanc ou un symbole de signe) qui sont 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,]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. Les espaces blancs peuvent 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é et NumberFormatInfo.CurrencyNegativePattern 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 . Les parenthèses peuvent être utilisées dans s pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses . |
chiffres | Séquence de chiffres comprises entre 0 et 9. |
, | Symbole de séparateur de milliers propre à la culture. Le symbole séparateur de milliers de la culture actuelle peut apparaître dans s si style inclut l’indicateur NumberStyles.AllowThousands . |
. | 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 | Séquence du chiffre 0. Les chiffres fractionnaires peuvent apparaître dans s si style inclut l’indicateur NumberStyles.AllowDecimalPoint . Si un chiffre autre que 0 apparaît dans fractional_digits, la méthode lève un OverflowException. |
e | Caractère « e » ou « E », qui indique que s peut être représenté en notation exponentielle. Le s paramètre peut représenter un nombre en notation exponentielle si style inclut l’indicateur NumberStyles.AllowExponent . Toutefois, le s paramètre doit représenter un nombre dans la plage du type de Int16 données et ne peut pas avoir un composant fractionnaire autre que zéro. |
hexdigits | Séquence de chiffres hexadécimaux de 0 à f ou de 0 à F. |
Notes
Tous les caractères NUL (U+0000) de fin 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 uniquement (qui correspond au NumberStyles.None style) analyse toujours correctement. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être, mais qui ne sont pas obligatoirement 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 0 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 peut apparaître avant les chiffres. |
NumberStyles.AllowTrailingSign | Un signe peut apparaître après les chiffres. |
NumberStyles.AllowParentheses | Élément sign sous la forme de parenthèses englobant la valeur numérique. |
NumberStyles.AllowThousands | Élément , . |
NumberStyles.AllowCurrencySymbol | Élément $. |
Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, s
doit être la représentation sous forme de chaîne d’une valeur hexadécimale sans préfixe. Par exemple, « 9AF3 » analyse correctement, mais « 0x9AF3 » 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 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 NumberFormatInfo.CurrentInfo. Pour analyser à l’aide des s
informations de mise en forme d’une culture spécifique, appelez la Int16.Parse(String, NumberStyles, IFormatProvider) méthode .
Voir aussi
S’applique à
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour