UInt64.Parse Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

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

Überlädt

Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende 64-Bit-Ganzzahl ohne Vorzeichen.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende 64-Bit-Ganzzahl ohne Vorzeichen.
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 die entsprechende ganze 64-Bit-Zahl ohne Vorzeichen.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende 64-Bit-Ganzzahl ohne Vorzeichen.
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 entsprechende ganze 64-Bit-Zahl ohne Vorzeichen.

Parse(String, NumberStyles, IFormatProvider)

Source:

UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Decimal.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende 64-Bit-Ganzzahl ohne Vorzeichen.

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

Parameter

s

String

Eine Zeichenfolge, die die zu konvertierende Zahl darstellt. Die Zeichenfolge wird unter Verwendung des durch den style-Parameter angegebenen Stils interpretiert.

style

NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente angeben, die in s vorhanden sein können. Ein häufig angegebener Wert ist Integer.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

Gibt zurück

UInt64

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

Implementiert

Parse(String, NumberStyles, IFormatProvider)

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 weist kein mit style kompatibles Format auf.

OverflowException

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

- oder -

s enthält Dezimalstellen ungleich 0 (null).

Beispiele

Im folgenden Beispiel wird die Parse(String, NumberStyles, IFormatProvider) -Methode verwendet, um verschiedene Zeichenfolgendarstellungen von Zahlen in 64-Bit-Ganzzahlwerte 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 Stilelemente (z. B. Leerzeichen oder positives oder negatives Zeichensymbol), die s im Parameter zulässig sind, damit der Analysevorgang erfolgreich ausgeführt werden kann. Es muss sich um eine Kombination von Bitflags aus der NumberStyles Enumeration handeln.

Abhängig vom Wert von stylekann der s Parameter die folgenden Elemente enthalten:

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

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

[ws] hexdigits[ws]

In der folgenden Tabelle wird jedes Element beschrieben.

Element	Beschreibung
ws	Optionaler Leerraum. Leerzeichen können am Anfang von s angezeigt werden, wenn style das NumberStyles.AllowLeadingWhite Flag enthalten ist, und sie kann am Ende s von angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag eingeschlossen ist.
$	Ein kulturspezifisches Währungssymbol. Seine 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 in s angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthalten ist.
sign	Ein optionales Zeichen. (Die -Methode löst ein aus OverflowException , wenn s ein negatives Vorzeichen enthält und eine Nicht-Null-Zahl darstellt.) Das Zeichen kann am Anfang von s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann das Ende von s angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthält. Klammern können in s verwendet werden, um einen negativen Wert anzugeben, wenn style das NumberStyles.AllowParentheses Flag enthalten ist.
Zahlen	Eine Sequenz von Ziffern von 0 bis 9.
.	Ein kulturspezifisches Dezimalzeichensymbol. Das Dezimalstellensymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthalten ist.
fractional_digits	Ein oder mehrere Vorkommen der Ziffer 0-9, wenn style das NumberStyles.AllowExponent Flag enthalten ist, oder mindestens ein Vorkommen der Ziffer 0, wenn dies nicht der Fall ist. Bruchstellen können nur in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthalten ist.
E	Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller (wissenschaftlicher) Notation 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 Sequenz von Hexadezimalstellen von 0 bis f oder 0 bis F.

Hinweis

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

Eine Zeichenfolge nur mit Dezimalstellen (die dem NumberStyles.None Format entspricht) analysiert immer erfolgreich. Die meisten der verbleibenden NumberStyles Member-Steuerelementelemente, die möglicherweise vorhanden sind, aber nicht erforderlich sind, um in dieser Eingabezeichenfolge vorhanden zu sein. Die folgende Tabelle gibt an, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die möglicherweise in svorhanden sind.

Nicht zusammengesetzte NumberStyles Werte	Zusätzlich zu Ziffern zulässige s Elemente
NumberStyles.None	Nur Dezimalstellen.
NumberStyles.AllowDecimalPoint	Das Dezimalzeichen (.) und fractional_digits Elemente. Wenn die Formatvorlage jedoch das NumberStyles.AllowExponent Flag nicht enthält, darf fractional_digits nur aus einer oder mehreren 0 Ziffern bestehen, andernfalls wird ein OverflowException ausgelöst.
NumberStyles.AllowExponent	Das Zeichen "e" oder "E", das die 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 Zeichen 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 führt dazu, dass der Analysevorgang fehlschlägt. Die einzigen anderen Flags, die damit kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Enumeration enthält eine zusammengesetzte Zahlenart, NumberStyles.HexNumber, die beide Leerzeichenflags enthält.)

Hinweis

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

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

• Sie können das tatsächliche NumberFormatInfo Objekt übergeben, das Formatierungsinformationen bereitstellt. (Seine Implementierung von GetFormat gibt sich einfach selbst zurück.)

• 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 ist null, wird das NumberFormatInfo -Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

• ToString
• Analysieren numerischer Zeichenfolgen in .NET

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:

UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende 64-Bit-Ganzzahl ohne Vorzeichen.

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

Parameter

s

ReadOnlySpan<Char>

Eine Zeichenspanne, die die zu konvertierende Zahl darstellt Die Zeichenspanne wird unter Verwendung des durch den style-Parameter angegebenen Stils interpretiert.

style

NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente angeben, die in s vorhanden sein können. Ein häufig angegebener Wert ist Integer.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

Gibt zurück

UInt64

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

Implementiert

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:

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 der zu analysierenden UTF-8-Zeichen.

style

NumberStyles

Eine bitweise Kombination von Zahlenformatvorlagen, die in utf8Textvorhanden sein können.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text bereitstellt.

Gibt zurück

UInt64

Das Ergebnis der Analyse utf8Textvon .

Implementiert

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Source:

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 die entsprechende ganze 64-Bit-Zahl ohne Vorzeichen.

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

Parameter

s

String

Eine Zeichenfolge, die die zu konvertierende Zahl darstellt.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

Gibt zurück

UInt64

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

Implementiert

Parse(String, IFormatProvider)

Ausnahmen

ArgumentNullException

Der s-Parameter ist null.

FormatException

Der s-Parameter hat nicht das richtige Format.

OverflowException

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

Beispiele

Das folgende Beispiel ist der Schaltflächen-Klickereignishandler eines Webformulars. Es verwendet das von der HttpRequest.UserLanguages -Eigenschaft zurückgegebene Array, um das Gebietsschema des Benutzers zu bestimmen. Anschließend instanziiert er 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, der auf verschiedene Arten formatiert werden kann, in einen UInt64 Wert zu konvertieren. Sie kann beispielsweise 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 Nummer des Formulars:

[ws] [Sign]digits[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle wird jedes Element beschrieben.

Element	Beschreibung
ws	Optionaler Leerraum.
sign	Ein optionales positives Zeichen oder ein negatives Zeichen, wenn s den Wert 0 (null) darstellt.
Zahlen	Eine Sequenz von Ziffern im Bereich von 0 bis 9.

Der s-Parameter wird mithilfe des Stils NumberStyles.Integer interpretiert. Zusätzlich zu den Dezimalstellen des Ganzzahlwerts ohne Vorzeichen sind nur führende und nachfolgende Leerzeichen zusammen mit einem führenden Zeichen zulässig. (Wenn das negative Vorzeichen vorhanden ist, s muss den Wert 0 (null) darstellen, oder die -Methode löst einen ausOverflowException.) Verwenden Sie die -Methode, um die Stilelemente explizit zusammen mit den kulturspezifischen Formatierungsinformationen zu definieren, die Parse(String, NumberStyles, IFormatProvider) in svorhanden sein können.

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

• Sie können das tatsächliche NumberFormatInfo Objekt übergeben, das Formatierungsinformationen bereitstellt. (Seine Implementierung von GetFormat gibt sich einfach selbst zurück.)

• 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 ist null, wird für NumberFormatInfo die aktuelle Kultur verwendet.

Weitere Informationen

• ToString()
• TryParse
• Analysieren numerischer Zeichenfolgen in .NET

Parse(String, NumberStyles)

Source:

UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Decimal.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende 64-Bit-Ganzzahl ohne Vorzeichen.

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

Parameter

s

String

Eine Zeichenfolge, die die zu konvertierende Zahl darstellt. Die Zeichenfolge wird unter Verwendung des durch den style-Parameter angegebenen Stils interpretiert.

style

NumberStyles

Eine bitweise Kombination der Enumerationswerte, die das zulässige Format von s angeben. Ein häufig angegebener Wert ist Integer.

Gibt zurück

UInt64

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

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 weist kein mit style kompatibles Format auf.

OverflowException

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

- oder -

s enthält Dezimalstellen ungleich 0 (null).

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 Stilelemente (z. B. Leerzeichen, positives oder negatives Vorzeichen, Gruppentrennzeichensymbol oder Dezimaltrennzeichen), die im s Parameter zulässig sind, damit der Analysevorgang erfolgreich ist. style muss eine Kombination von Bitflags aus der NumberStyles Enumeration sein. Der style -Parameter macht diese Methodenüberladung nützlich, wenn s die Zeichenfolgendarstellung eines Hexadezimalwerts enthält, wenn das Zahlensystem (dezimal oder hexadezimal) nur s zur Laufzeit bekannt ist oder wenn Sie Leerzeichen oder ein Zeichensymbol in snicht zulassen möchten.

Abhängig vom Wert von stylekann der s Parameter die folgenden Elemente enthalten:

[ws] [$][Zeichen][Ziffern,]Ziffern[.fractional_digits][E[sign]exponential_digits][ws]

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

[ws] hexdigits[ws]

In der folgenden Tabelle wird jedes Element beschrieben.

Element	Beschreibung
ws	Optionaler Leerraum. Leerzeichen können am Anfang von s angezeigt werden, wenn style das NumberStyles.AllowLeadingWhite Flag enthalten ist, und es kann am Ende von s angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag enthält.
$	Ein kulturspezifisches Währungssymbol. Seine Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyNegativePattern Eigenschaften und NumberFormatInfo.CurrencyPositivePattern der aktuellen Kultur definiert. Das Währungssymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthält.
sign	Ein optionales Zeichen. Das Zeichen kann am Anfang von s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann am Ende von s angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthält. Klammern können in s verwendet werden, um einen negativen Wert anzugeben, wenn style das NumberStyles.AllowParentheses Flag enthalten ist. Das negative Vorzeichensymbol kann jedoch nur mit 0 (null) verwendet werden. Andernfalls löst die -Methode eine aus OverflowException.
Zahlen 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 Gruppentrennzeichensymbol. Das Gruppentrennzeichen der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowThousands Flag enthält.
.	Ein kulturspezifisches Dezimaltrennzeichen. Das Dezimalzeichensymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält. Nur die Ziffer 0 kann als Bruchziffer angezeigt werden, damit der Analysevorgang erfolgreich ist. 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) Notation dargestellt wird. Der s Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthalten ist.
hexdigits	Eine Sequenz von Hexadezimalstellen von 0 bis f oder 0 bis F.

Hinweis

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

Eine Zeichenfolge nur 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 Member steuern Elemente, die in der Eingabezeichenfolge möglicherweise vorhanden sind, aber nicht vorhanden sein müssen. Die folgende Tabelle gibt an, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die in svorhanden sein können.

Wert vom Typ NumberStyles	Zusätzlich zu Ziffern zulässige s Elemente
None	Nur das Digits-Element .
AllowDecimalPoint	Das Dezimaltrennzeichen (.) und die Bruchstellenelemente .
AllowExponent	Das Zeichen "e" oder "E", das die 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 Währungselement ($).
Currency	Alle Elemente. Kann jedoch s keine hexadezimale Zahl oder eine Zahl in exponentieller Notation darstellen.
Float	Das ws-Element am Anfang oder Ende von s, signieren am Anfang von sund das Dezimaltrennzeichen (.). Der s Parameter kann auch exponentielle Notation verwenden.
Number	Die wsElemente , , signGruppierungstrennzeichen (,) und Dezimalstellen (.).
Any	Alle Elemente. Kann jedoch s keine Hexadezimalzahl darstellen.

Im Gegensatz zu den anderen NumberStyles Werten, die bestimmte Stilelemente in szulassen, aber nicht erfordern, bedeutet der NumberStyles.AllowHexSpecifier Formatvorlagenwert, dass die einzelnen numerischen Zeichen in s immer als Hexadezimalzeichen interpretiert werden. Gültige Hexadezimalzeichen sind 0-9, A-F und a-f. Ein Präfix wie "0x" wird nicht unterstützt und führt dazu, 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 Enumeration enthält eine zusammengesetzte Zahlenformatvorlage, NumberStyles.HexNumber, die beide Leerzeichenflags enthält.)

Hinweis

Wenn s die Zeichenfolgendarstellung einer Hexadezimalzahl ist, kann ihr 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 -Überladung auf, um die Kultur anzugeben, deren Formatierungsinformationen für den Parse(String, NumberStyles, IFormatProvider) Analysevorgang verwendet werden.

Weitere Informationen

• ToString
• TryParse
• Analysieren numerischer Zeichenfolgen in .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:

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 bereitstellt.

Gibt zurück

UInt64

Das Ergebnis der Analyse svon .

Implementiert

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:

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 der zu analysierenden UTF-8-Zeichen.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text bereitstellt.

Gibt zurück

UInt64

Das Ergebnis der Analyse utf8Textvon .

Implementiert

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String)

Source:

UInt64.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Decimal.Parse(String)

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

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

Parameter

s

String

Eine Zeichenfolge, die die zu konvertierende Zahl darstellt.

Gibt zurück

UInt64

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

Ausnahmen

ArgumentNullException

Der s-Parameter ist null.

FormatException

Der s-Parameter hat nicht das richtige Format.

OverflowException

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

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 im folgenden Format sein.

[ws] [sign] digits[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle wird jedes Element beschrieben.

Element	Beschreibung
ws	Optionaler Leerraum.
sign	Ein optionales Zeichen. Gültige Vorzeichen werden durch die NumberFormatInfo.NegativeSign Eigenschaften und NumberFormatInfo.PositiveSign der aktuellen Kultur bestimmt. Das negative Vorzeichensymbol kann jedoch nur mit 0 (null) verwendet werden. Andernfalls löst die -Methode eine aus OverflowException.
Zahlen	Eine Sequenz von Ziffern im Bereich von 0 bis 9. Alle führenden Nullen werden ignoriert.

Hinweis

Die durch den s -Parameter angegebene Zeichenfolge wird mithilfe des Stils NumberStyles.Integer interpretiert. Sie kann keine Gruppentrennzeichen oder Dezimaltrennzeichen enthalten und keinen Dezimalteil haben.

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 Parse(String, IFormatProvider) Sie die -Methode, um eine Zeichenfolge mithilfe der Formatierungsinformationen einer bestimmten Kultur zu analysieren.

Weitere Informationen

• ToString
• Analysieren numerischer Zeichenfolgen in .NET