UInt32.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Převede řetězcovou reprezentaci čísla na jeho 32bitový celočíselný ekvivalent bez znaménka.

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 bez znaménka.
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 bez znaménka.
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 bez znaménka.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 32bitový celočíselný ekvivalent bez znaménka.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků na hodnotu.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 na hodnotu.
Parse(String)	Převede řetězcovou reprezentaci čísla na jeho 32bitový celočíselný ekvivalent bez znaménka.

Parse(String, NumberStyles, IFormatProvider)

Zdroj:

UInt32.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Int64.Parse(String)

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

public:
 static System::UInt32 Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::UInt32>::Parse;

public static uint Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> uint32

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As UInteger

Parametry

s

String

Řetězec představující číslo, které se má převést. Řetězec se interpretuje pomocí stylu určeného parametrem style .

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 o formátování specifické pro jazykovou verzi .s

Návraty

UInt32

32bitové celé číslo bez znaménka, které odpovídá čí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í AllowHexSpecifier hodnot a HexNumber .

FormatException

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

OverflowException

s představuje číslo, které je menší než UInt32.MinValue nebo větší než UInt32.MaxValue.

-nebo-

s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad používá metodu k převodu Parse(String, NumberStyles, IFormatProvider) různých řetězcových reprezentací čísel na 32bitové celočíselné hodnoty bez znaménka.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] cultureNames= { "en-US", "fr-FR" };
      NumberStyles[] styles= { NumberStyles.Integer,
                               NumberStyles.Integer | NumberStyles.AllowDecimalPoint };
      string[] values = { "170209", "+170209.0", "+170209,0", "-103214.00",
                                 "-103214,00", "104561.1", "104561,1" };
      
      // Parse strings using each culture
      foreach (string cultureName in cultureNames)
      {
         CultureInfo ci = new CultureInfo(cultureName);
         Console.WriteLine("Parsing strings using the {0} culture", 
                           ci.DisplayName);
         // Use each style.
         foreach (NumberStyles style in styles)
         {
            Console.WriteLine("   Style: {0}", style.ToString());
            // Parse each numeric string.
            foreach (string value in values)
            {
               try {
                  Console.WriteLine("      Converted '{0}' to {1}.", value,
                                    UInt32.Parse(value, style, ci));
               }
               catch (FormatException) {
                  Console.WriteLine("      Unable to parse '{0}'.", value);
               }      
               catch (OverflowException) {
                  Console.WriteLine("      '{0}' is out of range of the UInt32 type.",
                                    value);
               }
            }
         }
      }                                    
   }
}
// The example displays the following output:
//       Parsing strings using the English (United States) culture
//          Style: Integer
//             Converted '170209' to 170209.
//             Unable to parse '+170209.0'.
//             Unable to parse '+170209,0'.
//             Unable to parse '-103214.00'.
//             Unable to parse '-103214,00'.
//             Unable to parse '104561.1'.
//             Unable to parse '104561,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '170209' to 170209.
//             Converted '+170209.0' to 170209.
//             Unable to parse '+170209,0'.
//             '-103214.00' is out of range of the UInt32 type.
//             Unable to parse '-103214,00'.
//             '104561.1' is out of range of the UInt32 type.
//             Unable to parse '104561,1'.
//       Parsing strings using the French (France) culture
//          Style: Integer
//             Converted '170209' to 170209.
//             Unable to parse '+170209.0'.
//             Unable to parse '+170209,0'.
//             Unable to parse '-103214.00'.
//             Unable to parse '-103214,00'.
//             Unable to parse '104561.1'.
//             Unable to parse '104561,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '170209' to 170209.
//             Unable to parse '+170209.0'.
//             Converted '+170209,0' to 170209.
//             Unable to parse '-103214.00'.
//             '-103214,00' is out of range of the UInt32 type.
//             Unable to parse '104561.1'.
//             '104561,1' is out of range of the UInt32 type.

open System
open System.Globalization

let cultureNames = [| "en-US"; "fr-FR" |]
let styles = 
    [| NumberStyles.Integer; NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint |]
let values = 
    [| "170209"; "+170209.0"; "+170209,0"; "-103214.00"; "-103214,00"; "104561.1"; "104561,1" |]

// Parse strings using each culture
for cultureName in cultureNames do
    let ci = CultureInfo cultureName
    printfn $"Parsing strings using the {ci.DisplayName} culture"
    // Use each style.
    for style in styles do
        printfn $"   Style: {style}"
        // Parse each numeric string.
        for value in values do
            try
                printfn $"      Converted '{value}' to {UInt32.Parse(value, style, ci)}."
            with
            | :? FormatException ->
                printfn $"      Unable to parse '{value}'."
            | :? OverflowException ->
                printfn $"      '{value}' is out of range of the UInt32 type."
// The example displays the following output:
//       Parsing strings using the English (United States) culture
//          Style: Integer
//             Converted '170209' to 170209.
//             Unable to parse '+170209.0'.
//             Unable to parse '+170209,0'.
//             Unable to parse '-103214.00'.
//             Unable to parse '-103214,00'.
//             Unable to parse '104561.1'.
//             Unable to parse '104561,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '170209' to 170209.
//             Converted '+170209.0' to 170209.
//             Unable to parse '+170209,0'.
//             '-103214.00' is out of range of the UInt32 type.
//             Unable to parse '-103214,00'.
//             '104561.1' is out of range of the UInt32 type.
//             Unable to parse '104561,1'.
//       Parsing strings using the French (France) culture
//          Style: Integer
//             Converted '170209' to 170209.
//             Unable to parse '+170209.0'.
//             Unable to parse '+170209,0'.
//             Unable to parse '-103214.00'.
//             Unable to parse '-103214,00'.
//             Unable to parse '104561.1'.
//             Unable to parse '104561,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '170209' to 170209.
//             Unable to parse '+170209.0'.
//             Converted '+170209,0' to 170209.
//             Unable to parse '-103214.00'.
//             '-103214,00' is out of range of the UInt32 type.
//             Unable to parse '104561.1'.
//             '104561,1' is out of range of the UInt32 type.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR" }
      Dim styles() As NumberStyles = { NumberStyles.Integer, _
                                       NumberStyles.Integer Or NumberStyles.AllowDecimalPoint }
      Dim values() As String = { "170209", "+170209.0", "+170209,0", "-103214.00", _
                                 "-103214,00", "104561.1", "104561,1" }
      
      ' Parse strings using each culture
      For Each cultureName As String In cultureNames
         Dim ci As New CultureInfo(cultureName)
         Console.WriteLine("Parsing strings using the {0} culture", ci.DisplayName)
         ' Use each style.
         For Each style As NumberStyles In styles
            Console.WriteLine("   Style: {0}", style.ToString())
            ' Parse each numeric string.
            For Each value As String In values
               Try
                  Console.WriteLine("      Converted '{0}' to {1}.", value, _
                                    UInt32.Parse(value, style, ci))
               Catch e As FormatException
                  Console.WriteLine("      Unable to parse '{0}'.", value)   
               Catch e As OverflowException
                  Console.WriteLine("      '{0}' is out of range of the UInt32 type.", _
                                    value)         
               End Try
            Next
         Next
      Next                                    
   End Sub
End Module
' The example displays the following output:
'       Parsing strings using the English (United States) culture
'          Style: Integer
'             Converted '170209' to 170209.
'             Unable to parse '+170209.0'.
'             Unable to parse '+170209,0'.
'             Unable to parse '-103214.00'.
'             Unable to parse '-103214,00'.
'             Unable to parse '104561.1'.
'             Unable to parse '104561,1'.
'          Style: Integer, AllowDecimalPoint
'             Converted '170209' to 170209.
'             Converted '+170209.0' to 170209.
'             Unable to parse '+170209,0'.
'             '-103214.00' is out of range of the UInt32 type.
'             Unable to parse '-103214,00'.
'             '104561.1' is out of range of the UInt32 type.
'             Unable to parse '104561,1'.
'       Parsing strings using the French (France) culture
'          Style: Integer
'             Converted '170209' to 170209.
'             Unable to parse '+170209.0'.
'             Unable to parse '+170209,0'.
'             Unable to parse '-103214.00'.
'             Unable to parse '-103214,00'.
'             Unable to parse '104561.1'.
'             Unable to parse '104561,1'.
'          Style: Integer, AllowDecimalPoint
'             Converted '170209' to 170209.
'             Unable to parse '+170209.0'.
'             Converted '+170209,0' to 170209.
'             Unable to parse '-103214.00'.
'             '-103214,00' is out of range of the UInt32 type.
'             Unable to parse '104561.1'.
'             '104561,1' is out of range of the UInt32 type.

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky nebo symbol kladného nebo záporného znaménka), které jsou v parametru s povoleny, aby operace parsování byla úspěšná. 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[.fractional_digits][E[sign]exponential_digits][ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Pokud style obsahuje NumberStyles.AllowHexSpecifier, s může parametr obsahovat následující prvky:

[ws] hexdigits[ws]

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 CurrencyPositivePattern vlastností objektu NumberFormatInfo , která je vrácena GetFormat metodou parametru provider . Symbol měny se může zobrazit v s , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak.
sign	Nepovinný znak. (Metoda vyvolá OverflowException hodnotu if s zahrnuje záporné znaménko a představuje nenulové číslo.) Znaménko se může zobrazit na začátku, s pokud příznak obsahujeNumberStyles.AllowLeadingSign, a může se zobrazit na koncis, pokud style příznak obsahuje NumberStyles.AllowTrailingSignstyle. Závorky lze v s použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic	Řada číslic od 0 do 9.
.	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.
Fractional_digits	Jeden nebo více výskytů číslice 0-9, pokud style obsahuje NumberStyles.AllowExponent příznak, nebo jeden nebo více výskytů číslice 0, pokud není. Desetinné číslice se můžou zobrazit pouze v s případě, že style obsahuje NumberStyles.AllowDecimalPoint příznak.
E	Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. Parametr s může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak.
exponential_digits	Řada číslic od 0 do 9. 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ě parsuje. Většina zbývajících NumberStyles členů řídí prvky, které mohou být přítomny, 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.

Neseseparované NumberStyles hodnoty	Prvky povolené s kromě číslic
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Desetinná čárka (.) a fractional_digits elementy. Pokud však styl příznak neobsahuje NumberStyles.AllowExponent , musí fractional_digits obsahovat pouze jednu nebo více číslic. V opačném případě OverflowException je vyvolán znak .
NumberStyles.AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis spolu s exponential_digits.
NumberStyles.AllowLeadingWhite	Element ws na začátku souboru s.
NumberStyles.AllowTrailingWhite	Element ws na konci souboru s.
NumberStyles.AllowLeadingSign	Znaménko před číslicemi.
NumberStyles.AllowTrailingSign	Znaménko za číslicemi.
NumberStyles.AllowParentheses	Závorky před číslicemi a za číslicemi označují zápornou hodnotu.
NumberStyles.AllowThousands	Element oddělovače skupin (,).
NumberStyles.AllowCurrencySymbol	Element currency ($).

Pokud se NumberStyles.AllowHexSpecifier použije příznak, s musí být šestnáctková hodnota. Jedinými dalšími příznaky, které je možné s ním kombinovat, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , NumberStyles.HexNumberkterý zahrnuje oba příznaky prázdných znaků.)

Poznámka

s Pokud je parametr řetězcovou reprezentací šestnáctkového čísla, nemůže předcházet žádná dekorace (například 0x nebo&h), která ho odlišuje jako šestnáctkové číslo. To způsobí, že operace analýzy vyvolá výjimku.

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi o formátu .s Existují tři způsoby, jak použít provider parametr k poskytnutí informací o vlastním formátování do operace parsování:

• Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o formátování. (Jeho implementace GetFormat jednoduše vrátí sama sebe.)

• Můžete předat CultureInfo objekt, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho NumberFormat vlastnost poskytuje informace o formátování.

• Můžete předat vlastní IFormatProvider implementaci. Jeho GetFormat metoda musí vytvořit instanci a vrátit NumberFormatInfo objekt, který poskytuje informace o formátování.

Pokud provider je null, použije se NumberFormatInfo objekt pro aktuální jazykovou verzi.

Viz také

• ToString()
• Analýza číselných řetězců v .NET

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Zdroj:

UInt32.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

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

public static uint Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> uint32

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As UInteger

Parametry

s

ReadOnlySpan<Char>

Rozsah obsahující znaky, které představují číslo, které se má převést. Rozsah se interpretuje pomocí stylu určeného parametrem style .

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 o formátování specifické pro jazykovou verzi .s

Návraty

UInt32

32bitové celé číslo bez znaménka, které odpovídá číslu zadanému v s.

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Zdroj:

UInt32.cs

Parsuje rozsah znaků UTF-8 na hodnotu.

public static uint Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> uint32

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As UInteger

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 jazykovou verzi .utf8Text

Návraty

UInt32

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Zdroj:

UInt32.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Int64.Parse(String)

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

public:
 static System::UInt32 Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::UInt32>::Parse;

public static uint Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> uint32

Public Shared Function Parse (s As String, provider As IFormatProvider) As UInteger

Parametry

s

String

Řetězec, který představuje číslo k převedení.

provider

IFormatProvider

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

Návraty

UInt32

32bitové celé číslo bez znaménka, které odpovídá číslu zadanému v s.

Implementuje

