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.

Implementiert

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 eine Vielzahl von style und provider Parameter verwendet, um die Zeichenfolgendarstellungen von Int32 Werten zu analysieren. Es veranschaulicht auch einige der verschiedenen Möglichkeiten, wie die gleiche 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 Zeichen), die im Parameter für den s Parsevorgang erfolgreich zulässig sind. Es muss eine Kombination aus Bit-Flags aus der NumberStyles Aufzählung sein. Je nach Wert stylevon , kann der s Parameter die folgenden Elemente enthalten:

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

Oder wenn style Sie folgendes enthalten AllowHexSpecifier:

[ws]hexdigits[ws]

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

Element BESCHREIBUNG
ws Optionaler Leerraum. Leerzeichen können am Anfang s des Kennzeichens angezeigt werden, und es kann am Ende s angezeigt werden, wenn style style das NumberStyles.AllowTrailingWhite Flag enthalten NumberStyles.AllowLeadingWhite ist.
$ Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyPositivePattern Eigenschaft NumberFormatInfo des Objekts definiert, das von der GetFormat Methode des provider Parameters zurückgegeben wird. Das Währungssymbol kann angezeigt s werden, wenn style das NumberStyles.AllowCurrencySymbol Kennzeichen enthalten ist.
sign Ein optionales Zeichen. Das Zeichen kann am Anfang des Zeichens angezeigt werden, wenn style das Kennzeichen oder am Ende s s der Kennzeichnung enthalten istNumberStyles.AllowTrailingSign.NumberStyles.AllowLeadingSign style Klammern können verwendet s werden, um einen negativen Wert anzugeben, wenn style das NumberStyles.AllowParentheses Flag enthalten ist.
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 Tausendertrennzeichensymbol. Die Tausendertrennzeichen der von ihnen angegebenen provider Kultur können bei s style Angabe des NumberStyles.AllowThousands Flags angezeigt werden.
. Ein kulturspezifisches Dezimalzeichen. Das dezimale Punktsymbol der von ihnen angegebenen provider Kultur kann angezeigt s werden, wenn style die NumberStyles.AllowDecimalPoint Kennzeichnung enthalten ist.

Nur die Ziffern 0 können als Bruchstellen für den Analysevorgang angezeigt werden, um erfolgreich zu sein; wenn fractional_digits alle anderen Ziffern enthält, wird ein OverflowException Wurf 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 die NumberStyles.AllowExponent Kennzeichnung enthalten ist.
hexdigits Eine Sequenz von hexadezimalen Ziffern von 0 bis f oder 0 bis F.

Hinweis

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

Eine Zeichenfolge mit dezimalen Ziffern (die NumberStyles.None der Formatvorlage entsprechen) analysiert immer erfolgreich, wenn es sich im Bereich des Int32 Typs befindet. Die meisten verbleibenden NumberStyles Elemente steuern Elemente, die möglicherweise vorhanden sind, aber nicht erforderlich sind, um in dieser Eingabezeichenfolge vorhanden zu sein. In der folgenden Tabelle wird angegeben, wie einzelne NumberStyles Elemente sich auf die Elemente auswirken, die möglicherweise vorhanden ssind.

Nicht zusammengesetzte NumberStyles-Werte Elemente, die in s zusätzlich zu Ziffern zulässig sind
NumberStyles.None Dezimalstellen nur.
NumberStyles.AllowDecimalPoint Der Dezimalpunkt ( . ) und Bruchstellenelemente . Es muss jedoch nur eine oder mehrere Ziffern bestehen, oder es OverflowException wird ausgelöst.
NumberStyles.AllowExponent Der s Parameter kann auch exponentielle Notation verwenden. Wenn s eine Zahl in exponentieller Notation dargestellt wird, muss sie eine ganze Zahl im Bereich des Int32 Datentyps ohne eine nicht nulle, Bruchkomponente darstellen.
NumberStyles.AllowLeadingWhite Das ws-Element am Anfang von s.
NumberStyles.AllowTrailingWhite Das ws-Element am Ende von s.
NumberStyles.AllowLeadingSign Ein positives Zeichen kann vor Ziffern angezeigt werden.
NumberStyles.AllowTrailingSign Ein positives Zeichen kann nach Ziffern angezeigt werden.
NumberStyles.AllowParentheses Das Sign-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, s muss es sich um einen Hexadezimalwert ohne Präfix handelt. Beispielsweise analysiert "C9AF3" erfolgreich, aber "0xC9AF3" nicht. Die einzigen anderen Flags, die vorhanden style sein können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Aufzählung verfügt über eine zusammengesetzte Zahlenformatvorlage, NumberStyles.HexNumberdie beide Leerzeichen-Flags enthält.)

Der provider Parameter ist eine Implementierung, z. B. ein IFormatProvider NumberFormatInfo oder CultureInfo ein Objekt. Der provider Parameter liefert kulturspezifische Informationen, die in der Analyse verwendet werden. If provider is null, the NumberFormatInfo object for the current culture is used.

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.

Implementiert

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 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 zulässig sind, damit der s Analysevorgang erfolgreich verläuft. Es muss eine Kombination aus Bitkennzeichnungen aus der NumberStyles Enumeration sein. Abhängig vom Wert von style, kann der s Parameter die folgenden Elemente enthalten:

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

Oder, wenn style :AllowHexSpecifier

[ws]hexdigits[ws]

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

