Int32.Parse Metoda

  • Reference

Definice

Obor názvů:
System
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Převede řetězcové vyjádření čísla na jeho 32bitové celé číslo se znaky.

Přetížení

Parse(String)

Převede řetězcové vyjádření čísla na jeho 32bitové celé číslo se znaky.
Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Parsuje rozsah znaků do hodnoty.
Parse(String, NumberStyles)

Převede řetězcovou reprezentaci čísla v zadaném stylu na 32bitový ekvivalent celého čísla se znaky.
Parse(String, IFormatProvider)

Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 32bitový ekvivalent celého čísla se znaky.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent.
Parse(String, NumberStyles, IFormatProvider)

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na 32bitové celé číslo se znaky.

Parse(String)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede řetězcové vyjádření čísla na jeho 32bitové celé číslo se znaky.

public:
 static int Parse(System::String ^ s);
public static int Parse (string s);
static member Parse : string -> int
Public Shared Function Parse (s As String) As Integer

Parametry

s
String

Řetězec obsahující číslo, které chcete převést.

Návraty

Int32

32bitové celé číslo se signedm odpovídající číslu obsaženému v s.

Výjimky

ArgumentNullException

s je null.

FormatException

s není ve správném formátu.

OverflowException

s představuje číslo menší než Int32.MinValue nebo větší než Int32.MaxValue.

Příklady

Následující příklad ukazuje, jak pomocí metody Int32.Parse(String) převést řetězcovou hodnotu na 32bitovou celočíselnou hodnotu se znaky signed. Výsledná celočíselná hodnota se pak zobrazí v konzole.

using namespace System;

void main()
{
   array<String^>^ values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                              "0xFA1B", "163042", "-10", "007", "2147483647", 
                              "2147483648", "16e07", "134985.0", "-12034",
                              "-2147483648", "-2147483649" };
   for each (String^ value in values)
   {
      try {
         Int32 number = Int32::Parse(value); 
         Console::WriteLine("{0} --> {1}", value, number);
      }
      catch (FormatException^ e) {
         Console::WriteLine("{0}: Bad Format", value);
      }   
      catch (OverflowException^ e) {
         Console::WriteLine("{0}: Overflow", value);   
      }  
   }
}
// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                          "0xFA1B", "163042", "-10", "007", "2147483647",
                          "2147483648", "16e07", "134985.0", "-12034",
                          "-2147483648", "-2147483649" };
      foreach (string value in values)
      {
         try {
            int number = Int32.Parse(value);
            Console.WriteLine("{0} --> {1}", value, number);
         }
         catch (FormatException) {
            Console.WriteLine("{0}: Bad Format", value);
         }
         catch (OverflowException) {
            Console.WriteLine("{0}: Overflow", value);
         }
      }
   }
}
// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow

open System

let values =
    [ "+13230"; "-0"; "1,390,146"; "$190,235,421,127"
      "0xFA1B"; "163042"; "-10"; "007"; "2147483647"
      "2147483648"; "16e07"; "134985.0"; "-12034"
      "-2147483648"; "-2147483649" ]

for value in values do
    try
        let number = Int32.Parse value
        printfn $"{value} --> {number}"
    with 
    | :? FormatException ->
        printfn $"{value}: Bad Format"
    | :? OverflowException ->
        printfn $"{value}: Overflow"
    

// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow

Module Example
   Public Sub Main()
      Dim values() As String = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                                 "0xFA1B", "163042", "-10", "007", "2147483647", 
                                 "2147483648", "16e07", "134985.0", "-12034",
                                 "-2147483648", "-2147483649"  }
      For Each value As String In values
         Try
            Dim number As Integer = Int32.Parse(value) 
            Console.WriteLine("{0} --> {1}", value, number)
         Catch e As FormatException
            Console.WriteLine("{0}: Bad Format", value)
         Catch e As OverflowException
            Console.WriteLine("{0}: Overflow", value)   
         End Try  
      Next
   End Sub
