UInt64.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Převede řetězcové vyjádření čísla na 64bitové celé číslo 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 64bitové celočíselné ekvivalenty.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na 64bitový celočíselnou ekvivalent.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(String, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na 64bitové celé číslo bez znaménka.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(String)	Převede řetězcové vyjádření čísla na 64bitové celé číslo bez znaménka.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na 64bitový celočíselnou ekvivalent.

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ězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na 64bitové celočíselné ekvivalenty.

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, 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 pro zadání je Integer.

provider

IFormatProvider

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

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í hodnot AllowHexSpecifier 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 obsahuje nenulové desetinné číslice.

Příklady

Následující příklad používá metodu Parse(String, NumberStyles, IFormatProvider) k převodu 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 povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu.

V závislosti na hodnotě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko]číslice[.fractional_digits][E[znaménko]exponential_digits][ws]

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

[ws]šestnáctkové[ws]

Následující tabulka popisuje jednotlivé prvky.

Element	Popis
ws	Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována CurrencyPositivePattern vlastnost NumberFormatInfo objektu, který je vrácen GetFormat metodou provider parametru. Symbol měny se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko	Volitelné znaménko. (Metoda vyvolá OverflowException, pokud s obsahuje záporné znaménko a představuje nenulové číslo.) Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se zobrazit konec s, pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.
číslice	Posloupnost čí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 příznak NumberStyles.AllowDecimalPoint.
fractional_digits	Jeden nebo více výskytů číslice 0-9, pokud style obsahuje příznak NumberStyles.AllowExponent nebo jeden nebo více výskytů číslice 0, pokud ne. Desetinná číslice se můžou v s zobrazovat jenom v případě, že style obsahuje příznak NumberStyles.AllowDecimalPoint.
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
exponential_digits	Posloupnost číslic od 0 do 9. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

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

Řetězec s desetinnými číslicemi (který odpovídá stylu NumberStyles.None) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů ovládacích prvků, 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 s.

Neseloženého NumberStyles hodnot	Prvky povolené v s kromě číslic
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Desetinná čárka (.) a prvky fractional_digits. Pokud však styl neobsahuje příznak NumberStyles.AllowExponent, fractional_digits musí obsahovat pouze jednu nebo více 0 číslic; v opačném případě je vyvolán OverflowException.
NumberStyles.AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
NumberStyles.AllowLeadingWhite	Prvek ws na začátku s.
NumberStyles.AllowTrailingWhite	Prvek ws na konci s.
NumberStyles.AllowLeadingSign	Znaménko před číslice.
NumberStyles.AllowTrailingSign	Znak za číslicemi .
NumberStyles.AllowParentheses	Závorky před a za číslice označují zápornou hodnotu.
NumberStyles.AllowThousands	Oddělovač skupin (,) – element.
NumberStyles.AllowCurrencySymbol	Prvek měny ($).

Pokud se používá příznak NumberStyles.AllowHexSpecifier, s musí být šestnáctková hodnota. Platné šestnáctkové znaky jsou 0-9, A-F a a-f. Předpona, například 0x, není podporována a způsobí selhání operace analýzy. Jedinými dalšími příznaky, které lze kombinovat s ním, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles zahrnuje složený styl čísla, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

Poznámka

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

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

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

• Můžete předat objekt CultureInfo, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho vlastnost NumberFormat 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 je providernull, použije se objekt NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

• ToString
• analýza číselných řetězců v rozhraní .NET

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Zdroj:

UInt64.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

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

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 k převodu. 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 pro zadání je Integer.

provider

IFormatProvider

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

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

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 pro analýzu.

style

NumberStyles

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

provider

IFormatProvider

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

Návraty

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 64bitové celé číslo 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, které se má převést.

provider

IFormatProvider

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

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

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

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 hodnotu UInt64. Dá se například použít k převodu textu zadaného uživatelem do textového pole HTML na číselnou hodnotu.

Parametr s obsahuje číslo formuláře:

[ws] [sign]digits[ws]

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

Element	Popis
ws	Volitelné prázdné znaky.
znaménko	Volitelné kladné znaménko nebo záporné znaménko, pokud s představuje hodnotu nula.
číslice	Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí stylu NumberStyles.Integer. Kromě desetinných číslic celé hodnoty bez znaménka je povoleno pouze počáteční a koncové mezery spolu s počátečním symbolem. (Pokud je přítomno záporné znaménko, s musí představovat hodnotu nuly nebo metoda vyvolá OverflowException.) Chcete-li 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íž metoda GetFormat vrací objekt NumberFormatInfo, který poskytuje informace specifické pro jazykovou verzi formátu s. Existují tři způsoby použití parametru provider k zadání vlastních informací o formátování do operace analýzy:

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

