Int16.Parse Metoda

Definice

Převede řetězcové vyjádření čísla na odpovídající 16bitové celé číslo se znaménkem.Converts the string representation of a number to its 16-bit signed integer equivalent.

Přetížení

Parse(String, NumberStyles, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na 16bitové celočíselné ekvivalenty se znaménkem.Converts the string representation of a number in a specified style and culture-specific format to its 16-bit signed integer equivalent.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede reprezentaci čísla v zadaném stylu a formátu specifického pro jazykovou verzi na 16bitové celé číslo se znaménkem.Converts the span representation of a number in a specified style and culture-specific format to its 16-bit signed integer equivalent.

Parse(String, NumberStyles)

Převede řetězcové vyjádření čísla v zadaném stylu na jeho 16bitové celé číslo se znaménkem.Converts the string representation of a number in a specified style to its 16-bit signed integer equivalent.

Parse(String)

Převede řetězcové vyjádření čísla na odpovídající 16bitové celé číslo se znaménkem.Converts the string representation of a number to its 16-bit signed integer equivalent.

Parse(String, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na 16bitové celé číslo se znaménkem.Converts the string representation of a number in a specified culture-specific format to its 16-bit signed integer equivalent.

Parse(String, NumberStyles, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na 16bitové celočíselné ekvivalenty se znaménkem.Converts the string representation of a number in a specified style and culture-specific format to its 16-bit signed integer equivalent.

public:
 static short Parse(System::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

Parametry

s
String

Řetězec obsahující číslo k převedení.A string containing a number to convert.

style
NumberStyles

Bitová kombinace hodnot výčtu, která určuje prvky stylu, které mohou být přítomny v s.A bitwise combination of enumeration values that indicates the style elements that can be present in s. Typická hodnota, která se má zadat, je Integer.A typical value to specify is Integer.

provider
IFormatProvider

IFormatProvider, která poskytuje informace o formátování specifické pro jazykovou verzi s.An IFormatProvider that supplies culture-specific formatting information about s.

Návraty

16bitové celé číslo se znaménkem odpovídá číslu zadanému v s.A 16-bit signed integer equivalent to the number specified in s.

Výjimky

s je null.s is null.

style není NumberStyles hodnota.style is not a NumberStyles value.

-nebo--or- style není kombinací hodnot AllowHexSpecifier a HexNumber.style is not a combination of AllowHexSpecifier and HexNumber values.

s není ve formátu, který je kompatibilní s style.s is not in a format compliant with style.

s představuje číslo menší než MinValue nebo větší než MaxValue.s represents a number less than MinValue or greater than MaxValue.

-nebo--or- s obsahuje nenulové zlomkové číslice.s includes non-zero fractional digits.

Příklady

V následujícím příkladu je použita řada style a provider parametrů k analýze řetězcové reprezentace Int16 hodnot.The following example uses a variety of style and provider parameters to parse the string representations of Int16 values.

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

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky nebo kladné znaménko), které jsou povoleny v parametru s pro úspěšné provedení operace analýzy.The style parameter defines the style elements (such as white space or the positive sign) that are allowed in the s parameter for the parse operation to succeed. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles.It must be a combination of bit flags from the NumberStyles enumeration. V závislosti na hodnotě style``s parametr může obsahovat následující prvky:Depending on the value of style, the s parameter may include the following elements:

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

Nebo, pokud style zahrnuje AllowHexSpecifier:Or, if style includes AllowHexSpecifier:

[ws]hexdigits[ws][ws]hexdigits[ws]

Prvky v hranatých závorkách ([a]) jsou volitelné.Elements in square brackets ([ and ]) are optional. Následující tabulka popisuje jednotlivé prvky.The following table describes each element.

PrvekElement PopisDescription
specifikacews Volitelné prázdné místo.Optional white space. Na začátku s se může zobrazit mezera, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite, nebo na konci s Pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.White space can appear at the beginning of s if style includes the NumberStyles.AllowLeadingWhite flag, or at the end of s if style includes the NumberStyles.AllowTrailingWhite flag.
$ Symbol měny pro konkrétní jazykovou verzi.A culture-specific currency symbol. Jeho pozice v řetězci je definována vlastností NumberFormatInfo.CurrencyPositivePattern a NumberFormatInfo.CurrencyNegativePattern aktuální jazykové verze.Its position in the string is defined by the NumberFormatInfo.CurrencyPositivePattern and NumberFormatInfo.CurrencyNegativePattern property of the current culture. Symbol měny aktuální jazykové verze se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.The current culture's currency symbol can appear in s if style includes the NumberStyles.AllowCurrencySymbol flag.
signsign Nepovinný znak.An optional sign. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se objevit na konci s Pokud style obsahuje příznak NumberStyles.AllowTrailingSign.The sign can appear at the beginning of s if style includes the NumberStyles.AllowLeadingSign flag, and it can appear at the end of s if style includes the NumberStyles.AllowTrailingSign flag. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.Parentheses can be used in s to indicate a negative value if style includes the NumberStyles.AllowParentheses flag.
znakdigits Řada číslic od 0 do 9.A sequence of digits from 0 through 9.
,, Symbol oddělovače tisíců, specifický pro jazykovou verzi.A culture-specific thousands separator symbol. Symbol oddělovače tisíců aktuální jazykové verze se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowThousands.The current culture's thousands separator symbol can appear in s if style includes the NumberStyles.AllowThousands flag.
.. Symbol desetinné čárky specifický pro jazykovou verzi.A culture-specific decimal point symbol. Symbol desetinné čárky aktuální jazykové verze se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint.The current culture's decimal point symbol can appear in s if style includes the NumberStyles.AllowDecimalPoint flag.
fractional_digitsfractional_digits Sekvence 0 číslice.A sequence of the 0 digit. Zlomkové číslice se můžou objevit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint.Fractional digits can appear in s if style includes the NumberStyles.AllowDecimalPoint flag. Je-li v fractional_digitsuvedena jiná číslice než 0, vyvolá metoda OverflowException.If any digit other than 0 appears in fractional_digits, the method throws an OverflowException.
cerebrálníe Znak "e" nebo "E", který označuje, že s lze reprezentovat v exponenciálním zápisu.The 'e' or 'E' character, which indicates that s can be represented in exponential notation. Parametr s může představovat číslo v exponenciální notaci, pokud style obsahuje příznak NumberStyles.AllowExponent.The s parameter can represent a number in exponential notation if style includes the NumberStyles.AllowExponent flag. Parametr s však musí představovat číslo v rozsahu datového typu Int16 a nemůže mít nenulovou zlomkovou komponentu.However, the s parameter must represent a number in the range of the Int16 data type and cannot have a non-zero fractional component.
hexdigitshexdigits Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.A sequence of hexadecimal digits from 0 through f, or 0 through F.

Poznámka

Všechny ukončující znaky NUL (U + 0000) ve s jsou ignorovány operací analýzy bez ohledu na hodnotu argumentu style.Any terminating NUL (U+0000) characters in s are ignored by the parsing operation, regardless of the value of the style argument.

Řetězec s pouze číslicemi (který odpovídá stylu NumberStyles.None) se vždy analyzuje úspěšně.A string with digits only (which corresponds to the NumberStyles.None style) always parses successfully. Většina zbývajících NumberStyles prvků ovládacího prvku, které mohou být, ale nemusí být přítomny v tomto vstupním řetězci.Most of the remaining NumberStyles members control elements that may be but are not required to be present in this input string. Následující tabulka uvádí, jak jednotlivé členy NumberStyles ovlivňují prvky, které mohou být přítomny v s.The following table indicates how individual NumberStyles members affect the elements that may be present in s.

Nesložené hodnoty NumberStylesNon-composite NumberStyles values Prvky, které jsou povoleny v s, kromě číslicElements permitted in s in addition to digits
NumberStyles.None Pouze desítkové číslice.Decimal digits only.
NumberStyles.AllowDecimalPoint Rozhraní .The . a fractional_digits prvky.and fractional_digits elements. Fractional_digits však musí obsahovat pouze jednu nebo více číslic 0 nebo je vyvolána OverflowException.However, fractional_digits must consist of only one or more 0 digits or an OverflowException is thrown.
NumberStyles.AllowExponent Parametr s může také používat exponenciální zápis.The s parameter can also use exponential notation.
NumberStyles.AllowLeadingWhite Element WS na začátku s.The ws element at the beginning of s.
NumberStyles.AllowTrailingWhite Element WS na konci s.The ws element at the end of s.
NumberStyles.AllowLeadingSign Znaménko se může objevit před číslicemi.A sign can appear before digits.
NumberStyles.AllowTrailingSign Za číslicemise může objevit znak.A sign can appear after digits.
NumberStyles.AllowParentheses Element Sign ve formě závorek, který obklopuje číselnou hodnotu.The sign element in the form of parentheses enclosing the numeric value.
NumberStyles.AllowThousands Element , .The , element.
NumberStyles.AllowCurrencySymbol Element $ .The $ element.

Pokud se používá příznak NumberStyles.AllowHexSpecifier, musí být s řetězcové vyjádření hexadecimální hodnoty bez předpony.If the NumberStyles.AllowHexSpecifier flag is used, s must be the string representation of a hexadecimal value without a prefix. Například "9AF3" se úspěšně analyzuje, ale "0x9AF3" ne.For example, "9AF3" parses successfully, but "0x9AF3" does not.. Jediné příznaky, které mohou být přítomny v style jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite.The only other flags that can be present in style are NumberStyles.AllowLeadingWhite and NumberStyles.AllowTrailingWhite. (NumberStyles výčet má složený styl čísla, NumberStyles.HexNumber, který obsahuje příznaky mezer.)(The NumberStyles enumeration has a composite number style, NumberStyles.HexNumber, that includes both white space flags.)

Parametr provider je IFormatProvider implementace, jejíž metoda GetFormat Získá objekt NumberFormatInfo.The provider parameter is an IFormatProvider implementation whose GetFormat method obtains a NumberFormatInfo object. Objekt NumberFormatInfo poskytuje informace specifické jazykové verze o formátu s.The NumberFormatInfo object provides culture-specific information about the format of s. Je-li provider null, je použit objekt NumberFormatInfo pro aktuální jazykovou verzi.If provider is null, the NumberFormatInfo object for the current culture is used.

Viz také

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede reprezentaci čísla v zadaném stylu a formátu specifického pro jazykovou verzi na 16bitové celé číslo se znaménkem.Converts the span representation of a number in a specified style and culture-specific format to its 16-bit signed integer equivalent.

public static short Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = null);
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 = null) As Short

Parametry

s
ReadOnlySpan<Char>

Rozsah obsahující znaky, které mají být převedeny.A span containing the characters representing the number to convert.

style
NumberStyles

Bitová kombinace hodnot výčtu, která určuje prvky stylu, které mohou být přítomny v s.A bitwise combination of enumeration values that indicates the style elements that can be present in s. Typická hodnota, která se má zadat, je Integer.A typical value to specify is Integer.

provider
IFormatProvider

IFormatProvider, která poskytuje informace o formátování specifické pro jazykovou verzi s.An IFormatProvider that supplies culture-specific formatting information about s.

Návraty

16bitové celé číslo se znaménkem odpovídá číslu zadanému v s.A 16-bit signed integer equivalent to the number specified in s.

Parse(String, NumberStyles)

Převede řetězcové vyjádření čísla v zadaném stylu na jeho 16bitové celé číslo se znaménkem.Converts the string representation of a number in a specified style to its 16-bit signed integer equivalent.

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

Parametry

s
String

Řetězec obsahující číslo k převedení.A string containing a number to convert.

style
NumberStyles

Bitová kombinace hodnot výčtu, která určuje prvky stylu, které mohou být přítomny v s.A bitwise combination of the enumeration values that indicates the style elements that can be present in s. Typická hodnota, která se má zadat, je Integer.A typical value to specify is Integer.

Návraty

16bitové celé číslo se znaménkem odpovídá číslu zadanému v s.A 16-bit signed integer equivalent to the number specified in s.

Výjimky

s je null.s is null.

style není NumberStyles hodnota.style is not a NumberStyles value.

-nebo--or- style není kombinací hodnot AllowHexSpecifier a HexNumber.style is not a combination of AllowHexSpecifier and HexNumber values.

s není ve formátu, který je kompatibilní s style.s is not in a format compliant with style.

s představuje číslo menší než MinValue nebo větší než MaxValue.s represents a number less than MinValue or greater than MaxValue.

-nebo--or- s obsahuje nenulové zlomkové číslice.s includes non-zero fractional digits.

Příklady

Následující příklad používá metodu Int16.Parse(String, NumberStyles) k analýze řetězcové reprezentace Int16 hodnot pomocí jazykové verze en-US.The following example uses the Int16.Parse(String, NumberStyles) method to parse the string representations of Int16 values using the en-US culture.

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

Poznámky

Parametr style definuje prvky stylu (například prázdný znak nebo symbol znaménka), které jsou povoleny v parametru s pro úspěšné provedení operace analýzy.The style parameter defines the style elements (such as white space or a sign symbol) that are allowed in the s parameter for the parse operation to succeed. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles.It must be a combination of bit flags from the NumberStyles enumeration. V závislosti na hodnotě style``s parametr může obsahovat následující prvky:Depending on the value of style, the s parameter may include the following elements:

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

Nebo, pokud style zahrnuje AllowHexSpecifier:Or, if style includes AllowHexSpecifier:

[ws]hexdigits[ws][ws]hexdigits[ws]

Položky v hranatých závorkách ([ a ]) jsou volitelné.Items in square brackets ([ and ]) are optional. Následující tabulka popisuje jednotlivé prvky.The following table describes each element.

PrvekElement PopisDescription
specifikacews Volitelné prázdné místo.Optional white space. Na začátku s se může zobrazit mezera, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite, nebo na konci s Pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.White space can appear at the beginning of s if style includes the NumberStyles.AllowLeadingWhite flag, or at the end of s if style includes the NumberStyles.AllowTrailingWhite flag.
$ Symbol měny pro konkrétní jazykovou verzi.A culture-specific currency symbol. Jeho pozice v řetězci je definována vlastností NumberFormatInfo.CurrencyPositivePattern a NumberFormatInfo.CurrencyNegativePattern aktuální jazykové verze.Its position in the string is defined by the NumberFormatInfo.CurrencyPositivePattern and NumberFormatInfo.CurrencyNegativePattern property of the current culture. Symbol měny aktuální jazykové verze se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.The current culture's currency symbol can appear in s if style includes the NumberStyles.AllowCurrencySymbol flag.
signsign Nepovinný znak.An optional sign. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se objevit na konci s Pokud style obsahuje příznak NumberStyles.AllowTrailingSign.The sign can appear at the beginning of s if style includes the NumberStyles.AllowLeadingSign flag, and it can appear at the end of s if style includes the NumberStyles.AllowTrailingSign flag. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.Parentheses can be used in s to indicate a negative value if style includes the NumberStyles.AllowParentheses flag.
znakdigits Řada číslic od 0 do 9.A sequence of digits from 0 through 9.
,, Symbol oddělovače tisíců, specifický pro jazykovou verzi.A culture-specific thousands separator symbol. Symbol oddělovače tisíců aktuální jazykové verze se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowThousands.The current culture's thousands separator symbol can appear in s if style includes the NumberStyles.AllowThousands flag.
.. Symbol desetinné čárky specifický pro jazykovou verzi.A culture-specific decimal point symbol. Symbol desetinné čárky aktuální jazykové verze se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint.The current culture's decimal point symbol can appear in s if style includes the NumberStyles.AllowDecimalPoint flag.
fractional_digitsfractional_digits Sekvence 0 číslice.A sequence of the 0 digit. Zlomkové číslice se můžou objevit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint.Fractional digits can appear in s if style includes the NumberStyles.AllowDecimalPoint flag. Je-li v fractional_digitsuvedena jiná číslice než 0, vyvolá metoda OverflowException.If any digit other than 0 appears in fractional_digits, the method throws an OverflowException.
cerebrálníe Znak "e" nebo "E", který označuje, že s lze reprezentovat v exponenciálním zápisu.The 'e' or 'E' character, which indicates that s can be represented in exponential notation. Parametr s může představovat číslo v exponenciální notaci, pokud style obsahuje příznak NumberStyles.AllowExponent.The s parameter can represent a number in exponential notation if style includes the NumberStyles.AllowExponent flag. Parametr s však musí představovat číslo v rozsahu datového typu Int16 a nemůže mít nenulovou zlomkovou komponentu.However, the s parameter must represent a number in the range of the Int16 data type and cannot have a non-zero fractional component.
hexdigitshexdigits Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.A sequence of hexadecimal digits from 0 through f, or 0 through F.

Poznámka

Všechny ukončující znaky NUL (U + 0000) ve s jsou ignorovány operací analýzy bez ohledu na hodnotu argumentu style.Any terminating NUL (U+0000) characters in s are ignored by the parsing operation, regardless of the value of the style argument.

Řetězec s pouze číslicemi (který odpovídá stylu NumberStyles.None) se vždy analyzuje úspěšně.A string with digits only (which corresponds to the NumberStyles.None style) always parses successfully. Většina zbývajících NumberStyles prvků ovládacího prvku, které mohou být, ale nemusí být přítomny v tomto vstupním řetězci.Most of the remaining NumberStyles members control elements that may be but are not required to be present in this input string. Následující tabulka uvádí, jak jednotlivé členy NumberStyles ovlivňují prvky, které mohou být přítomny v s.The following table indicates how individual NumberStyles members affect the elements that may be present in s.

Nesložené hodnoty NumberStylesNon-composite NumberStyles values Prvky, které jsou povoleny v s, kromě číslicElements permitted in s in addition to digits
NumberStyles.None Pouze desítkové číslice.Decimal digits only.
NumberStyles.AllowDecimalPoint Rozhraní .The . a fractional_digits prvky.and fractional_digits elements. Fractional_digits však musí obsahovat pouze jednu nebo více číslic 0 nebo je vyvolána OverflowException.However, fractional_digits must consist of only one or more 0 digits or an OverflowException is thrown.
NumberStyles.AllowExponent Parametr s může také používat exponenciální zápis.The s parameter can also use exponential notation.
NumberStyles.AllowLeadingWhite Element WS na začátku s.The ws element at the beginning of s.
NumberStyles.AllowTrailingWhite Element WS na konci s.The ws element at the end of s.
NumberStyles.AllowLeadingSign Znaménko se může objevit před číslicemi.A sign can appear before digits.
NumberStyles.AllowTrailingSign Za číslicemise může objevit znak.A sign can appear after digits.
NumberStyles.AllowParentheses Element Sign ve formě závorek, který obklopuje číselnou hodnotu.The sign element in the form of parentheses enclosing the numeric value.
NumberStyles.AllowThousands Element , .The , element.
NumberStyles.AllowCurrencySymbol Element $ .The $ element.

Pokud se používá příznak NumberStyles.AllowHexSpecifier, musí být s řetězcové vyjádření hexadecimální hodnoty bez předpony.If the NumberStyles.AllowHexSpecifier flag is used, s must be the string representation of a hexadecimal value without a prefix. Například "9AF3" se úspěšně analyzuje, ale "0x9AF3" ne.For example, "9AF3" parses successfully, but "0x9AF3" does not. Jediné příznaky, které mohou být přítomny v style jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite.The only other flags that can be present in style are NumberStyles.AllowLeadingWhite and NumberStyles.AllowTrailingWhite. (NumberStyles výčet má složený styl čísla, NumberStyles.HexNumber, který obsahuje příznaky mezer.)(The NumberStyles enumeration has a composite number style, NumberStyles.HexNumber, that includes both white space flags.)

Parametr s je analyzován pomocí informací o formátování v objektu NumberFormatInfo, který je inicializován pro aktuální jazykovou verzi systému.The s parameter is parsed using the formatting information in a NumberFormatInfo object that is initialized for the current system culture. Další informace najdete v tématu NumberFormatInfo.CurrentInfo.For more information, see NumberFormatInfo.CurrentInfo. Chcete-li analyzovat s pomocí informací o formátování konkrétní jazykové verze, zavolejte metodu Int16.Parse(String, NumberStyles, IFormatProvider).To parse s using the formatting information of a specific culture, call the Int16.Parse(String, NumberStyles, IFormatProvider) method.

Viz také

Parse(String)

Převede řetězcové vyjádření čísla na odpovídající 16bitové celé číslo se znaménkem.Converts the string representation of a number to its 16-bit signed integer equivalent.

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

Parametry

s
String

Řetězec obsahující číslo k převedení.A string containing a number to convert.

Návraty

16bitové celé číslo se znaménkem, které odpovídá číslu obsaženému v s.A 16-bit signed integer equivalent to the number contained in s.

Výjimky

s je null.s is null.

s nemá správný formát.s is not in the correct format.

s představuje číslo menší než MinValue nebo větší než MaxValue.s represents a number less than MinValue or greater than MaxValue.

Příklady

Následující příklad ukazuje, jak převést řetězcovou hodnotu na 16bitové celočíselnou hodnotu se znaménkem pomocí metody Int16.Parse(String).The following example demonstrates how to convert a string value into a 16-bit signed integer value using the Int16.Parse(String) method. Výsledná celočíselná hodnota se pak zobrazí v konzole.The resulting integer value is then displayed to the 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.      
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.      

Poznámky

Parametr s obsahuje číslo formuláře:The s parameter contains a number of the form:

[ws][sign]digits[ws][ws][sign]digits[ws]

Prvky v hranatých závorkách ([a]) jsou volitelné.Elements in square brackets ([ and ]) are optional. Následující tabulka popisuje jednotlivé prvky.The following table describes each element.

PrvekElement PopisDescription
specifikacews Volitelné prázdné místo.Optional white space.
signsign Nepovinný znak.An optional sign.
znakdigits Řada číslic od 0 do 9.A sequence of digits ranging from 0 to 9.

Parametr s je interpretován pomocí stylu NumberStyles.Integer.The s parameter is interpreted using the NumberStyles.Integer style. Kromě desetinných číslic hodnoty Integer jsou povoleny pouze úvodní a koncové mezery společně s počátečním znaménkem.In addition to the integer value's decimal digits, only leading and trailing spaces together with a leading sign are allowed. Chcete-li explicitně definovat prvky stylu, které mohou být k dispozici v s, použijte buď metodu Int16.Parse(String, NumberStyles) nebo Parse.To explicitly define the style elements that can be present in s, use either the Int16.Parse(String, NumberStyles) or the Parse method.

Parametr s je analyzován pomocí informací o formátování v objektu NumberFormatInfo, který je inicializován pro aktuální jazykovou verzi systému.The s parameter is parsed using the formatting information in a NumberFormatInfo object that is initialized for the current system culture. Další informace najdete v tématu CurrentInfo.For more information, see CurrentInfo. Chcete-li analyzovat řetězec pomocí informací o formátování některé jiné jazykové verze, použijte metodu Int16.Parse(String, IFormatProvider) nebo Int16.Parse(String, NumberStyles, IFormatProvider).To parse a string using the formatting information of some other culture, use the Int16.Parse(String, IFormatProvider) or the Int16.Parse(String, NumberStyles, IFormatProvider) method.

Viz také

Parse(String, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na 16bitové celé číslo se znaménkem.Converts the string representation of a number in a specified culture-specific format to its 16-bit signed integer equivalent.

public:
 static short Parse(System::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

Parametry

s
String

Řetězec obsahující číslo k převedení.A string containing a number to convert.

provider
IFormatProvider

IFormatProvider, která poskytuje informace o formátování specifické pro jazykovou verzi s.An IFormatProvider that supplies culture-specific formatting information about s.

Návraty

16bitové celé číslo se znaménkem odpovídá číslu zadanému v s.A 16-bit signed integer equivalent to the number specified in s.

Výjimky

s je null.s is null.

s nemá správný formát.s is not in the correct format.

s představuje číslo menší než MinValue nebo větší než MaxValue.s represents a number less than MinValue or greater than MaxValue.

Příklady

Následující příklad analyzuje řetězcové reprezentace Int16 hodnot pomocí metody Int16.Parse(String, IFormatProvider).The following example parses string representations of Int16 values with the Int16.Parse(String, IFormatProvider) method.

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

Poznámky

Parametr s obsahuje číslo formuláře:The s parameter contains a number of the form:

[ws][sign]digits[ws][ws][sign]digits[ws]

Prvky v hranatých závorkách ([a]) jsou volitelné.Elements in square brackets ([ and ]) are optional. Následující tabulka popisuje jednotlivé prvky.The following table describes each element.

PrvekElement PopisDescription
wsws Volitelný prázdný znak.An optional white space.
znaksign Nepovinný znak.An optional sign.
číslicedigits Řada číslic od 0 do 9.A sequence of digits ranging from 0 to 9.

Parametr s je interpretován pomocí stylu NumberStyles.Integer.The s parameter is interpreted using the NumberStyles.Integer style. Kromě desítkových číslic jsou v spovoleny pouze úvodní a koncové mezery s počátečním znaménkem.In addition to decimal digits, only leading and trailing spaces together with a leading sign are allowed in s. Chcete-li explicitně definovat prvky stylu společně s informacemi o formátování specifické jazykové verze, které mohou být k dispozici v s, použijte metodu Int16.Parse(String, NumberStyles, IFormatProvider).To explicitly define the style elements together with the culture-specific formatting information that can be present in s, use the Int16.Parse(String, NumberStyles, IFormatProvider) method.

Parametr provider je implementace IFormatProvider, která získá objekt NumberFormatInfo.The provider parameter is an IFormatProvider implementation that obtains a NumberFormatInfo object. NumberFormatInfo poskytuje informace specifické pro jazykovou verzi o formátu s.The NumberFormatInfo provides culture-specific information about the format of s. Je-li provider null, je použita NumberFormatInfo pro aktuální jazykovou verzi.If provider is null, the NumberFormatInfo for the current culture is used.

Viz také

Platí pro