Parse(String, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

FormatException

s není ve správném stylu.

OverflowException

s představuje číslo, které je menší než UInt32.MinValue nebo větší než UInt32.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í. Objekt NumberFormatInfo , který patří danému objektu, CultureInfo se pak předá Parse(String, IFormatProvider) metodě, která převede vstup uživatele na UInt32 hodnotu.

protected void OkToUInteger_Click(object sender, EventArgs e)
{
    string locale;
    uint 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 = UInt32.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 OKToUInteger_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OKToUInteger.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As UInteger

   ' 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 = UInt32.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

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	Volitelné znaménko nebo záporné znaménko, pokud s představuje hodnotu nula.
Číslic	Řada číslic od 0 do 9.

Parametr s se interpretuje pomocí NumberStyles.Integer stylu. Kromě desetinných číslic celé hodnoty bez znaménka jsou povoleny pouze počáteční a koncové mezery spolu s počátečním znaménkem. (Pokud je znaménko záporné, s musí představovat hodnotu nula, jinak metoda vyvolá OverflowException.) Chcete-li explicitně definovat prvky stylu spolu s informacemi o formátování specifické pro jazykovou verzi, které mohou být přítomny v s, použijte metodu Parse(String, NumberStyles, IFormatProvider) .

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi o formátu .s Existují tři způsoby, jak použít provider parametr k poskytnutí informací o vlastním formátování do operace parsování:

• Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o formátování. (Jeho implementace GetFormat jednoduše vrátí sama sebe.)

• Můžete předat CultureInfo objekt, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho NumberFormat vlastnost poskytuje informace o formátování.

• Můžete předat vlastní IFormatProvider implementaci. Jeho GetFormat metoda musí vytvořit instanci a vrátit NumberFormatInfo objekt, který poskytuje informace o formátování.

Pokud provider je null, použije se NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

• ToString()
• TryParse
• Analýza číselných řetězců v .NET

Parse(String, NumberStyles)

Zdroj:

UInt32.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Int64.Parse(String)

Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 32bitový celočíselný ekvivalent bez znaménka.

public:
 static System::UInt32 Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static uint Parse (string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> uint32

Public Shared Function Parse (s As String, style As NumberStyles) As UInteger

Parametry

s

String

Řetězec představující číslo, které se má převést. Řetězec se interpretuje pomocí stylu určeného parametrem style .

style

NumberStyles

Bitová kombinace hodnot výčtu, které určují povolený formát .s Typická hodnota, která se má zadat, je Integer.

Návraty

UInt32

32bitové celé číslo bez znaménka, které odpovídá číslu zadanému v s.

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, které je menší než UInt32.MinValue nebo větší než UInt32.MaxValue.

-nebo-

s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad se pokusí parsovat každý prvek v řetězcovém poli pomocí počtu NumberStyles hodnot.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values= { " 214309 ", "1,064,181", "(0)", "10241+", " + 21499 ", 
                         " +21499 ", "122153.00", "1e03ff", "91300.0e-2" };
      NumberStyles whitespace =  NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite;
      NumberStyles[] styles= { NumberStyles.None, whitespace, 
                               NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingSign | whitespace, 
                               NumberStyles.AllowThousands | NumberStyles.AllowCurrencySymbol, 
                               NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint };

      // Attempt to convert each number using each style combination.
      foreach (string value in values)
      {
         Console.WriteLine("Attempting to convert '{0}':", value);
         foreach (NumberStyles style in styles)
         {
            try {
               uint number = UInt32.Parse(value, style);
               Console.WriteLine("   {0}: {1}", style, number);
            }   
            catch (FormatException) {
               Console.WriteLine("   {0}: Bad Format", style);
            }   
            catch (OverflowException)
            {
               Console.WriteLine("   {0}: Overflow", value);         
            }         
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Attempting to convert ' 214309 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: 214309
//       Integer, AllowTrailingSign: 214309
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1,064,181':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: 1064181
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '(0)':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '10241+':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 10241
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' + 21499 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' +21499 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 21499
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '122153.00':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 122153
//    
//    Attempting to convert '1e03ff':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '91300.0e-2':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 913

open System
open System.Globalization

let values = 
    [| " 214309 "; "1,064,181"; "(0)"; "10241+"; " + 21499 " 
       " +21499 "; "122153.00"; "1e03ff"; "91300.0e-2" |]

let whitespace =  NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite
let styles = 
    [| NumberStyles.None; whitespace 
       NumberStyles.AllowLeadingSign ||| NumberStyles.AllowTrailingSign ||| whitespace
       NumberStyles.AllowThousands ||| NumberStyles.AllowCurrencySymbol
       NumberStyles.AllowExponent ||| NumberStyles.AllowDecimalPoint |]

// Attempt to convert each number using each style combination.
for value in values do
    printfn $"Attempting to convert '{value}':"
    for style in styles do
        try
            let number = UInt32.Parse(value, style)
            printfn $"   {style}: {number}"
        with
        | :? FormatException ->
            printfn $"   {style}: Bad Format"
        | :? OverflowException ->
            printfn $"   {value}: Overflow"
    printfn "" 
// The example displays the following output:
//    Attempting to convert ' 214309 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: 214309
//       Integer, AllowTrailingSign: 214309
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1,064,181':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: 1064181
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '(0)':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '10241+':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 10241
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' + 21499 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' +21499 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 21499
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '122153.00':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 122153
//    
//    Attempting to convert '1e03ff':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '91300.0e-2':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 913

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { " 214309 ", "1,064,181", "(0)", "10241+", _
                                 " + 21499 ", " +21499 ", "122153.00", _
                                 "1e03ff", "91300.0e-2" }
      Dim whitespace As NumberStyles =  NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite
      Dim styles() As NumberStyles = { NumberStyles.None, _
                                       whitespace, _
                                       NumberStyles.AllowLeadingSign Or NumberStyles.AllowTrailingSign Or whitespace, _
                                       NumberStyles.AllowThousands Or NumberStyles.AllowCurrencySymbol, _
                                       NumberStyles.AllowExponent Or NumberStyles.AllowDecimalPoint }

      ' Attempt to convert each number using each style combination.
      For Each value As String In values
         Console.WriteLine("Attempting to convert '{0}':", value)
         For Each style As NumberStyles In styles
            Try
               Dim number As UInteger = UInt32.Parse(value, style)
               Console.WriteLine("   {0}: {1}", style, number)
            Catch e As FormatException
               Console.WriteLine("   {0}: Bad Format", style)
            Catch e As OverflowException
               Console.WriteLine("   {0}: Overflow", value)         
            End Try         
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    Attempting to convert ' 214309 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: 214309
'       Integer, AllowTrailingSign: 214309
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '1,064,181':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: 1064181
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '(0)':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '10241+':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: 10241
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert ' + 21499 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert ' +21499 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: 21499
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '122153.00':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 122153
'    
'    Attempting to convert '1e03ff':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '91300.0e-2':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 913

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky, symbol kladného nebo záporného znaménka, oddělovač skupin nebo symbol desetinné čárky), které jsou povoleny v parametru s , aby operace parsování byla úspěšná. style musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style činí přetížení této metody užitečné, pokud s obsahuje řetězcovou reprezentaci šestnáctkové hodnoty, když číselný systém (desetinný nebo šestnáctkový) reprezentovaný s je známý pouze v době běhu nebo když chcete zakázat prázdné znaky nebo symbol znaménka v s.

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]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Pokud style parametr obsahuje NumberStyles.AllowHexSpecifier, s může parametr obsahovat následující prvky:

[ws] hexdigits[ws]

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. Symbol záporného znaménka však lze použít pouze s nulou; v opačném případě metoda vyvolá OverflowException.
Číslic Fractional_digits exponential_digits	Řada číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
,	Symbol oddělovače skupin, specifický pro jazykovou verzi. Oddělovač skupin 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 jinou FormatException číslici, vyvolá se znak .
E	Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) 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) se vždy úspěšně analyzuje, pokud je v rozsahu UInt32 typu. Většina zbývajících NumberStyles členů řídí prvky, které mohou být přítomny, 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.

NumberStyles Hodnotu	Prvky povolené s kromě číslic
None	Pouze prvek digits .
AllowDecimalPoint	Desetinná čárka (.) a desetinné číslice elementů .
AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis spolu s exponential_digits.
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	Prvek oddělovače skupin (,).
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. s Nemůže však představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Element ws na začátku nebo na konci s, znaménko na začátku sa symbol desetinné čárky (.). Parametr s může také použít exponenciální notaci.
Number	Elementy ws, sign, oddělovač skupin (,) a desetinná čárka (.).
Any	Všechny prvky. Nemůže však s představovat šestnáctkové číslo.

Na rozdíl od ostatních NumberStyles hodnot, které umožňují, ale nevyžadují, přítomnost určitých prvků stylu v s, NumberStyles.AllowHexSpecifier hodnota stylu znamená, že jednotlivé číselné znaky v s souboru jsou vždy interpretovány jako šestnáctkové znaky. Platné šestnáctkové znaky jsou 0-9, A-F a a-f. Předpona, například 0x, není povolená. Jedinými dalšími příznaky, které je možné kombinovat s parametrem style , jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , NumberStyles.HexNumberkterý zahrnuje oba příznaky prázdných znaků.)

Jedinými dalšími příznaky, které je možné kombinovat s parametrem style , jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , NumberStyles.HexNumberkterý zahrnuje oba příznaky prázdných znaků.)

Poznámka

Pokud s je řetězcová reprezentace šestnáctkového čísla, nemůže předcházet žádná ozdoba (například 0x nebo &h), která ho rozlišuje jako šestnáctkové číslo. To způsobí selhání převodu.

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

Viz také

• ToString()
• TryParse
• Analýza číselných řetězců v .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:

UInt32.cs

Parsuje rozsah znaků na hodnotu.

public:
 static System::UInt32 Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<System::UInt32>::Parse;

public static uint Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> uint32

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As UInteger

Parametry

s

ReadOnlySpan<Char>

Rozsah znaků, které se mají analyzovat.

provider

IFormatProvider

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

Návraty

UInt32

Výsledek analýzy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Zdroj:

UInt32.cs

Parsuje rozsah znaků UTF-8 na hodnotu.

public:
 static System::UInt32 Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<System::UInt32>::Parse;

public static uint Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> uint32

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As UInteger

Parametry

utf8Text

ReadOnlySpan<Byte>

Rozsah znaků UTF-8, které se mají analyzovat.

provider

IFormatProvider

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

Návraty

UInt32

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String)

Zdroj:

UInt32.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Int64.Parse(String)

Převede řetězcovou reprezentaci čísla na jeho 32bitový celočíselný ekvivalent bez znaménka.

public:
 static System::UInt32 Parse(System::String ^ s);

public static uint Parse (string s);

static member Parse : string -> uint32

Public Shared Function Parse (s As String) As UInteger

Parametry

s

String

Řetězec představující číslo, které se má převést.

Návraty

UInt32

32bitové celé číslo bez znaménka, které odpovídá číslu obsaženému v ssouboru .

Výjimky

ArgumentNullException

Parametr s je null.

FormatException

Parametr s nemá správný formát.

OverflowException

Parametr s představuje číslo, které je menší než UInt32.MinValue nebo větší než UInt32.MaxValue.

Příklady

Následující příklad používá metodu Parse(String) k analýze pole řetězcových hodnot.

string[] values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                    "0xFA1B", "163042", "-10", "2147483648", 
                    "14065839182", "16e07", "134985.0", "-12034" };
foreach (string value in values)
{
   try {
      uint number = UInt32.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: Overflow
//       2147483648 --> 2147483648
//       14065839182: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034: Overflow

open System

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

for value in values do
    try
        let number = UInt32.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: Overflow
//       2147483648 --> 2147483648
//       14065839182: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034: Overflow

Dim values() As String = { "+13230", "-0", "1,390,146", "$190,235,421,127", 
                           "0xFA1B", "163042", "-10", "2147483648",  
                           "14065839182", "16e07", "134985.0", "-12034" }
For Each value As String In values
   Try
      Dim number As UInteger = UInt32.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
' 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: Overflow
'       2147483648 --> 2147483648
'       14065839182: Overflow
'       16e07: Bad Format
'       134985.0: Bad Format
'       -12034: Overflow

Poznámky

Parametr s by měl být řetězcovou reprezentací čísla v následujícím formuláři.

[ws] [sign] digits[ws]

Prvky 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. Platné znakové znaky jsou určeny vlastnostmi NumberFormatInfo.NegativeSign a NumberFormatInfo.PositiveSign aktuální jazykové verze. Symbol záporného znaménka však lze použít pouze s nulou; v opačném případě metoda vyvolá OverflowException.
Číslic	Řada číslic od 0 do 9. Budou ignorovány všechny úvodní nuly.

Poznámka

Řetězec zadaný parametrem s je interpretován pomocí NumberStyles.Integer stylu. Nemůže obsahovat žádné oddělovače skupin ani oddělovač desetinných míst a nemůže mít desetinnou část.

Parametr s se analyzuje pomocí informací o formátování v objektu System.Globalization.NumberFormatInfo , který je inicializován pro aktuální systémovou jazykovou verzi. Další informace naleznete v tématu NumberFormatInfo.CurrentInfo. Pokud chcete analyzovat řetězec pomocí informací o formátování konkrétní jazykové verze, použijte metodu Parse(String, IFormatProvider) .

Viz také

• ToString()
• Analýza číselných řetězců v .NET