• Můžete předat objekt CultureInfo, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho vlastnost NumberFormat 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 je providernull, použije se NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

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

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:

UInt64.cs

Parsuje rozsah znaků do hodnoty.

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 o 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 do hodnoty.

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 pro analýzu.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o 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ězcové vyjádření čísla na 64bitové celé číslo 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, které se má převést.

Návraty

UInt64

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

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 formátu.

[ws] [znaménko]číslice[ws]

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

Element	Popis
ws	Volitelné prázdné znaky.
znaménko	Volitelné znaménko. Platné znaky znaménka jsou určeny NumberFormatInfo.NegativeSign a NumberFormatInfo.PositiveSign vlastnostmi aktuální jazykové verze. Symbol záporného znaménka však lze použít pouze s nulou; jinak metoda vyvolá OverflowException.
číslice	Posloupnost číslic v rozsahu od 0 do 9 Všechny počáteční nuly se ignorují.

Poznámka

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

Parametr s je analyzován pomocí informací o formátování v objektu System.Globalization.NumberFormatInfo, který je inicializován pro aktuální systémovou jazykovou verzi. Další informace najdete v tématu NumberFormatInfo.CurrentInfo. K analýze řetězce 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 rozhraní .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 64bitový celočíselnou ekvivalent.

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, 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čuje povolený formát s. Typická hodnota pro zadání je Integer.

Návraty

UInt64

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

Výjimky

ArgumentNullException

Parametr s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací hodnot AllowHexSpecifier 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 obsahuje nenulové desetinné číslice.

Příklady

Následující příklad se pokusí analyzovat každý prvek v řetězcovém poli pomocí řady 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ý znak, symbol kladného nebo záporného znaménka, symbol oddělovače skupin nebo symbol desetinné čárky), které jsou povolené v parametru s pro úspěšnou operaci analýzy. style musí být kombinací bitových příznaků z výčtu NumberStyles. Parametr style tuto metodu přetíží, pokud s obsahuje řetězcovou reprezentaci šestnáctkové hodnoty, pokud číselný systém (desítkový nebo šestnáctkový) reprezentovaný s je 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ě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko] [číslice,]číslic[.fractional_digits][E[znaménko]exponential_digits][ws]

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

[ws]šestnáctkové[ws]

Následující tabulka popisuje jednotlivé prvky.

Element	Popis
ws	Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern vlastnosti aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se zobrazit na konci s pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses. Symbol záporného znaménka však lze použít pouze s nulou; jinak metoda vyvolá OverflowException.
číslice fractional_digits exponential_digits	Posloupnost číslic od 0 do 9. Pro fractional_digitsje platná pouze číslice 0.
,	Symbol oddělovače skupin specifických pro jazykovou verzi. Oddělovač skupin aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowThousands.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint. Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; pokud fractional_digits obsahuje jakoukoli jinou číslici, vyvolá se FormatException.
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

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

Řetězec pouze s číslicemi (který odpovídá stylu NumberStyles.None) se vždy úspěšně parsuje, pokud je v rozsahu typu UInt64. Většina zbývajících NumberStyles členů ovládací 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 s.

hodnota NumberStyles	Prvky povolené v s kromě číslic
None	Pouze číslice prvek.
AllowDecimalPoint	Desetinná čárka (.) a desetinná místa prvky.
AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
AllowLeadingWhite	Element ws na začátku s.
AllowTrailingWhite	Prvek ws na konci s.
AllowLeadingSign	Znak prvek na začátku s.
AllowTrailingSign	Znak prvek na konci s.
AllowParentheses	Znak prvek ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Element oddělovače skupin (,).
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. s však nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo konci s, znaménko na začátku sa symbol desetinné čárky (.). Parametr s může také použít exponenciální zápis.
Number	Prvky ws, sign, oddělovač skupin (,) a desetinná čárka (.).
Any	Všechny prvky. s však nemůže 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 sznamená, že hodnota stylu NumberStyles.AllowHexSpecifier znamená, že jednotlivé číselné znaky v s 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í podporována a způsobí selhání operace analýzy. Jedinými dalšími příznaky, které lze kombinovat s parametrem style, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles zahrnuje složený styl čísla, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

Poznámka

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

Parametr s je analyzován pomocí informací o formátování v objektu NumberFormatInfo, který je inicializován pro aktuální systémovou jazykovou verzi. Chcete-li určit jazykovou verzi, jejíž informace 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 rozhraní .NET