UInt64.Parse Methode

Definition

Namespace:: System

Assemblys:: mscorlib.dll, System.Runtime.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 64-Bit-Ganzzahlenentsprechung ohne Vorzeichen.

Überlädt

Name	Beschreibung
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Format und kulturspezifischen Format in das 64-Bit-Äquivalent einer nicht signierten ganzzahligen Zahl.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die Spandarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das 64-Bit-Äquivalent einer nicht signierten ganzzahligen Zahl.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in das 64-Bit-Äquivalent einer nicht signierten ganzzahligen Zahl.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die 64-Bit-Ganzzahlenentsprechung ohne Vorzeichen.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in die 64-Bit-Entsprechung einer nicht signierten ganzzahligen Zahl.

Parse(String, NumberStyles, IFormatProvider)

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Decimal.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Format und kulturspezifischen Format in das 64-Bit-Äquivalent einer nicht signierten ganzzahligen Zahl.

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

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

[System.CLSCompliant(false)]
public static ulong Parse(string s, System.Globalization.NumberStyles style, IFormatProvider provider);

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

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

[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> uint64

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

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

Parameter

s: String

Eine Zeichenfolge, die die zu konvertierende Zahl darstellt. Die Zeichenfolge wird mithilfe der vom style Parameter angegebenen Formatvorlage interpretiert.

style: NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Formatvorlagenelemente angibt, in sdenen vorhanden sein kann. Ein typischer Wert, der angegeben werden soll, ist Integer.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s.

Gibt zurück

UInt64

Eine 64-Bit-ganzzahl ohne Vorzeichen, die der in s.

Implementiert

Parse(String, NumberStyles, IFormatProvider)

Attribute: CLSCompliantAttribute

Ausnahmen

ArgumentNullException

Der s Parameter ist null.

ArgumentException

style ist kein NumberStyles Wert.

-oder-

style ist keine Kombination von AllowHexSpecifier und HexNumber Werten.

FormatException

Der s Parameter ist nicht in einem Format enthalten, das mit styledem Format kompatibel ist.

OverflowException

Der s Parameter stellt eine Zahl kleiner als UInt64.MinValue oder größer als UInt64.MaxValue dar.

-oder-

s enthält Nicht-Null-Dezimalstellen.

Beispiele

Im folgenden Beispiel wird die Parse(String, NumberStyles, IFormatProvider) Methode verwendet, um verschiedene Zeichenfolgendarstellungen von Zahlen in 64-Bit-ganzzahlige Werte ohne Vorzeichen zu konvertieren.

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.

Hinweise

Der style Parameter definiert die Formatvorlagenelemente (z. B. Leerzeichen oder das positive oder negative Zeichensymbol), die im s Parameter für den erfolgreichen Analysevorgang zulässig sind. Es muss eine Kombination aus Bitkennzeichnungen aus der NumberStyles Enumeration sein.

Je nach Wert kann styleder s Parameter die folgenden Elemente enthalten:

[ws][][$Vorzeichen]Ziffern[.fractional_digits][E[Zeichen]exponential_digits][ws]

Elemente in eckigen Klammern ([ und ]) sind optional. Wenn style dieser Parameter enthält NumberStyles.AllowHexSpecifier, kann der s Parameter die folgenden Elemente enthalten:

[ws]hexdigits[ws]

In der folgenden Tabelle werden die einzelnen Elemente beschrieben.

Element	Beschreibung
Ws	Optionaler Leerraum. Leerzeichen können am Anfang angezeigt `s` werden, wenn `style` die NumberStyles.AllowLeadingWhite Kennzeichnung enthalten ist, und sie kann am Ende der `s` Kennzeichnung angezeigt werden, wenn `style` die NumberStyles.AllowTrailingWhite Kennzeichnung enthalten ist.
$	Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die CurrencyPositivePattern Eigenschaft des NumberFormatInfo Objekts definiert, das von der GetFormat Methode des `provider` Parameters zurückgegeben wird. Das Währungssymbol kann angezeigt werden, wenn `s` das `style` Kennzeichen enthalten NumberStyles.AllowCurrencySymbol ist.
Zeichen	Ein optionales Zeichen. (Die Methode löst einOverflowException, wenn `s` ein negatives Zeichen enthält und eine Nicht-Null-Zahl darstellt.) Das Zeichen kann am Anfang des `s` Falls enthalten seinNumberStyles.AllowLeadingSign, und es kann das Ende der `s` Kennzeichnung angezeigt werden, wenn `style` die NumberStyles.AllowTrailingSign`style` Kennzeichnung enthalten ist. Klammern können verwendet `s` werden, um einen negativen Wert anzugeben, wenn `style` das NumberStyles.AllowParentheses Flag enthalten ist.
Ziffern	Eine Sequenz von Ziffern von 0 bis 9.
.	Ein kulturspezifisches Dezimalkommasymbol. Das Dezimalkommasymbol der aktuellen Kultur kann angezeigt werden `s` , wenn `style` das NumberStyles.AllowDecimalPoint Kennzeichen enthalten ist.
fractional_digits	Mindestens ein Vorkommen der Ziffer 0-9, wenn `style` die NumberStyles.AllowExponent Kennzeichnung enthalten ist, oder mindestens ein Vorkommen der Ziffer 0, wenn dies nicht der Fall ist. Dezimalstellen können nur angezeigt werden `s` , wenn `style` die NumberStyles.AllowDecimalPoint Kennzeichnung enthalten ist.
E	Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller (wissenschaftlicher) Schreibweise dargestellt wird. Der `s` Parameter kann eine Zahl in exponentieller Notation darstellen, wenn `style` das NumberStyles.AllowExponent Flag enthalten ist.
exponential_digits	Eine Sequenz von Ziffern von 0 bis 9. Der `s` Parameter kann eine Zahl in exponentieller Notation darstellen, wenn `style` das NumberStyles.AllowExponent Flag enthalten ist.
hexdigits	Eine Abfolge von hexadezimalen Ziffern von 0 bis f oder 0 bis F.

Anmerkung

Alle endenden NUL-Zeichen s (U+0000) werden unabhängig vom Wert des style Arguments vom Analysevorgang ignoriert.

Eine Zeichenfolge mit dezimalen Ziffern (die der NumberStyles.None Formatvorlage entspricht) analysiert immer erfolgreich. Die meisten der verbleibenden NumberStyles Elemente steuern Elemente, die vorhanden sein können, aber nicht vorhanden sein müssen, in dieser Eingabezeichenfolge. In der folgenden Tabelle wird angegeben, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die möglicherweise svorhanden sind.

Nicht zusammengesetzte `NumberStyles` Werte	Zusätzlich zu Ziffern zulässige `s` Elemente
NumberStyles.None	Nur Dezimalziffern.
NumberStyles.AllowDecimalPoint	Die Dezimalkomma (.) und fractional_digits Elemente. Wenn die Formatvorlage jedoch nicht die NumberStyles.AllowExponent Kennzeichnung enthält, muss fractional_digits nur aus einer oder mehreren 0 Ziffern bestehen. Andernfalls wird ein OverflowException Fehler ausgelöst.
NumberStyles.AllowExponent	Das Zeichen "e" oder "E", das exponentielle Notation angibt, zusammen mit exponential_digits.
NumberStyles.AllowLeadingWhite	Das ws-Element am Anfang von `s`.
NumberStyles.AllowTrailingWhite	Das ws-Element am Ende von `s`.
NumberStyles.AllowLeadingSign	Ein Vorzeichen vor Ziffern.
NumberStyles.AllowTrailingSign	Ein Zeichen nach Ziffern.
NumberStyles.AllowParentheses	Klammern vor und nach Ziffern , um einen negativen Wert anzugeben.
NumberStyles.AllowThousands	Das Gruppentrennzeichen (,) -Element.
NumberStyles.AllowCurrencySymbol	Das Währungselement ($)

Wenn das NumberStyles.AllowHexSpecifier Flag verwendet wird, s muss es sich um einen Hexadezimalwert handelt. Gültige Hexadezimalzeichen sind 0-9, A-F und a-f. Ein Präfix wie "0x" wird nicht unterstützt und bewirkt, dass der Analysevorgang fehlschlägt. Die einzigen anderen Flags, die mit ihr kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Aufzählung enthält eine zusammengesetzte Zahlenformatvorlage, NumberStyles.HexNumberdie beide Leerzeichen enthält.)

Anmerkung

Wenn der s Parameter die Zeichenfolgendarstellung einer hexadezimalen Zahl ist, kann keine Dekoration (z 0x . B. oder &h) vorangestellt werden, die ihn als hexadezimale Zahl unterscheidet. Dies bewirkt, dass der Analysevorgang eine Ausnahme auslöst.

Der provider Parameter ist eine IFormatProvider Implementierung, deren GetFormat Methode ein NumberFormatInfo Objekt zurückgibt, das kulturspezifische Informationen zum Format von s. Es gibt drei Möglichkeiten, den provider Parameter zum Bereitstellen von benutzerdefinierten Formatierungsinformationen für den Analysevorgang zu verwenden:

Sie können das tatsächliche NumberFormatInfo Objekt übergeben, das Formatierungsinformationen bereitstellt. (Seine Umsetzung der GetFormat einfach zurückgibt.)
Sie können ein CultureInfo Objekt übergeben, das die Kultur angibt, deren Formatierung verwendet werden soll. Die NumberFormat Eigenschaft stellt Formatierungsinformationen bereit.
Sie können eine benutzerdefinierte IFormatProvider Implementierung übergeben. Die GetFormat Methode muss das Objekt instanziieren und zurückgeben, das NumberFormatInfo Formatierungsinformationen bereitstellt.

Wenn provider ja null, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Konvertiert die Spandarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das 64-Bit-Äquivalent einer nicht signierten ganzzahligen Zahl.

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

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

[System.CLSCompliant(false)]
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

[<System.CLSCompliant(false)>]
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

Parameter

s: ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die die zu konvertierende Zahl darstellen. Die Spanne wird mithilfe der durch den style Parameter angegebenen Formatvorlage interpretiert.

style: NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Formatvorlagenelemente angibt, in sdenen vorhanden sein kann. Ein typischer Wert, der angegeben werden soll, ist Integer.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s.

Gibt zurück

UInt64

Eine 64-Bit-ganzzahl ohne Vorzeichen, die der in s.

Implementiert

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Attribute: CLSCompliantAttribute

Gilt für:

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.

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

Parameter

utf8Text: ReadOnlySpan<Byte>

Die Spanne von UTF-8 Zeichen, die analysiert werden sollen.

style: NumberStyles

Eine bitweise Kombination aus Zahlenformatvorlagen, die vorhanden utf8Textsein können.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text.

Gibt zurück

UInt64

Das Ergebnis der Analyse utf8Text.

Implementiert

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Gilt für:

Parse(String, IFormatProvider)

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Decimal.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in das 64-Bit-Äquivalent einer nicht signierten ganzzahligen Zahl.

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

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

[System.CLSCompliant(false)]
public static ulong Parse(string s, IFormatProvider provider);

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

[System.CLSCompliant(false)]
public static ulong Parse(string s, IFormatProvider? provider);

[<System.CLSCompliant(false)>]
static member Parse : string * IFormatProvider -> uint64

static member Parse : string * IFormatProvider -> uint64

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

Parameter

s: String

Eine Zeichenfolge, die die zu konvertierende Zahl darstellt.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s.

Gibt zurück

UInt64

Eine 64-Bit-ganzzahl ohne Vorzeichen, die der in s.

Implementiert

Parse(String, IFormatProvider)

Attribute: CLSCompliantAttribute

Ausnahmen

ArgumentNullException

Der s Parameter ist null.

FormatException

Der s Parameter ist nicht in der richtigen Formatvorlage enthalten.

OverflowException

Der s Parameter stellt eine Zahl kleiner als UInt64.MinValue oder größer als UInt64.MaxValue dar.

Beispiele

Das folgende Beispiel ist der Button Click-Ereignishandler eines Webformulars. Es verwendet das von der HttpRequest.UserLanguages Eigenschaft zurückgegebene Array, um das Gebietsschema des Benutzers zu bestimmen. Anschließend instanziiert es ein CultureInfo Objekt, das diesem Gebietsschema entspricht. Das NumberFormatInfo Objekt, das zu diesem CultureInfo Objekt gehört, wird dann an die Parse(String, IFormatProvider) Methode übergeben, um die Eingabe des Benutzers in einen UInt64 Wert zu konvertieren.

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

Hinweise

Diese Überladung der Methode wird in der Parse(String, IFormatProvider) Regel verwendet, um Text zu konvertieren, der auf unterschiedliche Weise in einen UInt64 Wert formatiert werden kann. Beispielsweise kann er verwendet werden, um den von einem Benutzer eingegebenen Text in ein HTML-Textfeld in einen numerischen Wert zu konvertieren.

Der s Parameter enthält eine Zahl des Formulars:

[ws] [Zeichen]Ziffern[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle werden die einzelnen Elemente beschrieben.

Element	Beschreibung
Ws	Optionaler Leerraum.
Zeichen	Ein optionales positives Zeichen oder ein negatives Zeichen, wenn `s` der Wert Null darstellt.
Ziffern	Eine Sequenz von Ziffern zwischen 0 und 9.

Der s-Parameter wird mithilfe der NumberStyles.Integer Formatvorlage interpretiert. Neben den dezimalen Dezimalstellen des nicht signierten Ganzzahlwerts sind nur führende und nachfolgende Leerzeichen zusammen mit einem vorangestellten Zeichen zulässig. (Wenn das negative Zeichen vorhanden ist, s muss ein Wert von Null angegeben werden, oder die Methode löst eine OverflowException.) Wenn Sie die Formatvorlagenelemente explizit zusammen mit den kulturspezifischen Formatierungsinformationen definieren möchten, die vorhanden ssein können, verwenden Sie die Parse(String, NumberStyles, IFormatProvider) Methode.

Sie können das tatsächliche NumberFormatInfo Objekt übergeben, das Formatierungsinformationen bereitstellt. (Seine Umsetzung der GetFormat einfach zurückgibt.)
Sie können ein CultureInfo Objekt übergeben, das die Kultur angibt, deren Formatierung verwendet werden soll. Die NumberFormat Eigenschaft stellt Formatierungsinformationen bereit.
Sie können eine benutzerdefinierte IFormatProvider Implementierung übergeben. Die GetFormat Methode muss das Objekt instanziieren und zurückgeben, das NumberFormatInfo Formatierungsinformationen bereitstellt.

Wenn provider ja null, wird die NumberFormatInfo für die aktuelle Kultur verwendet.

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Char>, IFormatProvider)

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Analysiert eine Spanne von Zeichen in einen Wert.

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

Parameter

s: ReadOnlySpan<Char>

Die Spanne der zu analysierenden Zeichen.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s.

Gibt zurück

UInt64

Das Ergebnis der Analyse s.

Implementiert

Parse(ReadOnlySpan<Char>, IFormatProvider)

Gilt für:

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.

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

Parameter

utf8Text: ReadOnlySpan<Byte>

Die Spanne von UTF-8 Zeichen, die analysiert werden sollen.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text.

Gibt zurück

UInt64

Das Ergebnis der Analyse utf8Text.

Implementiert

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Gilt für:

Parse(String)

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Decimal.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 64-Bit-Ganzzahlenentsprechung ohne Vorzeichen.

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

[System.CLSCompliant(false)]
public static ulong Parse(string s);

public static ulong Parse(string s);

[<System.CLSCompliant(false)>]
static member Parse : string -> uint64

static member Parse : string -> uint64

Public Shared Function Parse (s As String) As ULong

Parameter

s: String

Eine Zeichenfolge, die die zu konvertierende Zahl darstellt.

Gibt zurück

UInt64

Eine 64-Bit-Ganzzahl ohne Vorzeichen, die der in s.

Attribute: CLSCompliantAttribute

Ausnahmen

ArgumentNullException

Der s Parameter ist null.

FormatException

Der s Parameter weist nicht das richtige Format auf.

OverflowException

Der s Parameter stellt eine Zahl kleiner als UInt64.MinValue oder größer als UInt64.MaxValue dar.

Beispiele

Im folgenden Beispiel wird die Parse Methode verwendet, um ein Array von Zeichenfolgenwerten zu analysieren.

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

Hinweise

Der s Parameter sollte die Zeichenfolgendarstellung einer Zahl in der folgenden Form sein.

[ws][Zeichen]Ziffern[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle werden die einzelnen Elemente beschrieben.

Element	Beschreibung
Ws	Optionaler Leerraum.
Zeichen	Ein optionales Zeichen. Gültige Zeichenzeichen werden durch die NumberFormatInfo.NegativeSign Eigenschaften NumberFormatInfo.PositiveSign der aktuellen Kultur bestimmt. Das Negative Zeichensymbol kann jedoch nur mit Null verwendet werden. andernfalls löst die Methode eine OverflowException.
Ziffern	Eine Sequenz von Ziffern zwischen 0 und 9. Alle führenden Nullen werden ignoriert.

Anmerkung

Die durch den s Parameter angegebene Zeichenfolge wird mithilfe der NumberStyles.Integer Formatvorlage interpretiert. Sie darf keine Gruppentrennzeichen oder Dezimaltrennzeichen enthalten, und sie darf keinen Dezimalteil aufweisen.

Der s Parameter wird mithilfe der Formatierungsinformationen in einem System.Globalization.NumberFormatInfo Objekt analysiert, das für die aktuelle Systemkultur initialisiert wird. Weitere Informationen finden Sie unter NumberFormatInfo.CurrentInfo. Verwenden Sie die Parse(String, IFormatProvider) Methode, um eine Zeichenfolge mithilfe der Formatierungsinformationen einer bestimmten Kultur zu analysieren.

Weitere Informationen

Gilt für:

Parse(String, NumberStyles)

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Quelle:: UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Decimal.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in die 64-Bit-Entsprechung einer nicht signierten ganzzahligen Zahl.

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

[System.CLSCompliant(false)]
public static ulong Parse(string s, System.Globalization.NumberStyles style);

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

[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles -> uint64

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

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

Parameter

s: String

Eine Zeichenfolge, die die zu konvertierende Zahl darstellt. Die Zeichenfolge wird mithilfe der vom style Parameter angegebenen Formatvorlage interpretiert.

style: NumberStyles

Eine bitweise Kombination der Enumerationswerte, die das zulässige Format von s. Ein typischer Wert, der angegeben werden soll, ist Integer.

Gibt zurück

UInt64

Eine 64-Bit-ganzzahl ohne Vorzeichen, die der in s.

Attribute: CLSCompliantAttribute

Ausnahmen

ArgumentNullException

Der s Parameter ist null.

ArgumentException

style ist kein NumberStyles Wert.

-oder-

style ist keine Kombination von AllowHexSpecifier und HexNumber Werten.

FormatException

Der s Parameter ist nicht in einem Format enthalten, das mit styledem Format kompatibel ist.

OverflowException

Der s Parameter stellt eine Zahl kleiner als UInt64.MinValue oder größer als UInt64.MaxValue dar.

-oder-

s enthält Nicht-Null-Dezimalstellen.

Beispiele

Im folgenden Beispiel wird versucht, jedes Element in einem Zeichenfolgenarray mithilfe einer Reihe von NumberStyles Werten zu analysieren.

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

Hinweise

Der style Parameter definiert die Formatvorlagenelemente (z. B. Leerzeichen, positives oder negatives Zeichensymbol, Das Gruppentrennzeichen oder das Dezimalkommasymbol), die im s Parameter zulässig sind, damit der Analysevorgang erfolgreich ausgeführt werden kann. style muss eine Kombination aus Bitkennzeichnungen aus der NumberStyles Enumeration sein. Der style Parameter macht diese Methodenüberladung nützlich, wenn s sie die Zeichenfolgendarstellung eines Hexadezimalwerts enthält, wenn das zahlensystem (Dezimal- oder Hexadezimalwert), das dargestellt s wird, nur zur Laufzeit bekannt ist, oder wenn Sie leerzeichen oder ein Zeichensymbol deaktivieren smöchten.

Je nach Wert kann styleder s Parameter die folgenden Elemente enthalten:

[ws][][$Vorzeichen][Ziffern;]Ziffern[.fractional_digits][E[Zeichen]exponential_digits][ws]

Elemente in eckigen Klammern ([ und ]) sind optional. Wenn style dieser Parameter enthält NumberStyles.AllowHexSpecifier, kann der s Parameter die folgenden Elemente enthalten:

[ws]hexdigits[ws]

In der folgenden Tabelle werden die einzelnen Elemente beschrieben.

Element	Beschreibung
Ws	Optionaler Leerraum. Leerzeichen können am Anfang angezeigt `s` werden, wenn `style` die NumberStyles.AllowLeadingWhite Kennzeichnung enthalten ist, und sie kann am Ende `s` angezeigt werden, wenn `style` die NumberStyles.AllowTrailingWhite Kennzeichnung enthalten ist.
$	Ein kulturspezifisches Währungssymbol. Seine Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyNegativePattern Eigenschaften NumberFormatInfo.CurrencyPositivePattern der aktuellen Kultur definiert. Das Währungssymbol der aktuellen Kultur kann angezeigt werden `s` , wenn `style` die NumberStyles.AllowCurrencySymbol Kennzeichnung enthalten ist.
Zeichen	Ein optionales Zeichen. Das Zeichen kann am Anfang angezeigt `s` werden, wenn `style` das NumberStyles.AllowLeadingSign Kennzeichen enthalten ist, und es kann am Ende der `s` Kennzeichnung angezeigt werden, wenn `style` die NumberStyles.AllowTrailingSign Kennzeichnung enthalten ist. Klammern können verwendet `s` werden, um einen negativen Wert anzugeben, wenn `style` das NumberStyles.AllowParentheses Flag enthalten ist. Das Negative Zeichensymbol kann jedoch nur mit Null verwendet werden. andernfalls löst die Methode eine OverflowException.
Ziffern fractional_digits exponential_digits	Eine Sequenz von Ziffern von 0 bis 9. Für fractional_digits ist nur die Ziffer 0 gültig.
,	Ein kulturspezifisches Gruppentrennzeichen. Das Gruppentrennzeichen der aktuellen Kultur kann angezeigt werden `s` , wenn `style` das NumberStyles.AllowThousands Kennzeichen enthalten ist.
.	Ein kulturspezifisches Dezimalkommasymbol. Das Dezimalkommasymbol der aktuellen Kultur kann angezeigt werden `s` , wenn `style` das NumberStyles.AllowDecimalPoint Kennzeichen enthalten ist. Nur die Ziffer 0 kann als Bruchzahl angezeigt werden, damit der Analysevorgang erfolgreich ausgeführt wird. wenn fractional_digits eine andere Ziffer enthält, wird eine FormatException ausgelöst.
E	Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller (wissenschaftlicher) Schreibweise dargestellt wird. Der `s` Parameter kann eine Zahl in exponentieller Notation darstellen, wenn `style` das NumberStyles.AllowExponent Flag enthalten ist.
hexdigits	Eine Abfolge von hexadezimalen Ziffern von 0 bis f oder 0 bis F.

Anmerkung

Alle endenden NUL-Zeichen s (U+0000) werden unabhängig vom Wert des style Arguments vom Analysevorgang ignoriert.

Eine Zeichenfolge mit Ziffern (die der NumberStyles.None Formatvorlage entspricht) analysiert immer erfolgreich, wenn sie sich im Bereich des UInt64 Typs befindet. Die meisten der verbleibenden NumberStyles Elemente steuern Elemente, die vorhanden sein können, aber nicht vorhanden sein müssen, in der Eingabezeichenfolge. In der folgenden Tabelle wird angegeben, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die möglicherweise svorhanden sind.

`NumberStyles`-Wert	Zusätzlich zu Ziffern zulässige `s` Elemente
None	Nur das Ziffernelement .
AllowDecimalPoint	Das Dezimalkomma (.) und die Dezimalstellenelemente .
AllowExponent	Das Zeichen "e" oder "E", das exponentielle Notation angibt, zusammen mit exponential_digits.
AllowLeadingWhite	Das ws-Element am Anfang von `s`.
AllowTrailingWhite	Das ws-Element am Ende von `s`.
AllowLeadingSign	Das Zeichenelement am Anfang von `s`.
AllowTrailingSign	Das Zeichenelement am Ende von `s`.
AllowParentheses	Das Zeichenelement in Form von Klammern, die den numerischen Wert einschließen.
AllowThousands	Das Gruppentrennzeichen (,) -Element.
AllowCurrencySymbol	Das Currency ($)-Element.
Currency	Alle Elemente. `s` Eine hexadezimale Zahl oder eine Zahl in exponentieller Schreibweise kann jedoch nicht dargestellt werden.
Float	Das ws-Element am Anfang oder Ende von `s`, Zeichen am Anfang von `s`, und das Dezimalkomma (.) Symbol. Der `s` Parameter kann auch exponentielle Notation verwenden.
Number	Die `ws`Elemente , , `sign`Gruppentrennzeichen (,) und Dezimalkomma (.).
Any	Alle Elemente. `s` Eine hexadezimale Zahl kann jedoch nicht dargestellt werden.

Im Gegensatz zu den anderen NumberStyles Werten, die jedoch nicht erforderlich sind, bedeutet der s FormatvorlagenwertNumberStyles.AllowHexSpecifier, dass die einzelnen numerischen Zeichen immer als Hexadezimalzeichen s interpretiert werden. Gültige Hexadezimalzeichen sind 0-9, A-F und a-f. Ein Präfix wie "0x" wird nicht unterstützt und bewirkt, dass der Analysevorgang fehlschlägt. Die einzigen anderen Flags, die mit dem style Parameter kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Aufzählung enthält eine zusammengesetzte Zahlenformatvorlage, NumberStyles.HexNumberdie beide Leerzeichen enthält.)

Anmerkung

Wenn s es sich um die Zeichenfolgendarstellung einer hexadezimalen Zahl handelt, kann keine Dekoration (z 0x . B. oder &h) vorangestellt werden, die sie als hexadezimale Zahl unterscheidet. Dies führt dazu, dass die Konvertierung fehlschlägt.

Der s Parameter wird mithilfe der Formatierungsinformationen in einem NumberFormatInfo Objekt analysiert, das für die aktuelle Systemkultur initialisiert wird. Rufen Sie die Parse(String, NumberStyles, IFormatProvider) Überladung auf, um die Kultur anzugeben, deren Formatierungsinformationen für den Analysevorgang verwendet werden.

Weitere Informationen

Gilt für:

Feedback

War diese Seite hilfreich?

Freigeben über

UInt64.Parse Methode

Definition

Überlädt

Parse(String, NumberStyles, IFormatProvider)

Parameter

Gibt zurück

Implementiert

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parameter

Gibt zurück

Implementiert

Gilt für:

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parameter

Gibt zurück

Implementiert

Gilt für:

Parse(String, IFormatProvider)

Parameter

Gibt zurück

Implementiert

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parameter

Gibt zurück

Implementiert

Gilt für:

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parameter

Gibt zurück

Implementiert

Gilt für:

Parse(String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Parse(String, NumberStyles)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Feedback