End Module
' The example displays the following output:
'       +13230 --> 13230
'       -0 --> 0
'       1,390,146: Bad Format
'       $190,235,421,127: Bad Format
'       0xFA1B: Bad Format
'       163042 --> 163042
'       -10 --> -10
'       007 --> 7
'       2147483647 --> 2147483647
'       2147483648: Overflow
'       16e07: Bad Format
'       134985.0: Bad Format
'       -12034 --> -12034
'       -2147483648 --> -2147483648
'       -2147483649: Overflow

Poznámky

Parametr s obsahuje číslo formuláře:

[ws] [sign]digits[ws]

Položky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element Popis
Ws Volitelné prázdné znaky.
podepsat Volitelné znaménko.
číslice Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí stylu NumberStyles.Integer. Kromě desetinných číslic jsou povoleny pouze úvodní a koncové mezery spolu s počátečním znakem. Chcete-li explicitně definovat prvky stylu, které mohou být přítomny v s, použijte Int32.Parse(String, NumberStyles) nebo Int32.Parse(String, NumberStyles, IFormatProvider) metoda.

Parametr s se parsuje pomocí informací o formátování v objektu NumberFormatInfo inicializovaném pro aktuální jazykovou verzi systému. Další informace najdete v tématu CurrentInfo. K analýze řetězce pomocí informací o formátování některé jiné jazykové verze použijte metodu Int32.Parse(String, NumberStyles, IFormatProvider).

Viz také

Platí pro

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Zdroj:
Int32.cs
Zdroj:
Int32.cs

Parsuje rozsah znaků UTF-8 do hodnoty.

public:
 static int Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<int>::Parse;
public static int Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> int
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Integer

Parametry

utf8Text
ReadOnlySpan<Byte>

Rozsah znaků UTF-8 pro analýzu.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o utf8Text.

Návraty

Int32

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Platí pro

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Parsuje rozsah znaků do hodnoty.

public:
 static int Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<int>::Parse;
public static int Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> int
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Integer

Parametry

s
ReadOnlySpan<Char>

Rozsah znaků, které se mají analyzovat.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o s.

Návraty

Int32

Výsledek analýzy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Platí pro

Parse(String, NumberStyles)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu na 32bitový ekvivalent celého čísla se znaky.

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style);
public static int Parse (string s, System.Globalization.NumberStyles style);
static member Parse : string * System.Globalization.NumberStyles -> int
Public Shared Function Parse (s As String, style As NumberStyles) As Integer

Parametry

s
String

Řetězec obsahující číslo, které chcete převést.

style
NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Integer.

Návraty

Int32

32bitové celé číslo se signedm odpovídající číslu zadanému v s.

Výjimky

ArgumentNullException

s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací hodnot AllowHexSpecifier a HexNumber.

FormatException

s není ve formátu kompatibilním s style.

OverflowException

s představuje číslo menší než Int32.MinValue nebo větší než Int32.MaxValue.

-nebo-

s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad používá metodu Int32.Parse(String, NumberStyles) k analýze řetězcových reprezentací několika Int32 hodnot. Aktuální jazyková verze pro příklad je en-US.

using namespace System;
using namespace System::Globalization;

public ref class ParseInt32
{
public:
   static void Main()
   {
      Convert("104.0", NumberStyles::AllowDecimalPoint);
      Convert("104.9", NumberStyles::AllowDecimalPoint);
      Convert(" $17,198,064.42", NumberStyles::AllowCurrencySymbol |
                                 NumberStyles::Number);
      Convert("103E06", NumberStyles::AllowExponent);
      Convert("-1,345,791", NumberStyles::AllowThousands);
      Convert("(1,345,791)", NumberStyles::AllowThousands |
                             NumberStyles::AllowParentheses);
   }

private:
   static void Convert(String^ value, NumberStyles style)
   {
      try
      {
         int number = Int32::Parse(value, style);
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException^)
      {
         Console::WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException^)
      {
         Console::WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
};

int main()
{
    ParseInt32::Main();
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.

using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("104.0", NumberStyles.AllowDecimalPoint);
      Convert("104.9", NumberStyles.AllowDecimalPoint);
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol |
                                 NumberStyles.Number);
      Convert("103E06", NumberStyles.AllowExponent);
      Convert("-1,345,791", NumberStyles.AllowThousands);
      Convert("(1,345,791)", NumberStyles.AllowThousands |
                             NumberStyles.AllowParentheses);
   }

   private static void Convert(string value, NumberStyles style)
   {
      try
      {
         int number = Int32.Parse(value, style);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.

open System
open System.Globalization

let convert value (style: NumberStyles) =
    try
        let number = Int32.Parse(value, style)
        printfn $"Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int32 type."

convert "104.0" NumberStyles.AllowDecimalPoint
convert "104.9" NumberStyles.AllowDecimalPoint
convert " $17,198,064.42" (NumberStyles.AllowCurrencySymbol ||| NumberStyles.Number)
convert "103E06" NumberStyles.AllowExponent
convert "-1,345,791" NumberStyles.AllowThousands
convert "(1,345,791)" (NumberStyles.AllowThousands ||| NumberStyles.AllowParentheses)


// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.

Imports System.Globalization

Module ParseInt32
   Public Sub Main()
      Convert("104.0", NumberStyles.AllowDecimalPoint)    
      Convert("104.9", NumberStyles.AllowDecimalPoint)
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol Or _
                                 NumberStyles.Number)
      Convert("103E06", NumberStyles.AllowExponent)  
      Convert("-1,345,791", NumberStyles.AllowThousands)
      Convert("(1,345,791)", NumberStyles.AllowThousands Or _
                             NumberStyles.AllowParentheses)
   End Sub
   
   Private Sub Convert(value As String, style As NumberStyles)
      Try
         Dim number As Integer = Int32.Parse(value, style)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value)   
      End Try
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '104.0' to 104.
'       '104.9' is out of range of the Int32 type.
'       ' $17,198,064.42' is out of range of the Int32 type.
'       Converted '103E06' to 103000000.
'       Unable to convert '-1,345,791'.
'       Converted '(1,345,791)' to -1345791.

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky, symbol kladného nebo záporného znaménka nebo symbol oddělovače tisíců), které jsou povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu. V závislosti na hodnotě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko] [digits,]digits[.fractional_digits][e[sign]exponential_digits][ws]

Pokud style zahrnuje AllowHexSpecifier:

[ws]hexdigits[ws]

Položky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element Popis
ws Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.
$ Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern vlastnosti aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko Volitelné znaménko. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.
číslice

fractional_digits

exponential_digits		 Posloupnost číslic od 0 do 9. Pro fractional_digitsje platná pouze číslice 0.
, Symbol oddělovače tisíců specifických pro jazykovou verzi. Oddělovač tisíců aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowThousands.
. Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint. Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; pokud fractional_digits obsahuje jakoukoli jinou číslici, vyvolá se OverflowException.
e Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

Všechny ukončující NUL (U+0000) znaky v s jsou ignorovány operací analýzy bez ohledu na hodnotu argumentu style.

Řetězec pouze s číslicemi (který odpovídá stylu NumberStyles.None) vždy parsuje úspěch, pokud je v rozsahu typu Int32. Většina zbývajících NumberStyles členů ovládací prvky, které mohou být, ale nemusí být přítomny ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v s.

Hodnota NumberStyles Prvky povolené v s kromě číslic
None Pouze číslice prvek.
AllowDecimalPoint Desetinná čárka ( . ) a desetinné číslice prvky.
AllowExponent Parametr s může také použít exponenciální zápis.
AllowLeadingWhite Prvek ws na začátku s.
AllowTrailingWhite Prvek ws na konci s.
AllowLeadingSign Znak prvek na začátku s.
AllowTrailingSign Znak prvek na konci s.
AllowParentheses Znak prvek ve formě závorek ohraničující číselnou hodnotu.
AllowThousands Oddělovač tisíců ( , ) – element.
AllowCurrencySymbol Prvek $.
Currency Všichni. Parametr s nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float Prvek ws na začátku nebo konci s, znaménko na začátku sa symbol desetinné čárky (. ). Parametr s může také použít exponenciální zápis.
Number Prvky ws, sign, oddělovač tisíců ( , ) a desetinná čárka (. ).
Any Všechny styly s výjimkou s nemohou představovat šestnáctkové číslo.

Pokud se použije příznak NumberStyles.AllowHexSpecifier, s musí být šestnáctková hodnota bez předpony. Například "C9AF3" se úspěšně parsuje, ale "0xC9AF3" ne. Jedinými dalšími příznaky, které lze kombinovat s parametrem s, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles zahrnuje složený styl čísla, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

Parametr s se analyzuje pomocí informací o formátování v objektu NumberFormatInfo inicializovaném pro aktuální jazykovou verzi systému. Chcete-li určit jazykovou verzi, jejíž informace formátování se používají pro operaci analýzy, zavolejte Int32.Parse(String, NumberStyles, IFormatProvider) přetížení.

Viz také

Platí pro

Parse(String, IFormatProvider)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 32bitový ekvivalent celého čísla se znaky.

public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<int>::Parse;
public static int Parse (string s, IFormatProvider provider);
public static int Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> int
Public Shared Function Parse (s As String, provider As IFormatProvider) As Integer

Parametry

s
String

Řetězec obsahující číslo, které chcete převést.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o s.

Návraty

Int32

32bitové celé číslo se signedm odpovídající číslu zadanému v s.

Implementuje

Parse(String, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

FormatException

s není správný formát.

OverflowException

s představuje číslo menší než Int32.MinValue nebo větší než Int32.MaxValue.

Příklady

Následující příklad je obslužná rutina události kliknutí na tlačítko webového formuláře. Používá pole vrácené vlastností HttpRequest.UserLanguages k určení národního prostředí uživatele. Potom vytvoří instanci CultureInfo objektu, který odpovídá danému národnímu prostředí. Objekt NumberFormatInfo, který patří do daného CultureInfo objektu, se pak předá metodě Parse(String, IFormatProvider), která převede vstup uživatele na hodnotu Int32.

protected void OkToInteger_Click(object sender, EventArgs e)
{
    string locale;
    int number;
    CultureInfo culture;

    // Return if string is empty
    if (String.IsNullOrEmpty(this.inputNumber.Text))
        return;

    // Get locale of web request to determine possible format of number
    if (Request.UserLanguages.Length == 0)
        return;
    locale = Request.UserLanguages[0];
    if (String.IsNullOrEmpty(locale))
        return;

    // Instantiate CultureInfo object for the user's locale
    culture = new CultureInfo(locale);

    // Convert user input from a string to a number
    try
    {
        number = Int32.Parse(this.inputNumber.Text, culture.NumberFormat);
    }
    catch (FormatException)
    {
        return;
    }
    catch (Exception)
    {
        return;
    }
    // Output number to label on web form
    this.outputNumber.Text = "Number is " + number.ToString();
}

Protected Sub OkToInteger_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToInteger.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Integer

   ' Return if string is empty
   If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub

   ' Get locale of web request to determine possible format of number
   If Request.UserLanguages.Length = 0 Then Exit Sub
   locale = Request.UserLanguages(0)
   If String.IsNullOrEmpty(locale) Then Exit Sub

   ' Instantiate CultureInfo object for the user's locale
   culture = New CultureInfo(locale)

   ' Convert user input from a string to a number
   Try
      number = Int32.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As Exception
      Exit Sub
   End Try

   ' Output number to label on web form
   Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

Poznámky

Toto přetížení Parse(String, IFormatProvider) metody se obvykle používá k převodu textu, který lze formátovat různými způsoby na hodnotu Int32. Dá se například použít k převodu textu zadaného uživatelem do textového pole HTML na číselnou hodnotu.

Parametr s obsahuje číslo formuláře:

[ws] [sign]digits[ws]

Položky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element Popis
ws Volitelné prázdné znaky.
znaménko Volitelné znaménko.
číslice Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí stylu NumberStyles.Integer. Kromě desetinných číslic jsou povoleny pouze úvodní a koncové mezery spolu s počátečním znakem. Chcete-li explicitně definovat prvky stylu, které mohou být přítomny v s, použijte Int32.Parse(String, NumberStyles, IFormatProvider) metoda.

Parametr provider je IFormatProvider implementace, například NumberFormatInfo nebo objekt CultureInfo. Parametr provider poskytuje informace specifické pro jazykovou verzi o formátu s. Pokud je providernull, použije se objekt NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

Platí pro

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Zdroj:
Int32.cs
Zdroj:
Int32.cs

Parsuje rozsah znaků UTF-8 do hodnoty.

public static int Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Integer

Parametry

utf8Text
ReadOnlySpan<Byte>

Rozsah znaků UTF-8 pro analýzu.

style
NumberStyles

Bitové kombinace stylů čísel, které mohou být přítomny v utf8Text.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o utf8Text.

Návraty

Int32

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Platí pro

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent.

public static int Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
public static int Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Integer

Parametry

s
ReadOnlySpan<Char>

Rozsah obsahující znaky představující číslo, které se má převést.

style
NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Integer.

provider
IFormatProvider

Objekt, který poskytuje informace specifické pro jazykovou verzi o formátu s.

Návraty

Int32

32bitové celé číslo se signedm odpovídající číslu zadanému v s.

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Platí pro

Parse(String, NumberStyles, IFormatProvider)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na 32bitové celé číslo se znaky.

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<int>::Parse;
public static int Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static int Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Integer

Parametry

s
String

Řetězec obsahující číslo, které chcete převést.

style
NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Integer.

provider
IFormatProvider

Objekt, který poskytuje informace specifické pro jazykovou verzi o formátu s.

Návraty

Int32

32bitové celé číslo se signedm odpovídající číslu zadanému v s.

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací hodnot AllowHexSpecifier a HexNumber.

FormatException

s není ve formátu kompatibilním s style.

OverflowException

s představuje číslo menší než Int32.MinValue nebo větší než Int32.MaxValue.

-nebo-

s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad používá k analýze řetězcových reprezentací hodnot Int32 různé parametry style a provider. Ukazuje také některé z různých způsobů, jak lze stejný řetězec interpretovat v závislosti na jazykové verzi, jejíž informace o formátování se používají pro operaci analýzy.

using namespace System;
using namespace System::Globalization;

public ref class ParseInt32
{
public:
   static void Main()
   {
      Convert("12,000", NumberStyles::Float | NumberStyles::AllowThousands, 
              gcnew CultureInfo("en-GB"));
      Convert("12,000", NumberStyles::Float | NumberStyles::AllowThousands,
              gcnew CultureInfo("fr-FR"));
      Convert("12,000", NumberStyles::Float, gcnew CultureInfo("en-US"));

      Convert("12 425,00", NumberStyles::Float | NumberStyles::AllowThousands,
              gcnew CultureInfo("sv-SE"));
      Convert("12,425.00", NumberStyles::Float | NumberStyles::AllowThousands,
              NumberFormatInfo::InvariantInfo);
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowDecimalPoint, 
              gcnew CultureInfo("fr-FR"));
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowDecimalPoint,
              gcnew CultureInfo("en-US"));
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowThousands,
              gcnew CultureInfo("en-US"));
   }

private:
   static void Convert(String^ value, NumberStyles style,
                               IFormatProvider^ provider)
   {
      try
      {
         int number = Int32::Parse(value, style, provider);
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException^)
      {
         Console::WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException^)
      {
         Console::WriteLine("'{0}' is out of range of the Int32 type.", value);   
      }
   }                               
};

int main()
{
    ParseInt32::Main();
}
// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("en-GB"));
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("fr-FR"));
      Convert("12,000", NumberStyles.Float, new CultureInfo("en-US"));

      Convert("12 425,00", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("sv-SE"));
      Convert("12,425.00", NumberStyles.Float | NumberStyles.AllowThousands,
              NumberFormatInfo.InvariantInfo);
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("fr-FR"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("en-US"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowThousands,
              new CultureInfo("en-US"));
   }

   private static void Convert(string value, NumberStyles style,
                               IFormatProvider provider)
   {
      try
      {
         int number = Int32.Parse(value, style, provider);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
}
// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

open System
open System.Globalization

let convert (value: string) (style: NumberStyles) (provider: IFormatProvider) =
    try
        let number = Int32.Parse(value, style, provider)
        printfn $"Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int32 type."

convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "en-GB")
convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "fr-FR")
convert "12,000" NumberStyles.Float (CultureInfo "en-US")
convert "12 425,00" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "sv-SE")
convert "12,425.00" (NumberStyles.Float ||| NumberStyles.AllowThousands) NumberFormatInfo.InvariantInfo
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "fr-FR")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "en-US")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowThousands) (CultureInfo "en-US")

// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

Imports System.Globalization

Module ParseInt32
   Public Sub Main()
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("en-GB"))      
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("fr-FR"))
      Convert("12,000", NumberStyles.Float, New CultureInfo("en-US"))
      
      Convert("12 425,00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("sv-SE")) 
      Convert("12,425.00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              NumberFormatInfo.InvariantInfo) 
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _ 
              New CultureInfo("fr-FR"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _
              New CultureInfo("en-US"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowThousands, _
              New CultureInfo("en-US"))
   End Sub

   Private Sub Convert(value As String, style As NumberStyles, _
                       provider As IFormatProvider)
      Try
         Dim number As Integer = Int32.Parse(value, style, provider)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value)   
      End Try
   End Sub                       
End Module
' This example displays the following output to the console:
'       Converted '12,000' to 12000.
'       Converted '12,000' to 12.
'       Unable to convert '12,000'.
'       Converted '12 425,00' to 12425.
'       Converted '12,425.00' to 12425.
'       '631,900' is out of range of the Int32 type.
'       Unable to convert '631,900'.
'       Converted '631,900' to 631900.

Poznámky

Parametr style definuje prvky stylu (například prázdné znaménko nebo kladné znaménko), které jsou povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu. V závislosti na hodnotě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko] [digits,]digits[.fractional_digist][e[sign]exponential_digits][ws]

Pokud style zahrnuje AllowHexSpecifier:

[ws]hexdigits[ws]

Položky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element Popis
ws Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.
$ Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyPositivePattern vlastnost objektu NumberFormatInfo vrácenou GetFormat metodou parametru provider. Symbol měny se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko Volitelné znaménko. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign nebo na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.
číslice

fractional_digits

exponential_digits		 Posloupnost číslic od 0 do 9. Pro fractional_digitsje platná pouze číslice 0.
, Symbol oddělovače tisíců specifických pro jazykovou verzi. Oddělovač tisíců jazykové verze určené provider se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowThousands.
. Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky jazykové verze určené provider se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint.

Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; pokud fractional_digits obsahuje jakoukoli jinou číslici, vyvolá se OverflowException.
e Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

Všechny ukončující NUL (U+0000) znaky v s jsou ignorovány operací analýzy bez ohledu na hodnotu argumentu style.

Řetězec s desetinnými číslicemi (který odpovídá stylu NumberStyles.None) se vždy úspěšně parsuje, pokud je v rozsahu typu Int32. Většina zbývajících NumberStyles členů ovládací prvky, které mohou být, ale nemusí být přítomny v tomto vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v s.

Neseparované hodnoty NumberStyles Prvky povolené v s kromě číslic
NumberStyles.None Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint Desetinná čárka ( . ) a desetinné číslice prvky. desetinné číslice však musí obsahovat pouze jednu nebo více 0 číslic nebo je vyvolán OverflowException.
NumberStyles.AllowExponent Parametr s může také použít exponenciální zápis. Pokud s představuje číslo v exponenciálním zápisu, musí představovat celé číslo v rozsahu Int32 datového typu bez nenulové desetinné komponenty.
NumberStyles.AllowLeadingWhite Prvek ws na začátku s.
NumberStyles.AllowTrailingWhite Prvek ws na konci s.
NumberStyles.AllowLeadingSign Kladné znaménko může být zobrazeno před číslice.
NumberStyles.AllowTrailingSign Po číslicíchse může zobrazit kladné znaménko .
NumberStyles.AllowParentheses Znak prvek ve formě závorek ohraničující číselnou hodnotu.
NumberStyles.AllowThousands Oddělovač tisíců ( , ) – element.
NumberStyles.AllowCurrencySymbol Prvek $.

Pokud se použije příznak NumberStyles.AllowHexSpecifier, s musí být šestnáctková hodnota bez předpony. Například "C9AF3" se úspěšně parsuje, ale "0xC9AF3" ne. Jedinými dalšími příznaky, které mohou být přítomné v style, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles má složený styl čísla, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

Parametr provider je IFormatProvider implementace, například NumberFormatInfo nebo objekt CultureInfo. Parametr provider poskytuje informace specifické pro jazykovou verzi používané při analýze. Pokud je providernull, použije se objekt NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

Platí pro