Element BESCHREIBUNG
ws Optionaler Leerraum. Leerzeichen können am Anfang s angezeigt werden, wenn style die NumberStyles.AllowLeadingWhite Kennzeichnung enthalten ist, und sie kann am Ende s angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Kennzeichen enthalten ist.
$ Ein kulturspezifisches Währungssymbol. Seine Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyNegativePattern und NumberFormatInfo.CurrencyPositivePattern die Eigenschaften der aktuellen Kultur definiert. Das Währungssymbol der aktuellen Kultur kann angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Kennzeichen enthalten s ist.
sign Ein optionales Zeichen. Das Zeichen kann am Anfang s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Kennzeichen enthalten ist, und es kann am Ende s angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Kennzeichen enthalten ist. Klammern können verwendet s werden, um einen negativen Wert anzugeben, wenn style das NumberStyles.AllowParentheses Kennzeichen enthalten ist.
Zahlen

fractional_digits

exponential_digits
Eine Abfolge von Ziffern von 0 bis 9. Für fractional_digits ist nur die Ziffer 0 gültig.
, Ein kulturspezifisches Tausendertrennzeichensymbol. Das Tausendertrennzeichen der aktuellen Kultur kann angezeigt werden, wenn style das NumberStyles.AllowThousands Kennzeichen enthalten s ist.
. Ein kulturspezifisches Dezimalkommasymbol. Das Dezimalkommasymbol der aktuellen Kultur kann angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Kennzeichen enthalten s ist. Nur die Ziffer 0 kann als Bruchziffer angezeigt werden, damit der Analysevorgang erfolgreich verläuft; wenn fractional_digits eine andere Ziffer enthält, wird ein OverflowException Wurf 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 enthalten ist.
hexdigits Eine Sequenz von Hexadezimalstellen von 0 bis f oder 0 bis F.

Hinweis

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

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

NumberStyles-Wert Elemente, die zusätzlich zu Ziffern in s zulässig sind
None Das Element "Ziffern" wird nur verwendet.
AllowDecimalPoint Der Dezimalpunkt ( . ) und Bruchstellenelemente .
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 Zeichenelement am Anfang von s.
AllowTrailingSign Das Sign-Element am Ende von s.
AllowParentheses Das Sign-Element in Form von Klammern, die den numerischen Wert einschließ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 , zeichen am Anfang svon s, und der Dezimalpunkt ( . ) Symbol. Der s Parameter kann auch exponentielle Notation verwenden.
Number Die , , Tausendertrennzeichen ws( , sign) und Dezimalpunkt ( . ) Elemente.
Any Alle Formatvorlagen können mit Ausnahme einer Hexadezimalzahl nicht s dargestellt werden.

Wenn das NumberStyles.AllowHexSpecifier Flag verwendet wird, s muss es sich um einen Hexadezimalwert ohne Präfix handelt. Beispielsweise analysiert "C9AF3" erfolgreich, aber "0xC9AF3" nicht. Die einzigen anderen Flags, die mit dem s Parameter NumberStyles.AllowLeadingWhite kombiniert werden können, sind und NumberStyles.AllowTrailingWhite. (Die NumberStyles Aufzählung enthält eine zusammengesetzte Zahlenformatvorlage, NumberStyles.HexNumberdie 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. 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 mithilfe der Int32.Parse(String) Methode in einen 32-Bit-ganzzahligen Wert 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 s Parameter enthält eine Zahl des Formulars:

[ws] [Zeichen]Ziffern[ws]

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

Element BESCHREIBUNG
ws Optionaler Leerraum.
Signieren Ein optionales Zeichen.
Zahlen Eine Abfolge von Ziffern zwischen 0 und 9.

Der s Parameter wird mithilfe der NumberStyles.Integer Formatvorlage interpretiert. Zusätzlich zu dezimalen Ziffern sind nur führende und nachgestellte Leerzeichen zusammen mit einem führenden Zeichen zulässig. Verwenden Sie zum expliziten Definieren der Formatvorlagenelemente, die vorhanden ssein können, entweder die Int32.Parse(String, NumberStyles) Methode 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. Verwenden Sie die Int32.Parse(String, NumberStyles, IFormatProvider) Methode, um eine Zeichenfolge mithilfe der Formatierungsinformationen einiger anderer Kultur zu analysieren.

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.

Implementiert

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 handelt es sich um den 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 wird ein CultureInfo Objekt instanziiert, 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 Methode wird in der Parse(String, IFormatProvider) Regel verwendet, um Text zu konvertieren, der in einer Vielzahl von Möglichkeiten in einen Int32 Wert formatiert werden kann. 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 Anzahl des Formulars:

[ws] [sign]digits[ws]

Elemente in quadratischen 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, die zwischen 0 und 9 reichen.

Der s Parameter wird mithilfe der NumberStyles.Integer Formatvorlage interpretiert. Neben dezimalen Ziffern sind nur führende und nachgestellte Leerzeichen zusammen mit einem führenden Zeichen zulässig. Zum expliziten Definieren der Formatvorlagenelemente, die vorhanden ssein können, verwenden Sie die Int32.Parse(String, NumberStyles, IFormatProvider) Methode.

Der provider Parameter ist eine Implementierung, z. B. ein IFormatProvider NumberFormatInfo oder CultureInfo ein Objekt. Der provider Parameter liefert kulturspezifische Informationen zum Format von s. If provider is null, the NumberFormatInfo object for the current culture is used.

Siehe auch

Gilt für: