UInt64.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

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

Přetížení

Parse(String, NumberStyles, IFormatProvider)	Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový 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 64bitový 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 64bitový celočíselný ekvivalent bez znaménka.
Parse(String, NumberStyles)	Převede řetězcové vyjádření čísla v zadaném stylu na jeho 64bitové celočíselné ekvivalenty 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 64bitový celočíselný ekvivalent bez znaménka.

Parse(String, NumberStyles, IFormatProvider)

Zdroj:

UInt64.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Decimal.Parse(String)

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

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

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

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

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

Parametry

s

String

Řetězec, který představuje číslo k převedení. Řetězec je interpretován 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 sjazykovou verzi.

Návraty

UInt64

64bitové celé číslo bez znaménka odpovídající číslu zadanému v s.

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentNullException

Parametr s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier hodnot a HexNumber .

FormatException

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

OverflowException

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

-nebo-

s zahrnuje 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 64bitové 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,
                                    UInt64.Parse(value, style, ci));
               }
               catch (FormatException) {
                  Console.WriteLine("      Unable to parse '{0}'.", value);
               }      
               catch (OverflowException) {
                  Console.WriteLine("      '{0}' is out of range of the UInt64 type.",
                                    value);
               }
            }
         }
      }                                    
   }
}
// The example displays the following output:
//       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 UInt64 type.
//          Unable to parse '-103214,00'.
//          '104561.1' is out of range of the UInt64 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 UInt64 type.
//          Unable to parse '104561.1'.
//          '104561,1' is out of range of the UInt64 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 {UInt64.Parse(value, style, ci)}."
            with
            | :? FormatException ->
                printfn $"      Unable to parse '{value}'."
            | :? OverflowException ->
                printfn $"      '{value}' is out of range of the UInt64 type."
// The example displays the following output:
//       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 UInt64 type.
//          Unable to parse '-103214,00'.
//          '104561.1' is out of range of the UInt64 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 UInt64 type.
//          Unable to parse '104561.1'.
//          '104561,1' is out of range of the UInt64 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, _
                                    UInt64.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 UInt64 type.", _
                                    value)         
               End Try
            Next
         Next
      Next                                    
   End Sub
End Module
' The example displays the following output:
'       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 UInt64 type.
'          Unable to parse '-103214,00'.
'          '104561.1' is out of range of the UInt64 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 UInt64 type.
'          Unable to parse '104561.1'.
'          '104561,1' is out of range of the UInt64 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 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[.fractional_digits][E[sign]exponential_digits][ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Pokud style obsahuje NumberStyles.AllowHexSpecifierparametr , 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. Pokud příznak obsahujeNumberStyles.AllowLeadingWhite, může se na začátku sstyle zobrazit prázdné znaky, a pokud style příznak obsahujeNumberStyles.AllowTrailingWhite, může se zobrazit na koncis.
$	Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována CurrencyPositivePattern vlastností objektu NumberFormatInfo , která je vrácena metodou GetFormat parametru provider . Symbol měny se může zobrazit v s , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak .
sign	Nepovinný znak. (Metoda vyvolá hodnotu OverflowException if s obsahuje záporné znaménko a představuje nenulové číslo.) Znaménko se může zobrazit na začátku, s pokud style obsahuje NumberStyles.AllowLeadingSign příznak, a může se zobrazit na konci, s pokud style příznak obsahuje NumberStyles.AllowTrailingSign . 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 jen v s případě, že styleNumberStyles.AllowDecimalPoint obsahuje 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 .
hexdigits	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 s NUL (U+0000) bez ohledu na hodnotu argumentu style .

Řetězec pouze s desítkový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 nemusí být přítomny, v tomto vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v snástroji .

Neseseparované NumberStyles hodnoty	Prvky povolené s spolu s číslicemi
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Desetinná čárka (.) a fractional_digits prvky. Pokud však styl neobsahuje NumberStyles.AllowExponent příznak, musí fractional_digits obsahovat pouze jednu nebo více číslic; jinak 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 .s
NumberStyles.AllowTrailingWhite	Element ws na konci .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č skupin (,).
NumberStyles.AllowCurrencySymbol	Element currency ($).

Pokud se NumberStyles.AllowHexSpecifier použije příznak, s musí to být šestnáctková hodnota. Platné šestnáctkové znaky jsou 0-9, A-F a a-f. Předpona 0x se nepodporuje a způsobí selhání operace analýzy. Jediné další příznaky, které se dají s tímto příznakem kombinovat, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , NumberStyles.HexNumberkterý obsahuje oba příznaky prázdných znaků.)

Poznámka

s Pokud je parametr řetězcovým vyjádřením šestnáctkového čísla, nemůže mu předcházet žádné dekorace (například 0x nebo &h), které ho odlišují 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 sformátu . Existují tři způsoby použití parametru provider 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 jednoduše GetFormat 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:

UInt64.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 64bitový celočíselný ekvivalent bez znaménka.

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

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

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

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

Návraty

UInt64

64bitové celé číslo bez znaménka odpovídající číslu zadanému v s.

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Zdroj:

UInt64.cs

Parsuje rozsah znaků UTF-8 na hodnotu.

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

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

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

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

UInt64

Výsledek analýzy utf8Text

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Zdroj:

UInt64.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Decimal.Parse(String)

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

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

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

static member Parse : string * IFormatProvider -> uint64

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

Parametry

s

String

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

provider

IFormatProvider

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

Návraty

UInt64

64bitové celé číslo bez znaménka odpovídající číslu zadanému v s.

Implementuje

Parse(String, IFormatProvider)

Výjimky

ArgumentNullException

Parametr s je null.

FormatException

Parametr s není ve správném stylu.

OverflowException

Parametr s představuje číslo menší než UInt64.MinValue nebo větší než UInt64.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ří do daného objektuParse(String, IFormatProvider), CultureInfo se pak předá metodě, která převede vstup uživatele na UInt64 hodnotu.

protected void OkToSingle_Click(object sender, EventArgs e)
{
    string locale;
    float 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 = Single.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 OkToSingle_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToSingle.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Single

   ' 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 = Single.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As OverflowException
      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 UInt64 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	Volitelné kladné 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 celočíselné hodnoty bez znaménka jsou povoleny pouze počáteční a koncové mezery spolu se znaménkem na začátku. (Pokud je znaménko záporné, s musí představovat hodnotu nula, nebo metoda vyvolá OverflowException.) Pokud chcete explicitně definovat prvky stylu společně 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 sformátu . Existují tři způsoby použití parametru provider 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 jednoduše GetFormat 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:

UInt64.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Decimal.Parse(String)

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

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

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

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

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

Parametry

s

String

Řetězec, který představuje číslo k převedení. Řetězec je interpretován pomocí stylu určeného parametrem style .

style

NumberStyles

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

Návraty

UInt64

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

Výjimky

ArgumentNullException

Parametr s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier hodnot a HexNumber .

FormatException

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

OverflowException

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

-nebo-

s zahrnuje 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 {
               ulong number = UInt64.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 = UInt64.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 ULong = UInt64.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, symbol oddělovače skupin nebo symbol desetinné čárky), které jsou povoleny v parametru s pro úspěšnou operaci analýzy. style musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style umožňuje, aby přetížení této metody bylo užitečné, pokud s obsahuje řetězcové vyjádření šestnáctkové hodnoty, pokud je číselný systém (desítkový nebo šestnáctkový) reprezentovaný s hodnotou známý pouze za běhu, nebo pokud 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 obsahuje NumberStyles.AllowHexSpecifierparametr , 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é znaky se můžou 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, s pokud style obsahuje NumberStyles.AllowLeadingSign příznak, a může se zobrazit 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. 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 UInt64 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 jako "0x" není podporována a způsobí selhání operace analýzy. 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:

UInt64.cs

Parsuje rozsah znaků na hodnotu.

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

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

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

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

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

UInt64

Výsledek analýzy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Zdroj:

UInt64.cs

Parsuje rozsah znaků UTF-8 na hodnotu.

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

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

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

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

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

UInt64

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String)

Zdroj:

UInt64.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Decimal.Parse(String)

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

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

public static ulong Parse (string s);

static member Parse : string -> uint64

Public Shared Function Parse (s As String) As ULong

Parametry

s

String

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

Návraty

UInt64

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

Výjimky

ArgumentNullException

Parametr s je null.

FormatException

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

OverflowException

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

Příklady

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

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

let values = 
    [| "+13230"; "-0"; "1,390,146"; "$190,235,421,127"
       "0xFA1B"; "163042"; "-10"; "14065839182"
       "16e07"; "134985.0"; "-12034" |]
for value in values do
    try 
        let number = UInt64.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
//       14065839182 --> 14065839182
//       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", "14065839182", _
                           "16e07", "134985.0", "-12034" }
For Each value As String In values
   Try
      Dim number As ULong = UInt64.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
'       14065839182 --> 14065839182
'       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