Int32.Parse Methode

Definition

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.

Überlädt

Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.

Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.

Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.

Parse(String, IFormatProvider)

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

Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
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 die zu konvertierende Zahl enthält.

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 Informationen zum Format von s bereitstellt.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen, die der Zahl in s entspricht.

Ausnahmen

s ist null.

style ist kein NumberStyles-Wert.

- oder - style ist keine Kombination von AllowHexSpecifier- und HexNumber-Werten.

s weist kein mit style kompatibles Format auf.

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

- oder - s enthält Dezimalstellen ungleich 0 (null).

Beispiele

Im folgenden Beispiel werden eine Vielzahl von - und style provider -Parametern verwendet, um die Zeichenfolgendarstellungen von Werten zu Int32 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 Stilelemente (z. B. Leerzeichen oder das positive Vorzeichen), die im -Parameter zulässig sind, s damit der Analysevorgang erfolgreich ist. Dabei muss es sich um eine Kombination aus Bitflags aus der NumberStyles -Enumeration handeln. Abhängig vom Wert von style kann der Parameter die folgenden Elemente s enthalten:

[ws] [$] [Signieren] [digits,]digits[.fractional_digist][e[sign]exponential_digits][ws]

Oder, wenn style AllowHexSpecifier enthält:

[ws]hexdigits[ws]

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

Element BESCHREIBUNG
ws Optionaler Leerraum. Leerraum kann am Anfang von angezeigt s werden, wenn style das Flag NumberStyles.AllowLeadingWhite einschließt, und es kann am Ende von angezeigt s werden, wenn style das Flag NumberStyles.AllowTrailingWhite einschließt.
$ Ein kulturspezifisches Währungssymbol. Ihre Position in der Zeichenfolge wird durch die -Eigenschaft des -Objekts definiert, NumberFormatInfo.CurrencyPositivePattern das von der NumberFormatInfo GetFormat -Methode des -Parameters zurückgegeben provider wird. Das Währungssymbol kann in angezeigt s werden, wenn style das Flag NumberStyles.AllowCurrencySymbol enthält.
sign Ein optionales Zeichen. Das Zeichen kann am Anfang von angezeigt s werden, wenn style das Flag NumberStyles.AllowLeadingSign enthält, oder am Ende von , s wenn das Flag style NumberStyles.AllowTrailingSign enthält. Klammern können in verwendet s werden, um einen negativen Wert anzugeben, wenn style das Flag NumberStyles.AllowParentheses enthält.
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 Tausendertrennzeichen. Das Tausendertrennzeichen der von angegebenen Kultur provider kann in angezeigt s werden, wenn das Flag style NumberStyles.AllowThousands enthält.
. Ein kulturspezifisches Dezimaltrennzeichen. Das Dezimaltrennzeichen der von angegebenen Kultur provider kann in angezeigt s werden, wenn das style 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, OverflowException wird eine ausgelöst.
e Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller Notation dargestellt wird. Der s -Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent -Flag enthält.
hexdigits Eine Sequenz von Hexadezimalziffern von 0 bis f oder 0 bis F.

Hinweis

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

Eine Zeichenfolge nur mit Dezimalstellen (die dem Stil entspricht) wird immer erfolgreich analysiert, wenn sie sich im Bereich NumberStyles.None des Typs Int32 befindet. Die meisten der verbleibenden Member steuern Elemente, die in dieser Eingabezeichenfolge vorhanden sein können, aber NumberStyles nicht vorhanden sein müssen. Die folgende Tabelle gibt an, wie NumberStyles sich einzelne Member auf die Elemente auswirken, die möglicherweise in vorhanden s sind.

Nicht zusammengesetzte NumberStyles-Werte Elemente, die in zusätzlich zu Ziffern zulässig sind
NumberStyles.None Nur Dezimalstellen.
NumberStyles.AllowDecimalPoint Das Dezimaltrennzeichen ( . ) und Dezimalziffernelemente. Bruchziffern dürfen jedoch nur aus einer oder mehreren Ziffern bestehen, oder es OverflowException wird eine ausgelöst.
NumberStyles.AllowExponent Der s -Parameter kann auch exponentielle Notation verwenden. Wenn eine Zahl in exponentieller Notation darstellt, muss sie eine ganze Zahl innerhalb des Bereichs des Datentyps ohne eine Bruchkomponente darstellen, die nicht 0 s Int32 (null) ist.
NumberStyles.AllowLeadingWhite Das ws-Element am Anfang von s .
NumberStyles.AllowTrailingWhite Das ws-Element am Ende von s .
NumberStyles.AllowLeadingSign Vor den Ziffern kann ein positives Vorzeichen angezeigt werden.
NumberStyles.AllowTrailingSign Nach ziffern kann ein positives Vorzeichen angezeigt werden.
NumberStyles.AllowParentheses Das Vorzeichenelement in Form von Klammern, die den numerischen Wert umschließen.
NumberStyles.AllowThousands Das Tausendertrennzeichen (, ) -Element.
NumberStyles.AllowCurrencySymbol Das $ -Element.

Wenn das NumberStyles.AllowHexSpecifier Flag verwendet wird, s muss ein Hexadezimalwert ohne Präfix sein. Beispielsweise wird "C9AF3" erfolgreich analysiert, "0xC9AF3" jedoch nicht. Die einzigen anderen Flags, die in vorhanden sein style können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite . (Die NumberStyles -Enumeration verfügt über einen zusammengesetzten Zahlenstil, NumberStyles.HexNumber , der beide Leerraumflags enthält.)

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

Siehe auch

Gilt für

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.

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>

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

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 Informationen zum Format von s bereitstellt.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen, die der Zahl in s entspricht.

Gilt für

Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende 32-Bit-Ganzzahl 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 die zu konvertierende Zahl enthält.

style
NumberStyles

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

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen, die der Zahl in s entspricht.

Ausnahmen

s ist null.

style ist kein NumberStyles-Wert.

- oder - style ist keine Kombination von AllowHexSpecifier- und HexNumber-Werten.

s weist kein mit style kompatibles Format auf.

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

- oder - s enthält Dezimalstellen ungleich 0 (null).

Beispiele

Im folgenden Beispiel wird die Int32.Parse(String, NumberStyles) -Methode verwendet, um die Zeichenfolgendarstellungen mehrerer Werte zu Int32 analysieren. Die aktuelle Kultur für das Beispiel lautet 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 -Parameter definiert die Stilelemente (z. B. Leerzeichen, das positive oder negative Vorzeichen oder das Tausendertrennzeichen), die im -Parameter zulässig sind, damit der style s Analysevorgang erfolgreich ist. Es muss eine Kombination aus Bitflags aus der -Enumeration NumberStyles sein. Abhängig vom Wert von kann style s der -Parameter die folgenden Elemente enthalten:

[ws] [$] [Signieren] [digits,]digits[.fractional_digits][e[sign]exponential_digits][ws]

Oder, wenn style AllowHexSpecifier enthält:

[ws]hexdigits[ws]

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

Element BESCHREIBUNG
ws Optionaler Leerraum. Leerraum kann am Anfang von angezeigt werden, wenn das Flag enthält, und es kann am Ende von angezeigt s style NumberStyles.AllowLeadingWhite werden, s wenn das Flag style NumberStyles.AllowTrailingWhite enthält.
$ Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die Eigenschaften NumberFormatInfo.CurrencyNegativePattern und der aktuellen Kultur NumberFormatInfo.CurrencyPositivePattern definiert. Das Währungssymbol der aktuellen Kultur kann in angezeigt s werden, wenn style das Flag NumberStyles.AllowCurrencySymbol enthält.
sign Ein optionales Vorzeichen. Das Vorzeichen kann am Anfang von angezeigt werden, wenn das Flag enthält, und es kann am Ende von angezeigt s style NumberStyles.AllowLeadingSign werden, s wenn das Flag style NumberStyles.AllowTrailingSign enthält. In können Klammern verwendet werden, s um einen negativen Wert anzugeben, wenn das Flag style NumberStyles.AllowParentheses enthält.
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 Tausendertrennzeichen. Das Tausendertrennzeichen der aktuellen Kultur kann in angezeigt s werden, wenn style das Flag NumberStyles.AllowThousands enthält.
. Ein kulturspezifisches Dezimaltrennzeichen. Das Dezimaltrennzeichen der aktuellen Kultur kann in angezeigt s werden, wenn style das Flag NumberStyles.AllowDecimalPoint enthält. Nur die Ziffer 0 kann als Bruchziffer angezeigt werden, damit der Analysevorgang erfolgreich ist. Wenn fractional_digits eine andere Ziffer enthält, OverflowException wird eine ausgelöst.
e Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller Notation dargestellt wird. Der s -Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das Flag NumberStyles.AllowExponent enthält.
hexdigits Eine Sequenz von Hexadezimalziffern von 0 bis f oder 0 bis F.

Hinweis

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

Eine Zeichenfolge nur mit Ziffern (die dem Stil entspricht) analysiert immer erfolgreich, wenn sie sich im Bereich NumberStyles.None des Typs Int32 befindet. Die meisten der verbleibenden Member steuern Elemente, die in der Eingabezeichenfolge vorhanden sein können, aber NumberStyles nicht vorhanden sein müssen. Die folgende Tabelle gibt an, wie NumberStyles sich einzelne Member auf die Elemente auswirken, die möglicherweise in vorhanden s sind.

NumberStyles-Wert Elemente, die in zusätzlich zu Ziffern zulässig sind
None Nur das digits-Element.
AllowDecimalPoint Das Dezimaltrennzeichen ( . ) und Dezimalziffernelemente.
AllowExponent Der s -Parameter kann auch exponentielle Notation verwenden.
AllowLeadingWhite Das ws-Element am Anfang von s .
AllowTrailingWhite Das ws-Element am Ende von s .
AllowLeadingSign Das Vorzeichenelement am Anfang von s .
AllowTrailingSign Das Vorzeichenelement am Ende von s .
AllowParentheses Das Vorzeichenelement in Form von Klammern, die den numerischen Wert umschließen.
AllowThousands Das Tausendertrennzeichen (, ) -Element.
AllowCurrencySymbol Das $ -Element.
Currency Alle Der s -Parameter kann keine Hexadezimalzahl oder eine Zahl in exponentieller Notation darstellen.
Float Das ws-Element am Anfang oder Ende von s , das Vorzeichen am Anfang von s und das Dezimaltrennzeichen ( . ) symbol. Der s -Parameter kann auch exponentielle Notation verwenden.
Number Das ws sign Trennzeichen , das Tausendertrennzeichen ( , ) und das Dezimaltrennzeichen ( . ) -Elemente.
Any Alle Stile, mit Ausnahme von s , können keine Hexadezimalzahl darstellen.

Wenn das NumberStyles.AllowHexSpecifier Flag verwendet wird, s muss ein Hexadezimalwert ohne Präfix sein. "C9AF3" wird beispielsweise erfolgreich analysiert, "0xC9AF3" jedoch nicht. Die einzigen anderen Flags, die mit dem Parameter kombiniert werden s können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite . (Die NumberStyles -Enumeration enthält einen zusammengesetzten Zahlenstil, , der NumberStyles.HexNumber beide Leerzeichenflags enthält.)

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

Siehe auch

Gilt für

Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.

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 die zu konvertierende Zahl enthält.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen, die der Zahl in s entspricht.

Ausnahmen

s ist null.

s weist nicht das richtige Format auf.

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

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie ein Zeichenfolgenwert mit der -Methode in einen 32-Bit-Ganzzahlwert mit Vorzeichen konvertiert Int32.Parse(String) 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 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.
Signieren Ein optionales Vorzeichen.
Zahlen Eine Sequenz von Ziffern im Bereich von 0 bis 9.

Der s -Parameter wird mithilfe des -Stils NumberStyles.Integer interpretiert. Neben Dezimalstellen sind nur führende und nachstellende Leerzeichen zusammen mit einem vorigen Vorzeichen zulässig. Um die Stilelemente, die in vorhanden sein können, explizit zu definieren, verwenden s Sie entweder die Int32.Parse(String, NumberStyles) -Methode oder die Int32.Parse(String, NumberStyles, IFormatProvider) -Methode.

Der s -Parameter wird mithilfe der Formatierungsinformationen in einem -Objekt analysiert, NumberFormatInfo 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.

Siehe auch

Gilt für

Parse(String, IFormatProvider)

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

public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider);
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 die zu konvertierende Zahl enthält.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen, die der Zahl in s entspricht.

Ausnahmen

s ist null.

s weist nicht das richtige Format auf.

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

Beispiele

Das folgende Beispiel ist der Schaltflächenklick-Ereignishandler eines Webformulars. Es verwendet das von der HttpRequest.UserLanguages -Eigenschaft zurückgegebene Array, um das Gebietsschema des Benutzers zu bestimmen. Anschließend wird ein CultureInfo -Objekt instanziiert, das diesem Gebietsschema entspricht. Das NumberFormatInfo Objekt, das zu diesem Objekt gehört, CultureInfo wird dann an die Parse(String, IFormatProvider) -Methode übergeben, um die Eingabe des Benutzers in einen Wert zu Int32 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 -Methode wird in der Parse(String, IFormatProvider) Regel verwendet, um Text, der auf verschiedene Weise formatiert werden kann, in einen Wert zu Int32 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] [Vorzeichen]Ziffern[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.
Zahlen Eine Sequenz von Ziffern im Bereich von 0 bis 9.

Der s -Parameter wird mithilfe des NumberStyles.Integer Stils interpretiert. Zusätzlich zu Dezimalstellen sind nur führende und nachfolgende Leerzeichen zusammen mit einem führenden Vorzeichen zulässig. Verwenden Sie die -Methode, um die Stilelemente explizit zu definieren, die in vorhanden sein s Int32.Parse(String, NumberStyles, IFormatProvider) können.

Der provider Parameter ist eine IFormatProvider Implementierung, z. B. ein NumberFormatInfo - oder CultureInfo -Objekt. Der provider -Parameter stellt kulturspezifische Informationen zum Format von zur s Verfügung. Wenn provider null ist, wird das NumberFormatInfo -Objekt für die aktuelle Kultur verwendet.

Siehe auch

Gilt für