Int32.Parse Methode

Definition

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 32-Bit-ganzzahlige Entsprechung.

Überlädt

Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 32-Bit-ganzzahlige Entsprechung.

Parse(ReadOnlySpan<Byte>, IFormatProvider)

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

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analysiert eine Spanne von Zeichen in einen Wert.

Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in die 32-Bit-ganzzahlige Entsprechung mit Vorzeichen.

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die 32-Bit-ganzzahlige Entsprechung mit Vorzeichen.

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

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

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konvertiert die Spandarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das 32-Bit-äquivalente ganzzahlige 32-Bit-Format.

Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in die 32-Bit-ganzzahlige Entsprechung mit Vorzeichen.

Parse(String)

Quelle:
Int32.cs
Quelle:
Int32.cs
Quelle:
Int32.cs

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 32-Bit-ganzzahlige Entsprechung.

public:
 static int Parse(System::String ^ s);
public static int Parse (string s);
static member Parse : string -> int
Public Shared Function Parse (s As String) As Integer

Parameter

s
String

Eine Zeichenfolge, die eine zahl enthält, die konvertiert werden soll.

Gibt zurück

Eine 32-Bit-Ganzzahl, die der zahl entspricht, die in senthalten ist.

Ausnahmen

s ist null.

s ist nicht im richtigen Format vorhanden.

s stellt eine Zahl kleiner als Int32.MinValue oder größer als Int32.MaxValuedar.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie ein Zeichenfolgenwert mithilfe der Int32.Parse(String)-Methode in einen 32-Bit-Ganzzahlwert konvertiert wird. Der resultierende ganzzahlige Wert wird dann in der Konsole angezeigt.

using namespace System;

void main()
{
   array<String^>^ values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                              "0xFA1B", "163042", "-10", "007", "2147483647", 
                              "2147483648", "16e07", "134985.0", "-12034",
                              "-2147483648", "-2147483649" };
   for each (String^ value in values)
   {
      try {
         Int32 number = Int32::Parse(value); 
         Console::WriteLine("{0} --> {1}", value, number);
      }
      catch (FormatException^ e) {
         Console::WriteLine("{0}: Bad Format", value);
      }   
      catch (OverflowException^ e) {
         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 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow
using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                          "0xFA1B", "163042", "-10", "007", "2147483647",
                          "2147483648", "16e07", "134985.0", "-12034",
                          "-2147483648", "-2147483649" };
      foreach (string value in values)
      {
         try {
            int number = Int32.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 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow
open System

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

for value in values do
    try
        let number = Int32.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 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow
Module Example
   Public Sub Main()
      Dim values() As String = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                                 "0xFA1B", "163042", "-10", "007", "2147483647", 
                                 "2147483648", "16e07", "134985.0", "-12034",
                                 "-2147483648", "-2147483649"  }
      For Each value As String In values
         Try
            Dim number As Integer = Int32.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
   End Sub
End Module
' 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 --> -10
'       007 --> 7
'       2147483647 --> 2147483647
'       2147483648: Overflow
'       16e07: Bad Format
'       134985.0: Bad Format
'       -12034 --> -12034
'       -2147483648 --> -2147483648
'       -2147483649: Overflow

Hinweise

Der parameter s 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 Zeichen.
Ziffern Eine Sequenz von Ziffern zwischen 0 und 9.

Der s-Parameter wird mithilfe der NumberStyles.Integer-Formatvorlage interpretiert. Neben Dezimalziffern sind nur führende und nachfolgende Leerzeichen zusammen mit einem vorangestellten Zeichen zulässig. Verwenden Sie zum expliziten Definieren der Formatvorlagenelemente, die in svorhanden sein können, entweder die Int32.Parse(String, NumberStyles) oder die Int32.Parse(String, NumberStyles, IFormatProvider)-Methode.

Der s-Parameter wird mithilfe der Formatierungsinformationen in einem NumberFormatInfo Objekt analysiert, das für die aktuelle Systemkultur initialisiert wurde. Weitere Informationen finden Sie unter CurrentInfo. Um eine Zeichenfolge mithilfe der Formatierungsinformationen einer anderen Kultur zu analysieren, verwenden Sie die Int32.Parse(String, NumberStyles, IFormatProvider)-Methode.

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Quelle:
Int32.cs
Quelle:
Int32.cs

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

public:
 static int Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<int>::Parse;
public static int Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> int
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Integer

Parameter

utf8Text
ReadOnlySpan<Byte>

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

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Textbereitstellt.

Gibt zurück

Das Ergebnis der Analyse utf8Text.

Implementiert

Gilt für:

Parse(ReadOnlySpan<Char>, IFormatProvider)

Quelle:
Int32.cs
Quelle:
Int32.cs
Quelle:
Int32.cs

Analysiert eine Spanne von Zeichen in einen Wert.

public:
 static int Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<int>::Parse;
public static int Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> int
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Integer

Parameter

s
ReadOnlySpan<Char>

Die Spanne der zu analysierenden Zeichen.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt.

Gibt zurück

Das Ergebnis der Analyse s.

Implementiert

Gilt für:

Parse(String, NumberStyles)

Quelle:
Int32.cs
Quelle:
Int32.cs
Quelle:
Int32.cs

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in die 32-Bit-ganzzahlige Entsprechung mit Vorzeichen.

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style);
public static int Parse (string s, System.Globalization.NumberStyles style);
static member Parse : string * System.Globalization.NumberStyles -> int
Public Shared Function Parse (s As String, style As NumberStyles) As Integer

Parameter

s
String

Eine Zeichenfolge, die eine zahl enthält, die konvertiert werden soll.

style
NumberStyles

Eine bitweise Kombination der Enumerationswerte, die die Formatvorlagenelemente angibt, die in svorhanden sein können. Ein typischer Wert, der angegeben werden soll, ist Integer.

Gibt zurück

Eine 32-Bit-Ganzzahl, die der in sangegebenen Zahl entspricht.

Ausnahmen

s ist null.

style ist kein NumberStyles Wert.

-oder-

style ist keine Kombination aus AllowHexSpecifier und HexNumber Werten.

s ist nicht in einem Format vorhanden, das mit stylekompatibel ist.

s stellt eine Zahl kleiner als Int32.MinValue oder größer als Int32.MaxValuedar.

-oder-

s enthält Nicht-Null-Dezimalstellen.

Beispiele

Im folgenden Beispiel wird die Int32.Parse(String, NumberStyles)-Methode verwendet, um die Zeichenfolgendarstellungen mehrerer Int32 Werte zu analysieren. Die aktuelle Kultur für das Beispiel ist en-US.

using namespace System;
using namespace System::Globalization;

public ref class ParseInt32
{
public:
   static void Main()
   {
      Convert("104.0", NumberStyles::AllowDecimalPoint);
      Convert("104.9", NumberStyles::AllowDecimalPoint);
      Convert(" $17,198,064.42", NumberStyles::AllowCurrencySymbol |
                                 NumberStyles::Number);
      Convert("103E06", NumberStyles::AllowExponent);
      Convert("-1,345,791", NumberStyles::AllowThousands);
      Convert("(1,345,791)", NumberStyles::AllowThousands |
                             NumberStyles::AllowParentheses);
   }

private:
   static void Convert(String^ value, NumberStyles style)
   {
      try
      {
         int number = Int32::Parse(value, style);
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException^)
      {
         Console::WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException^)
      {
         Console::WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
};

int main()
{
    ParseInt32::Main();
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.
using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("104.0", NumberStyles.AllowDecimalPoint);
      Convert("104.9", NumberStyles.AllowDecimalPoint);
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol |
                                 NumberStyles.Number);
      Convert("103E06", NumberStyles.AllowExponent);
      Convert("-1,345,791", NumberStyles.AllowThousands);
      Convert("(1,345,791)", NumberStyles.AllowThousands |
                             NumberStyles.AllowParentheses);
   }

   private static void Convert(string value, NumberStyles style)
   {
      try
      {
         int number = Int32.Parse(value, style);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.
open System
open System.Globalization

let convert value (style: NumberStyles) =
    try
        let number = Int32.Parse(value, style)
        printfn $"Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int32 type."

convert "104.0" NumberStyles.AllowDecimalPoint
convert "104.9" NumberStyles.AllowDecimalPoint
convert " $17,198,064.42" (NumberStyles.AllowCurrencySymbol ||| NumberStyles.Number)
convert "103E06" NumberStyles.AllowExponent
convert "-1,345,791" NumberStyles.AllowThousands
convert "(1,345,791)" (NumberStyles.AllowThousands ||| NumberStyles.AllowParentheses)


// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.
Imports System.Globalization

Module ParseInt32
   Public Sub Main()
      Convert("104.0", NumberStyles.AllowDecimalPoint)    
      Convert("104.9", NumberStyles.AllowDecimalPoint)
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol Or _
                                 NumberStyles.Number)
      Convert("103E06", NumberStyles.AllowExponent)  
      Convert("-1,345,791", NumberStyles.AllowThousands)
      Convert("(1,345,791)", NumberStyles.AllowThousands Or _
                             NumberStyles.AllowParentheses)
   End Sub
   
   Private Sub Convert(value As String, style As NumberStyles)
      Try
         Dim number As Integer = Int32.Parse(value, style)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value)   
      End Try
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '104.0' to 104.
'       '104.9' is out of range of the Int32 type.
'       ' $17,198,064.42' is out of range of the Int32 type.
'       Converted '103E06' to 103000000.
'       Unable to convert '-1,345,791'.
'       Converted '(1,345,791)' to -1345791.

Hinweise

Der style-Parameter definiert die Formatvorlagenelemente (z. B. Leerzeichen, positives oder negatives Zeichensymbol oder das Tausendertrennzeichen), die im parameter s zulässig sind, damit der Analysevorgang erfolgreich ausgeführt werden kann. Es muss sich um eine Kombination aus Bitkennzeichnungen aus der NumberStyles Enumeration sein. Abhängig vom Wert von stylekann der s Parameter die folgenden Elemente enthalten:

[ws] [$] [Zeichen] [Ziffern;]Ziffern[.fractional_digits][e[Zeichen]exponential_digits][ws]

Oder, wenn styleAllowHexSpecifierenthält:

[ws]hexdigits[ws]

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

Element Beschreibung
ws Optionaler Leerraum. Leerzeichen können am Anfang s angezeigt werden, wenn style das NumberStyles.AllowLeadingWhite Flag enthält, und es kann am Ende der s angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag enthält.
$ Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die eigenschaften NumberFormatInfo.CurrencyNegativePattern 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.
signieren Ein optionales Zeichen. Das Zeichen kann am Anfang der s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann am Ende 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 enthält.
Ziffern

fractional_digits

exponential_digits
Eine Sequenz von Ziffern von 0 bis 9. Bei fractional_digitsist nur die Ziffer 0 gültig.
, Ein kulturspezifisches Tausendertrennzeichen. Das Tausendertrennzeichen der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowThousands Flag enthält.
. Ein kulturspezifisches Dezimalkommasymbol. Das Dezimalkommasymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält. 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 ein OverflowException ausgelöst.
e Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller Schreibweise dargestellt wird. Der s-Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthält.
hexdigits Eine Abfolge von hexadezimalen Ziffern von 0 bis f oder 0 bis F.

Anmerkung

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

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

NumberStyles-Wert Elemente, die zusätzlich zu Ziffern in s zulässig sind
None Nur die Ziffern Element.
AllowDecimalPoint Dezimalkomma ( . ) und Dezimalstellen Elemente.
AllowExponent Der parameter s kann auch exponentielle Notation verwenden.
AllowLeadingWhite Das ws-Element am Anfang s.
AllowTrailingWhite Das ws-Element am Ende s.
AllowLeadingSign Das signieren Element am Anfang s.
AllowTrailingSign Das signieren Element am Ende s.
AllowParentheses Das Zeichen Element in Form von Klammern, die den numerischen Wert einschließen.
AllowThousands Das Tausendertrennzeichen ( , ) -Element.
AllowCurrencySymbol Das $-Element.
Currency Alle. Der parameter s kann keine hexadezimale Zahl oder eine Zahl in exponentieller Schreibweise darstellen.
Float Das ws-Element am Anfang oder Ende s, Zeichen am Anfang sund das Dezimalkomma ( . ) Symbol. Der parameter s kann auch exponentielle Notation verwenden.
Number Die Elemente ws, sign, Tausendertrennzeichen ( , ) und Dezimalkomma ( . ) Elemente.
Any Alle Formatvorlagen, mit Ausnahme von s, können keine hexadezimale Zahl darstellen.

Wenn das NumberStyles.AllowHexSpecifier-Flag verwendet wird, muss s ein Hexadezimalwert ohne Präfix sein. Beispielsweise analysiert "C9AF3" erfolgreich, aber "0xC9AF3" nicht. Die einzigen anderen Flags, die mit dem s-Parameter kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles-Aufzählung enthält eine zusammengesetzte Zahlenformatvorlage, NumberStyles.HexNumber, die beide Leerzeichen-Flags enthält.)

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

Weitere Informationen

Gilt für:

Parse(String, IFormatProvider)

Quelle:
Int32.cs
Quelle:
Int32.cs
Quelle:
Int32.cs

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die 32-Bit-ganzzahlige Entsprechung mit Vorzeichen.

public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<int>::Parse;
public static int Parse (string s, IFormatProvider provider);
public static int Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> int
Public Shared Function Parse (s As String, provider As IFormatProvider) As Integer

Parameter

s
String

Eine Zeichenfolge, die eine zahl enthält, die konvertiert werden soll.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt.

Gibt zurück

Eine 32-Bit-Ganzzahl, die der in sangegebenen Zahl entspricht.

Implementiert

Ausnahmen

s ist null.

s ist nicht das richtige Format.

s stellt eine Zahl kleiner als Int32.MinValue oder größer als Int32.MaxValuedar.

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 Int32 Wert zu konvertieren.

protected void OkToInteger_Click(object sender, EventArgs e)
{
    string locale;
    int 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 = Int32.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 OkToInteger_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToInteger.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Integer

   ' 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 = Int32.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As Exception
      Exit Sub
   End Try

   ' Output number to label on web form
   Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

Hinweise

Diese Überladung der Parse(String, IFormatProvider)-Methode wird in der Regel verwendet, um Text zu konvertieren, der auf unterschiedliche Weise in einen Int32 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 parameter s 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.
signieren Ein optionales Zeichen.
Ziffern Eine Sequenz von Ziffern zwischen 0 und 9.

Der s-Parameter wird mithilfe der NumberStyles.Integer-Formatvorlage interpretiert. Neben Dezimalziffern sind nur führende und nachfolgende Leerzeichen zusammen mit einem vorangestellten Zeichen zulässig. Um explizit die Formatvorlagenelemente zu definieren, die in svorhanden sein können, verwenden Sie die Int32.Parse(String, NumberStyles, IFormatProvider)-Methode.

Der provider-Parameter ist eine IFormatProvider Implementierung, z. B. ein NumberFormatInfo- oder CultureInfo-Objekt. Der provider Parameter liefert kulturspezifische Informationen zum Format der s. Wenn providernullist, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Quelle:
Int32.cs
Quelle:
Int32.cs

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

public static int Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Integer

Parameter

utf8Text
ReadOnlySpan<Byte>

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

style
NumberStyles

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

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Textbereitstellt.

Gibt zurück

Das Ergebnis der Analyse utf8Text.

Implementiert

Gilt für:

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Quelle:
Int32.cs
Quelle:
Int32.cs
Quelle:
Int32.cs

Konvertiert die Spandarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das 32-Bit-äquivalente ganzzahlige 32-Bit-Format.

public static int Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
public static int Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Integer

Parameter

s
ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die die zu konvertierende Zahl darstellen.

style
NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Formatvorlagenelemente angibt, die in svorhanden sein können. Ein typischer Wert, der angegeben werden soll, ist Integer.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Informationen zum Format von sbereitstellt.

Gibt zurück

Eine 32-Bit-Ganzzahl, die der in sangegebenen Zahl entspricht.

Implementiert

Gilt für:

Parse(String, NumberStyles, IFormatProvider)

Quelle:
Int32.cs
Quelle:
Int32.cs
Quelle:
Int32.cs

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in die 32-Bit-ganzzahlige Entsprechung mit Vorzeichen.

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<int>::Parse;
public static int Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static int Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Integer

Parameter

s
String

Eine Zeichenfolge, die eine zahl enthält, die konvertiert werden soll.

style
NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Formatvorlagenelemente angibt, die in svorhanden sein können. Ein typischer Wert, der angegeben werden soll, ist Integer.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Informationen zum Format von sbereitstellt.

Gibt zurück

Eine 32-Bit-Ganzzahl, die der in sangegebenen Zahl entspricht.

Implementiert

Ausnahmen

s ist null.

style ist kein NumberStyles Wert.

-oder-

style ist keine Kombination aus AllowHexSpecifier und HexNumber Werten.

s ist nicht in einem Format vorhanden, das mit stylekompatibel ist.

s stellt eine Zahl kleiner als Int32.MinValue oder größer als Int32.MaxValuedar.

-oder-

s enthält Nicht-Null-Dezimalstellen.

Beispiele

Im folgenden Beispiel wird eine Vielzahl von style und provider Parameter verwendet, um die Zeichenfolgendarstellungen von Int32 Werten zu analysieren. Außerdem werden einige der verschiedenen Möglichkeiten veranschaulicht, wie dieselbe Zeichenfolge je nach Kultur interpretiert werden kann, deren Formatierungsinformationen für den Analysevorgang verwendet werden.

using namespace System;
using namespace System::Globalization;

public ref class ParseInt32
{
public:
   static void Main()
   {
      Convert("12,000", NumberStyles::Float | NumberStyles::AllowThousands, 
              gcnew CultureInfo("en-GB"));
      Convert("12,000", NumberStyles::Float | NumberStyles::AllowThousands,
              gcnew CultureInfo("fr-FR"));
      Convert("12,000", NumberStyles::Float, gcnew CultureInfo("en-US"));

      Convert("12 425,00", NumberStyles::Float | NumberStyles::AllowThousands,
              gcnew CultureInfo("sv-SE"));
      Convert("12,425.00", NumberStyles::Float | NumberStyles::AllowThousands,
              NumberFormatInfo::InvariantInfo);
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowDecimalPoint, 
              gcnew CultureInfo("fr-FR"));
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowDecimalPoint,
              gcnew CultureInfo("en-US"));
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowThousands,
              gcnew CultureInfo("en-US"));
   }

private:
   static void Convert(String^ value, NumberStyles style,
                               IFormatProvider^ provider)
   {
      try
      {
         int number = Int32::Parse(value, style, provider);
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException^)
      {
         Console::WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException^)
      {
         Console::WriteLine("'{0}' is out of range of the Int32 type.", value);   
      }
   }                               
};

int main()
{
    ParseInt32::Main();
}
// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.
using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("en-GB"));
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("fr-FR"));
      Convert("12,000", NumberStyles.Float, new CultureInfo("en-US"));

      Convert("12 425,00", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("sv-SE"));
      Convert("12,425.00", NumberStyles.Float | NumberStyles.AllowThousands,
              NumberFormatInfo.InvariantInfo);
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("fr-FR"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("en-US"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowThousands,
              new CultureInfo("en-US"));
   }

   private static void Convert(string value, NumberStyles style,
                               IFormatProvider provider)
   {
      try
      {
         int number = Int32.Parse(value, style, provider);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
}
// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.
open System
open System.Globalization

let convert (value: string) (style: NumberStyles) (provider: IFormatProvider) =
    try
        let number = Int32.Parse(value, style, provider)
        printfn $"Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int32 type."

convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "en-GB")
convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "fr-FR")
convert "12,000" NumberStyles.Float (CultureInfo "en-US")
convert "12 425,00" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "sv-SE")
convert "12,425.00" (NumberStyles.Float ||| NumberStyles.AllowThousands) NumberFormatInfo.InvariantInfo
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "fr-FR")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "en-US")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowThousands) (CultureInfo "en-US")

// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.
Imports System.Globalization

Module ParseInt32
   Public Sub Main()
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("en-GB"))      
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("fr-FR"))
      Convert("12,000", NumberStyles.Float, New CultureInfo("en-US"))
      
      Convert("12 425,00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("sv-SE")) 
      Convert("12,425.00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              NumberFormatInfo.InvariantInfo) 
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _ 
              New CultureInfo("fr-FR"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _
              New CultureInfo("en-US"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowThousands, _
              New CultureInfo("en-US"))
   End Sub

   Private Sub Convert(value As String, style As NumberStyles, _
                       provider As IFormatProvider)
      Try
         Dim number As Integer = Int32.Parse(value, style, provider)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value)   
      End Try
   End Sub                       
End Module
' This example displays the following output to the console:
'       Converted '12,000' to 12000.
'       Converted '12,000' to 12.
'       Unable to convert '12,000'.
'       Converted '12 425,00' to 12425.
'       Converted '12,425.00' to 12425.
'       '631,900' is out of range of the Int32 type.
'       Unable to convert '631,900'.
'       Converted '631,900' to 631900.

Hinweise

Der style-Parameter definiert die Formatvorlagenelemente (z. B. Leerzeichen oder positives Vorzeichen), die im parameter s zulässig sind, damit der Analysevorgang erfolgreich ausgeführt werden kann. Es muss sich um eine Kombination aus Bitkennzeichnungen aus der NumberStyles Enumeration sein. Abhängig vom Wert von stylekann der s Parameter die folgenden Elemente enthalten:

[ws] [$] [Zeichen] [Ziffern;]Ziffern[.fractional_digist][e[Zeichen]exponential_digits][ws]

Oder, wenn styleAllowHexSpecifierenthält:

[ws]hexdigits[ws]

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

Element Beschreibung
ws Optionaler Leerraum. Leerzeichen können am Anfang s angezeigt werden, wenn style das NumberStyles.AllowLeadingWhite Flag enthält, und es kann am Ende der s angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag enthält.
$ Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die NumberFormatInfo.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 enthält.
signieren Ein optionales Zeichen. Das Zeichen kann am Anfang s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag oder am Ende der s enthält, 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 enthält.
Ziffern

fractional_digits

exponential_digits
Eine Sequenz von Ziffern von 0 bis 9. Bei fractional_digitsist nur die Ziffer 0 gültig.
, Ein kulturspezifisches Tausendertrennzeichen. Das Tausendertrennzeichen der durch provider angegebenen Kultur kann in s angezeigt werden, wenn style die NumberStyles.AllowThousands-Kennzeichnung enthält.
. Ein kulturspezifisches Dezimalkommasymbol. Das Dezimalkommasymbol der durch provider angegebenen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält.

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 ein OverflowException ausgelöst.
e Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller Schreibweise dargestellt wird. Der s-Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthält.
hexdigits Eine Abfolge von hexadezimalen Ziffern von 0 bis f oder 0 bis F.

Anmerkung

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

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

Nicht zusammengesetzte NumberStyles-Werte Elemente, die zusätzlich zu Ziffern in s zulässig sind
NumberStyles.None Nur Dezimalziffern.
NumberStyles.AllowDecimalPoint Dezimalkomma ( . ) und Dezimalstellen Elemente. Bruchziffern darf jedoch nur aus einer oder mehreren 0 Ziffern bestehen, oder ein OverflowException wird ausgelöst.
NumberStyles.AllowExponent Der parameter s kann auch exponentielle Notation verwenden. Wenn s eine Zahl in exponentieller Schreibweise darstellt, muss sie eine ganze Zahl innerhalb des Bereichs des datentyps Int32 ohne eine Nicht-Null-Bruchkomponente darstellen.
NumberStyles.AllowLeadingWhite Das ws-Element am Anfang s.
NumberStyles.AllowTrailingWhite Das ws-Element am Ende s.
NumberStyles.AllowLeadingSign Ein positives Zeichen kann vor Ziffernangezeigt werden.
NumberStyles.AllowTrailingSign Ein positives Zeichen kann nach Ziffernangezeigt werden.
NumberStyles.AllowParentheses Das Zeichen Element in Form von Klammern, die den numerischen Wert einschließen.
NumberStyles.AllowThousands Das Tausendertrennzeichen ( , ) -Element.
NumberStyles.AllowCurrencySymbol Das $-Element.

Wenn das NumberStyles.AllowHexSpecifier-Flag verwendet wird, muss s ein Hexadezimalwert ohne Präfix sein. Beispielsweise analysiert "C9AF3" erfolgreich, aber "0xC9AF3" nicht. Die einzigen anderen Kennzeichen, die in style vorhanden sein können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles-Aufzählung weist eine zusammengesetzte Zahlenformatvorlage auf, NumberStyles.HexNumber, die beide Leerzeichen enthält.)

Der provider-Parameter ist eine IFormatProvider Implementierung, z. B. ein NumberFormatInfo- oder CultureInfo-Objekt. Der parameter provider liefert kulturspezifische Informationen, die bei der Analyse verwendet werden. Wenn providernullist, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

Gilt für: