Int32.Parse Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 32bitového celého čísla se znaménkem.

Přetížení

Parse(String, NumberStyles, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent se znaky.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent se signýmým kódem.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků UTF-8 na hodnotu.
Parse(String, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent se znaky.
Parse(String)	Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 32bitového celého čísla se znaménkem.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků na hodnotu.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 na hodnotu.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 32bitový celočíselný ekvivalent se znaky.

Parse(String, NumberStyles, IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent 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 k převedení.

style: NumberStyles

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

provider: IFormatProvider

Objekt, který poskytuje informace specifické pro jazykovou verzi sformátu .

Návraty

Int32

32bitové celé číslo se signoum adresou, které odpovídá číslu zadanému v ssouboru .

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier hodnot 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á různé style parametry a provider k analýze řetězcových Int32 reprezentací hodnot. 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 parsování.

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é znaky nebo kladné znaménko), které jsou povoleny v parametru s pro úspěšnou operaci analýzy. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . V závislosti na hodnotě styles může parametr obsahovat následující prvky:

[ws] [$] [sign] [digits,]digits[.fractional_digist][e[sign]exponential_digits][ws]

Nebo, pokud style obsahuje 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é místo. Prázdné místo se může zobrazit na začátku, `s` pokud `style` obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci, `s` pokud `style` obsahuje NumberStyles.AllowTrailingWhite příznak.
$	Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyPositivePattern vlastností objektu NumberFormatInfo vrácenou metodou GetFormat parametru `provider` . Symbol měny se může zobrazit v `s` , pokud `style` obsahuje NumberStyles.AllowCurrencySymbol příznak.
sign	Nepovinný znak. Znaménko se může zobrazit na začátku, `s` pokud `style` obsahuje NumberStyles.AllowLeadingSign příznak, nebo na konci, `s` pokud `style` obsahuje NumberStyles.AllowTrailingSign příznak. Závorky lze v `s` použít k označení záporné hodnoty, pokud `style` obsahuje NumberStyles.AllowParentheses příznak.
Číslic Fractional_digits exponential_digits	Řada číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
,	Symbol oddělovače tisíců, specifický pro jazykovou verzi. Oddělovač tisíců jazykové verze zadané nástrojem `provider` se může zobrazit v `s` , pokud `style` obsahuje NumberStyles.AllowThousands příznak.
.	Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky jazykové verze zadané nástrojem `provider` se může zobrazit v `s` případě, že `style` obsahuje NumberStyles.AllowDecimalPoint příznak. Pouze číslice 0 se může zobrazit jako desetinná číslice, aby operace analýzy byla úspěšná; Pokud fractional_digits obsahuje jakoukoli jinou číslici, vyvolá se znak OverflowException .
E	Znak "e" nebo "E", který označuje, že hodnota je vyjádřena v exponenciální notaci. Parametr `s` může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud `style` obsahuje příznak.
šestihranné	Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.

Poznámka

Operace analýzy ignoruje všechny ukončující ZNAKY NUL (U+0000) bez s ohledu na hodnotu argumentu style .

Řetězec pouze s desetinnými číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně analyzuje, pokud je v rozsahu Int32 typu. Většina zbývajících NumberStyles členů řídí prvky, které mohou být, ale nejsou nutné, aby byly 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 nástroji s.

Nesložené hodnoty NumberStyles	Prvky, které jsou povoleny v s, kromě číslic
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Desetinná čárka ( . ) a desetinné číslice prvky. Desetinné číslice se však musí skládat pouze z jedné nebo více číslic 0 nebo OverflowException je vyvolán.
NumberStyles.AllowExponent	Parametr `s` může také použít exponenciální notaci. Pokud `s` představuje číslo v exponenciálním zápisu, musí představovat celé číslo v rozsahu datového Int32 typu bez nenulové zlomkové komponenty.
NumberStyles.AllowLeadingWhite	Element ws na začátku souboru `s`.
NumberStyles.AllowTrailingWhite	Element ws na konci souboru `s`.
NumberStyles.AllowLeadingSign	Před číslicemi se může zobrazit kladné znaménko.
NumberStyles.AllowTrailingSign	Za číslicemi se může zobrazit kladné znaménko.
NumberStyles.AllowParentheses	Element sign ve formě závorek ohraničující číselnou hodnotu.
NumberStyles.AllowThousands	Element oddělovače tisíců ( , )
NumberStyles.AllowCurrencySymbol	Element $ .

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

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

Viz také

Platí pro

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný 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, která se má zadat, je Integer.

provider: IFormatProvider

Objekt, který poskytuje informace specifické pro jazykovou verzi sformátu .

Návraty

Int32

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

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Platí pro

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Parsuje rozsah znaků UTF-8 na hodnotu.

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, které se mají analyzovat.

style: NumberStyles

Bitové kombinace stylů čísel, které se můžou vyskytovat v nástroji utf8Text.

provider: IFormatProvider

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

Návraty

Int32

Výsledek analýzy utf8Text

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Platí pro

Parse(String, IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

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

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 k převedení.

provider: IFormatProvider

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

Návraty

Int32

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

Implementuje

Parse(String, IFormatProvider)

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

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

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 Int32 hodnotu. Například jej lze 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é místo.
sign	Nepovinný znak.
Číslic	Řada číslic od 0 do 9.

Parametr se s interpretuje pomocí NumberStyles.Integer stylu . Kromě desítkových číslic jsou povoleny pouze úvodní a koncové mezery s počátečním znaménkem. Pokud chcete explicitně definovat prvky stylu, které mohou být přítomny v s, použijte metodu Int32.Parse(String, NumberStyles, IFormatProvider) .

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

Viz také

Platí pro

Parse(String)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 32bitového celého čísla se znaménkem.

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 k převedení.

Návraty

Int32

32bitové celé číslo se signoumhom parametrem 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 převést řetězcovou hodnotu na 32bitovou celočíselnou hodnotu se sadou se sadou znaků pomocí Int32.Parse(String) metody . Výsledná celočíselná hodnota se pak zobrazí v konzole nástroje .

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é místo.
znak	Nepovinný znak.
číslice	Řada číslic od 0 do 9.

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

Parametr s je analyzován pomocí informací o formátování v objektu NumberFormatInfo inicializovaném pro aktuální jazykovou verzi systému. Další informace naleznete v tématu CurrentInfo. Pokud chcete analyzovat řetězec pomocí informací o formátování nějaké jiné jazykové verze, použijte metodu Int32.Parse(String, NumberStyles, IFormatProvider) .

Viz také

Platí pro

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Parsuje rozsah znaků na hodnotu.

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

Návraty

Int32

Výsledek analýzy s

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Platí pro

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Parsuje rozsah znaků UTF-8 na hodnotu.

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, které se mají analyzovat.

provider: IFormatProvider

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

Návraty

Int32

Výsledek analýzy utf8Text

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Platí pro

Parse(String, NumberStyles)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 32bitový celočíselný ekvivalent 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 k převedení.

style: NumberStyles

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

Návraty

Int32

32bitové celé číslo se signoum adresou, které odpovídá číslu zadanému v ssouboru .

Výjimky

ArgumentNullException

s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier hodnot 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 zahrnuje 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 daný 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 v parametru s povolené pro úspěšnou operaci analýzy. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . V závislosti na hodnotě styles může parametr obsahovat následující prvky:

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

Nebo pokud style obsahuje 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é místo. Prázdné místo se může zobrazit na začátku, `s` pokud `style` obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci, `s` pokud `style` obsahuje NumberStyles.AllowTrailingWhite příznak.
$	Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v `s` , pokud `style` obsahuje NumberStyles.AllowCurrencySymbol příznak.
sign	Nepovinný znak. Znaménko se může zobrazit na začátku, pokud příznak obsahujeNumberStyles.AllowLeadingSign, a může se zobrazit na konci, `s` pokud `style` příznak obsahujeNumberStyles.AllowTrailingSign.`styles` Závorky lze v `s` použít k označení záporné hodnoty, pokud `style` obsahuje NumberStyles.AllowParentheses příznak.
Číslic Fractional_digits exponential_digits	Řada číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
,	Symbol oddělovače tisíců, specifický pro jazykovou verzi. Oddělovač tisíců aktuální jazykové verze se může zobrazit v `s` , pokud `style` obsahuje NumberStyles.AllowThousands příznak.
.	Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v `s` , pokud `style` obsahuje NumberStyles.AllowDecimalPoint příznak. Pouze číslice 0 se může zobrazit jako desetinná číslice, aby operace analýzy byla úspěšná; Pokud fractional_digits obsahuje jakoukoli jinou číslici, vyvolá se znak OverflowException .
E	Znak "e" nebo "E", který označuje, že hodnota je vyjádřena v exponenciální notaci. Parametr `s` může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud `style` obsahuje příznak.
šestihranné	Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.

Poznámka

Operace analýzy ignoruje všechny ukončující ZNAKY NUL (U+0000) bez s ohledu na hodnotu argumentu style .

Řetězec pouze s číslicemi (který odpovídá NumberStyles.None stylu) vždy úspěšně analyzuje, pokud je v rozsahu Int32 typu. Většina zbývajících NumberStyles členů řídí prvky, které můžou 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 nástroji s.

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

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

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

Viz také

Platí pro

Int32.Parse Metoda

Definice

Přetížení

Parse(String, NumberStyles, IFormatProvider)

Parametry

Návraty

Implementuje

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parametry

Návraty

Implementuje

Platí pro

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parametry

Návraty

Implementuje

Platí pro

Parse(String, IFormatProvider)

Parametry

Návraty

Implementuje

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Parse(String)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parametry

Návraty

Implementuje

Platí pro

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parametry

Návraty

Implementuje

Platí pro

Parse(String, NumberStyles)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Váš názor

Další materiály