Freigeben über


Int32.TryParse Methode

Definition

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 32-Bit-ganzzahlige Entsprechung. Ein Rückgabewert gibt an, ob der Vorgang erfolgreich war.

Überlädt

TryParse(String, IFormatProvider, Int32)

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

TryParse(ReadOnlySpan<Char>, Int32)

Konvertiert die Spandarstellung einer Zahl in einem kulturspezifischen Format in das 32-Bit-Ganzzahläquivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

TryParse(String, Int32)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 32-Bit-ganzzahlige Entsprechung. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)

Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)

Versucht, einen Bereich von Zeichen in einen Wert zu analysieren.

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)

Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren.

TryParse(ReadOnlySpan<Byte>, Int32)

Versucht, einen UTF-8-Zeichenbereich zu konvertieren, der die Zeichenfolgendarstellung einer Zahl in seine 32-Bit-ganzzahlige Entsprechung enthält.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)

Konvertiert die Spandarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das 32-Bit-äquivalente ganzzahlige 32-Bit-Format. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

TryParse(String, NumberStyles, IFormatProvider, Int32)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in die 32-Bit-ganzzahlige Entsprechung mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

TryParse(String, IFormatProvider, Int32)

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

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = IParsable<int>::TryParse;
public static bool TryParse (string? s, IFormatProvider? provider, out int result);
static member TryParse : string * IFormatProvider * int -> bool
Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Integer) As Boolean

Parameter

s
String

Die zu analysierende Zeichenfolge.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt.

result
Int32

Wenn diese Methode zurückgegeben wird, enthält das Ergebnis der erfolgreichen Analyse s oder eines nicht definierten Werts für fehler.

Gibt zurück

true, wenn s erfolgreich analysiert wurde; andernfalls false.

Gilt für:

TryParse(ReadOnlySpan<Char>, Int32)

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

Konvertiert die Spandarstellung einer Zahl in einem kulturspezifischen Format in das 32-Bit-Ganzzahläquivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] int % result);
public static bool TryParse (ReadOnlySpan<char> s, out int result);
static member TryParse : ReadOnlySpan<char> * int -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Integer) As Boolean

Parameter

s
ReadOnlySpan<Char>

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

result
Int32

Wenn diese Methode zurückgegeben wird, enthält sie den 32-Bit-Ganzzahlwert der Zahl, die in senthalten ist, wenn die Konvertierung erfolgreich war, oder null, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn der parameter snull oder Empty ist oder eine Zahl kleiner als Int32.MinValue oder größer als Int32.MaxValuedarstellt. Dieser Parameter wird nicht initialisiert übergeben. alle ursprünglich in result angegebenen Werte werden überschrieben.

Gibt zurück

true, wenn s erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

TryParse(String, Int32)

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

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 32-Bit-ganzzahlige Entsprechung. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] int % result);
public static bool TryParse (string s, out int result);
public static bool TryParse (string? s, out int result);
static member TryParse : string * int -> bool
Public Shared Function TryParse (s As String, ByRef result As Integer) As Boolean

Parameter

s
String

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

result
Int32

Wenn diese Methode zurückgegeben wird, enthält sie den 32-Bit-Ganzzahlwert der Zahl, die in senthalten ist, wenn die Konvertierung erfolgreich war, oder null, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn der s Parameter null oder Emptyist, nicht das richtige Format aufweist oder eine Zahl kleiner als Int32.MinValue oder größer als Int32.MaxValuedarstellt. Dieser Parameter wird nicht initialisiert übergeben. alle ursprünglich in result angegebenen Werte werden überschrieben.

Gibt zurück

true, wenn s erfolgreich konvertiert wurde; andernfalls false.

Beispiele

Im folgenden Beispiel wird die Int32.TryParse(String, Int32)-Methode mit einer Reihe unterschiedlicher Zeichenfolgenwerte aufgerufen.

using namespace System;


   void TryToParse(String^ value)
   {
      Int32 number;
      bool result = Int32::TryParse(value, number);
      if (result) {
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      else {
         if (value == nullptr) value = "";
         Console::WriteLine("Attempted conversion of '{0}' failed.", value);
      }
   }


void main()
{
      TryToParse(nullptr);
      TryToParse("160519");
      TryToParse("9432.0");
      TryToParse("16,667");
      TryToParse("   -322   ");
      TryToParse("+4302");
      TryToParse("(100);");
      TryToParse("01FA");
}
// The example displays the following output:
//      Attempted conversion of '' failed.
//      Converted '160519' to 160519.
//      Attempted conversion of '9432.0' failed.
//      Attempted conversion of '16,667' failed.
//      Converted '   -322   ' to -322.
//      Converted '+4302' to 4302.
//      Attempted conversion of '(100);' failed.
//      Attempted conversion of '01FA' failed.
using System;

public class Example
{
   public static void Main()
   {
      string[] values = { null, "160519", "9432.0", "16,667",
                          "   -322   ", "+4302", "(100);", "01FA" };
      foreach (var value in values)
      {
         int number;

         bool success = int.TryParse(value, out number);
         if (success)
         {
            Console.WriteLine($"Converted '{value}' to {number}.");
         }
         else
         {
            Console.WriteLine($"Attempted conversion of '{value ?? "<null>"}' failed.");
         }
      }
   }
}
// The example displays the following output:
//       Attempted conversion of '<null>' failed.
//       Converted '160519' to 160519.
//       Attempted conversion of '9432.0' failed.
//       Attempted conversion of '16,667' failed.
//       Converted '   -322   ' to -322.
//       Converted '+4302' to 4302.
//       Attempted conversion of '(100);' failed.
//       Attempted conversion of '01FA' failed.
open System

let values = 
   [ null; "160519"; "9432.0"; "16,667"
     "   -322   "; "+4302"; "(100);"; "01FA" ]
for value in values do
    match Int32.TryParse value with
    | true, number -> 
        printfn $"Converted '{value}' to {number}."
    | _ -> 
        printfn $"""Attempted conversion of '{if isNull value then "<null>" else value}' failed."""
         
// The example displays the following output:
//       Attempted conversion of '<null>' failed.
//       Converted '160519' to 160519.
//       Attempted conversion of '9432.0' failed.
//       Attempted conversion of '16,667' failed.
//       Converted '   -322   ' to -322.
//       Converted '+4302' to 4302.
//       Attempted conversion of '(100);' failed.
//       Attempted conversion of '01FA' failed.
Module Example
   Public Sub Main()
      Dim values() As String = { Nothing, "160519", "9432.0", "16,667",
                                 "   -322   ", "+4302", "(100);", 
                                 "01FA" }

      For Each value In values
         Dim number As Integer
    
         Dim success As Boolean = Int32.TryParse(value, number)
         If success Then
            Console.WriteLine("Converted '{0}' to {1}.", value, number)
         Else
            Console.WriteLine("Attempted conversion of '{0}' failed.", 
                              If(value ,"<null>"))
         End If     
      Next
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '<null>' failed.
'       Converted '160519' to 160519.
'       Attempted conversion of '9432.0' failed.
'       Attempted conversion of '16,667' failed.
'       Converted '   -322   ' to -322.
'       Converted '+4302' to 4302.
'       Attempted conversion of '(100)' failed.
'       Attempted conversion of '01FA' failed.

Einige der Zeichenfolgen, die die TryParse(String, Int32)-Methode in diesem Beispiel nicht konvertieren kann, sind:

  • "9432.0". Die Konvertierung schlägt fehl, da die Zeichenfolge kein Dezimaltrennzeichen enthalten kann. sie darf nur integrale Ziffern enthalten.

  • "16,667". Die Konvertierung schlägt fehl, da die Zeichenfolge keine Gruppentrennzeichen enthalten kann; sie darf nur integrale Ziffern enthalten.

  • "(100)". Die Konvertierung schlägt fehl, da die Zeichenfolge kein negatives Zeichen als das negative Zeichen enthalten kann, das durch die NumberFormatInfo.NegativeSign und NumberFormatInfo.NumberNegativePattern Eigenschaften der aktuellen Kultur definiert ist.

  • "01FA". Die Konvertierung schlägt fehl, da die Zeichenfolge keine Hexadezimalziffern enthalten kann. sie darf nur Dezimalziffern enthalten.

Hinweise

Die TryParse-Methode ähnelt der Parse-Methode, außer die TryParse Methode löst keine Ausnahme aus, wenn die Konvertierung fehlschlägt. Es beseitigt die Notwendigkeit, die Ausnahmebehandlung zu verwenden, um eine FormatException zu testen, wenn s ungültig ist und nicht erfolgreich analysiert werden kann.

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 den Dezimalziffern sind nur führende und nachfolgende Leerzeichen zusammen mit einem vorangestellten Zeichen zulässig. Wenn Sie die Formatvorlagenelemente explizit zusammen mit den kulturspezifischen Formatierungsinformationen definieren möchten, die in svorhanden sein können, verwenden Sie die Int32.TryParse(String, NumberStyles, IFormatProvider, Int32)-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.

Diese Überladung der TryParse-Methode interpretiert alle Ziffern im s Parameter als Dezimalziffern. Rufen Sie die Int32.TryParse(String, NumberStyles, IFormatProvider, Int32) überladung auf, um die Zeichenfolgendarstellung einer Hexadezimalzahl zu analysieren.

Weitere Informationen

Gilt für:

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)

Quelle:
Int32.cs
Quelle:
Int32.cs

Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = IUtf8SpanParsable<int>::TryParse;
public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out int result);
static member TryParse : ReadOnlySpan<byte> * IFormatProvider * int -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Integer) As Boolean

Parameter

utf8Text
ReadOnlySpan<Byte>

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

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Textbereitstellt.

result
Int32

Enthält das Ergebnis der erfolgreichen Analyse utf8Text oder eines nicht definierten Werts für fehler.

Gibt zurück

true, wenn utf8Text erfolgreich analysiert wurde; andernfalls false.

Gilt für:

TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)

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

Versucht, einen Bereich von Zeichen in einen Wert zu analysieren.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = ISpanParsable<int>::TryParse;
public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out int result);
static member TryParse : ReadOnlySpan<char> * IFormatProvider * int -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Integer) As Boolean

Parameter

s
ReadOnlySpan<Char>

Die Spanne der zu analysierenden Zeichen.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt.

result
Int32

Wenn diese Methode zurückgegeben wird, enthält das Ergebnis der erfolgreichen Analyse soder eines nicht definierten Werts für fehler.

Gibt zurück

true, wenn s erfolgreich analysiert wurde; andernfalls false.

Gilt für:

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)

Quelle:
Int32.cs
Quelle:
Int32.cs

Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;
public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);
static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * int -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

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.

result
Int32

Enthält das Ergebnis der erfolgreichen Analyse utf8Text oder eines nicht definierten Werts für fehler.

Gibt zurück

true, wenn utf8Text erfolgreich analysiert wurde; andernfalls false.

Gilt für:

TryParse(ReadOnlySpan<Byte>, Int32)

Quelle:
Int32.cs
Quelle:
Int32.cs

Versucht, einen UTF-8-Zeichenbereich zu konvertieren, der die Zeichenfolgendarstellung einer Zahl in seine 32-Bit-ganzzahlige Entsprechung enthält.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] int % result);
public static bool TryParse (ReadOnlySpan<byte> utf8Text, out int result);
static member TryParse : ReadOnlySpan<byte> * int -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Integer) As Boolean

Parameter

utf8Text
ReadOnlySpan<Byte>

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

result
Int32

Wenn diese Methode zurückgegeben wird, enthält sie den 32-Bit-ganzzahligen Wert, der der zahl entspricht, die in utf8Text enthalten ist, wenn die Konvertierung erfolgreich war, oder null, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben. alle ursprünglich im Ergebnis angegebenen Werte werden überschrieben.

Gibt zurück

true, wenn utf8Text erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)

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. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result);
public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;
public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);
public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out int result);
static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * int -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

Parameter

s
ReadOnlySpan<Char>

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

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 Formatierungsinformationen zu sbereitstellt.

result
Int32

Wenn diese Methode zurückgegeben wird, enthält sie den 32-Bit-Ganzzahlwert der Zahl, die in senthalten ist, wenn die Konvertierung erfolgreich war, oder null, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn der parameter snull oder Emptyist, nicht in einem Format vorhanden ist, das mit stylekompatibel ist, oder eine Zahl kleiner als Int32.MinValue oder größer als Int32.MaxValuedarstellt. Dieser Parameter wird nicht initialisiert übergeben. alle ursprünglich in result angegebenen Werte werden überschrieben.

Gibt zurück

true, wenn s erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

TryParse(String, NumberStyles, IFormatProvider, Int32)

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. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result);
public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;
public static bool TryParse (string s, System.Globalization.NumberStyles style, IFormatProvider provider, out int result);
public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);
static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * int -> bool
Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

Parameter

s
String

Eine Zeichenfolge, die eine zahl enthält, die konvertiert werden soll. Die Zeichenfolge wird mithilfe der von styleangegebenen Formatvorlage interpretiert.

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 Formatierungsinformationen zu sbereitstellt.

result
Int32

Wenn diese Methode zurückgegeben wird, enthält sie den 32-Bit-Ganzzahlwert der Zahl, die in senthalten ist, wenn die Konvertierung erfolgreich war, oder null, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn der parameter snull oder Emptyist, nicht in einem Format vorhanden ist, das mit stylekompatibel ist, oder eine Zahl kleiner als Int32.MinValue oder größer als Int32.MaxValuedarstellt. Dieser Parameter wird nicht initialisiert übergeben. alle ursprünglich in result angegebenen Werte werden überschrieben.

Gibt zurück

true, wenn s erfolgreich konvertiert wurde; andernfalls false.

Ausnahmen

style ist kein NumberStyles Wert.

-oder-

style ist keine Kombination aus AllowHexSpecifier und HexNumber Werten.

Beispiele

Im folgenden Beispiel wird die Int32.TryParse(String, NumberStyles, IFormatProvider, Int32)-Methode mit einer Reihe unterschiedlicher Zeichenfolgen- und NumberStyles Werte aufgerufen.

using namespace System;
using namespace System::Globalization;

void CallTryParse(String^ stringToConvert, NumberStyles styles)
{
      Int32 number;
      CultureInfo^ provider;

      // If currency symbol is allowed, use en-US culture. 
      if (((Int32) (styles & NumberStyles::AllowCurrencySymbol)) > 0)
         provider = gcnew CultureInfo("en-US");
      else
         provider = CultureInfo::InvariantCulture;

      bool result = Int32::TryParse(stringToConvert, styles, 
                                   provider, number);
      if (result)
         Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
      else
         Console::WriteLine("Attempted conversion of '{0}' failed.", 
                           Convert::ToString(stringToConvert));
}

void main()
{
      String^ numericString;
      NumberStyles styles;

      numericString = "106779";
      styles = NumberStyles::Integer;
      CallTryParse(numericString, styles);

      numericString = "-30677";
      styles = NumberStyles::None;
      CallTryParse(numericString, styles);

      styles = NumberStyles::AllowLeadingSign;
      CallTryParse(numericString, styles);

      numericString = "301677-";
      CallTryParse(numericString, styles);

      styles = styles | NumberStyles::AllowTrailingSign;
      CallTryParse(numericString, styles);

      numericString = "$10634";
      styles = NumberStyles::Integer;
      CallTryParse(numericString, styles);

      styles = NumberStyles::Integer | NumberStyles::AllowCurrencySymbol;
      CallTryParse(numericString, styles);

      numericString = "10345.00";
      styles = NumberStyles::Integer | NumberStyles::AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10345.72";
      styles = NumberStyles::Integer | NumberStyles::AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "22,593"; 
      styles = NumberStyles::Integer | NumberStyles::AllowThousands;
      CallTryParse(numericString, styles);

      numericString = "12E-01";
      styles = NumberStyles::Integer | NumberStyles::AllowExponent;
      CallTryParse(numericString, styles); 

      numericString = "12E03";
      CallTryParse(numericString, styles); 

      numericString = "80c1";
      CallTryParse(numericString, NumberStyles::HexNumber);

      numericString = "0x80C1";
      CallTryParse(numericString, NumberStyles::HexNumber);      
      Console::ReadLine();
}
// The example displays the following output:
//      Converted '106779' to 106779.
//      Attempted conversion of '-30677' failed.
//      Converted '-30677' to -30677.
//      Attempted conversion of '301677-' failed.
//      Converted '301677-' to -301677.
//      Attempted conversion of '$10634' failed.
//      Converted '$10634' to 10634.
//      Converted '10345.00' to 10345.
//      Attempted conversion of '10345.72' failed.
//      Converted '22,593' to 22593.
//      Attempted conversion of '12E-01' failed.
//      Converted '12E03' to 12000.
//      Converted '80c1' to 32961.
//      Attempted conversion of '0x80C1' failed.
using System;
using System.Globalization;

public class StringParsing
{
   public static void Main()
   {
      string numericString;
      NumberStyles styles;

      numericString = "106779";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);

      numericString = "-30677";
      styles = NumberStyles.None;
      CallTryParse(numericString, styles);

      styles = NumberStyles.AllowLeadingSign;
      CallTryParse(numericString, styles);

      numericString = "301677-";
      CallTryParse(numericString, styles);

      styles = styles | NumberStyles.AllowTrailingSign;
      CallTryParse(numericString, styles);

      numericString = "$10634";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);

      styles = NumberStyles.Integer | NumberStyles.AllowCurrencySymbol;
      CallTryParse(numericString, styles);

      numericString = "10345.00";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10345.72";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "22,593";
      styles = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallTryParse(numericString, styles);

      numericString = "12E-01";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(numericString, styles);

      numericString = "12E03";
      CallTryParse(numericString, styles);

      numericString = "80c1";
      CallTryParse(numericString, NumberStyles.HexNumber);

      numericString = "0x80C1";
      CallTryParse(numericString, NumberStyles.HexNumber);
   }

   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      CultureInfo provider;

      // If currency symbol is allowed, use en-US culture.
      if ((styles & NumberStyles.AllowCurrencySymbol) > 0)
         provider = new CultureInfo("en-US");
      else
         provider = CultureInfo.InvariantCulture;

      bool success = int.TryParse(stringToConvert, styles,
                                   provider, out int number);
      if (success)
         Console.WriteLine($"Converted '{stringToConvert}' to {number}.");
      else
         Console.WriteLine($"Attempted conversion of '{stringToConvert}' failed.");
   }
}
// The example displays the following output to the console:
//       Converted '106779' to 106779.
//       Attempted conversion of '-30677' failed.
//       Converted '-30677' to -30677.
//       Attempted conversion of '301677-' failed.
//       Converted '301677-' to -301677.
//       Attempted conversion of '$10634' failed.
//       Converted '$10634' to 10634.
//       Converted '10345.00' to 10345.
//       Attempted conversion of '10345.72' failed.
//       Converted '22,593' to 22593.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E03' to 12000.
//       Converted '80c1' to 32961.
//       Attempted conversion of '0x80C1' failed.
open System
open System.Globalization

let callTryParse (stringToConvert: string) styles =
    let provider =
        // If currency symbol is allowed, use en-US culture.
        if int (styles &&& NumberStyles.AllowCurrencySymbol) > 0 then
            CultureInfo "en-US"
        else
            CultureInfo.InvariantCulture

    match Int32.TryParse(stringToConvert, styles, provider) with
    | true, number ->
        printfn $"Converted '{stringToConvert}' to {number}."
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."

[<EntryPoint>]
let main _ =
    let numericString = "106779"
    let styles = NumberStyles.Integer
    callTryParse numericString styles

    let numericString = "-30677"
    let styles = NumberStyles.None
    callTryParse numericString styles

    let styles = NumberStyles.AllowLeadingSign
    callTryParse numericString styles

    let numericString = "301677-"
    callTryParse numericString styles

    let styles = styles ||| NumberStyles.AllowTrailingSign
    callTryParse numericString styles

    let numericString = "$10634"
    let styles = NumberStyles.Integer
    callTryParse numericString styles

    let styles = NumberStyles.Integer ||| NumberStyles.AllowCurrencySymbol
    callTryParse numericString styles

    let numericString = "10345.00"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "10345.72"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "22,593"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callTryParse numericString styles

    let numericString = "12E-01"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse numericString styles

    let numericString = "12E03"
    callTryParse numericString styles

    let numericString = "80c1"
    callTryParse numericString NumberStyles.HexNumber

    let numericString = "0x80C1"
    callTryParse numericString NumberStyles.HexNumber

    0

// The example displays the following output to the console:
//       Converted '106779' to 106779.
//       Attempted conversion of '-30677' failed.
//       Converted '-30677' to -30677.
//       Attempted conversion of '301677-' failed.
//       Converted '301677-' to -301677.
//       Attempted conversion of '$10634' failed.
//       Converted '$10634' to 10634.
//       Converted '10345.00' to 10345.
//       Attempted conversion of '10345.72' failed.
//       Converted '22,593' to 22593.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E03' to 12000.
//       Converted '80c1' to 32961.
//       Attempted conversion of '0x80C1' failed.
Imports System.Globalization

Module StringParsing
   Public Sub Main()
      Dim numericString As String
      Dim styles As NumberStyles
      
      numericString = "106779"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      numericString = "-30677"
      styles = NumberStyles.None
      CallTryParse(numericString, styles)
      
      styles = NumberStyles.AllowLeadingSign
      CallTryParse(numericString, styles)
      
      numericString = "301677-"
      CallTryParse(numericString, styles)
      
      styles = styles Or NumberStyles.AllowTrailingSign
      CallTryParse(numericString, styles)
      
      numericString = "$10634"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      styles = NumberStyles.Integer Or NumberStyles.AllowCurrencySymbol
      CallTryParse(numericString, styles)

      numericString = "10345.00"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)
      
      numericString = "10345.72"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)

      numericString = "22,593" 
      styles = NumberStyles.Integer Or NumberStyles.AllowThousands
      CallTryParse(numericString, styles)
      
      numericString = "12E-01"
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(numericString, styles) 
          
      numericString = "12E03"
      CallTryParse(numericString, styles) 
      
      numericString = "80c1"
      CallTryParse(numericString, NumberStyles.HexNumber)
      
      numericString = "0x80C1"
      CallTryParse(numericString, NumberStyles.HexNumber)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles AS NumberStyles)
      Dim number As Integer
      Dim provider As CultureInfo
      
      ' If currency symbol is allowed, use en-US culture.
      If CBool(styles And NumberStyles.AllowCurrencySymbol) Then
         provider = CultureInfo.CurrentCulture
      Else
         provider = New CultureInfo("en-US")
      End If
      
      Dim result As Boolean = Int32.TryParse(stringToConvert, styles, _
                                             provider, number)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           Convert.ToString(stringToConvert))
      End If                                                                           
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '106779' to 106779.
'       Attempted conversion of '-30677' failed.
'       Converted '-30677' to -30677.
'       Attempted conversion of '301677-' failed.
'       Converted '301677-' to -301677.
'       Attempted conversion of '$10634' failed.
'       Converted '$10634' to 10634.
'       Converted '10345.00' to 10345.
'       Attempted conversion of '10345.72' failed.
'       Converted '22,593' to 22593.
'       Attempted conversion of '12E-01' failed.
'       Converted '12E03' to 12000.
'       Converted '80c1' to 32961.
'       Attempted conversion of '0x80C1' failed.

Hinweise

Die TryParse-Methode ähnelt der Parse-Methode, außer die TryParse Methode löst keine Ausnahme aus, wenn die Konvertierung fehlschlägt. Es beseitigt die Notwendigkeit, die Ausnahmebehandlung zu verwenden, um eine FormatException zu testen, wenn s ungültig ist und nicht erfolgreich analysiert werden kann.

Der style-Parameter definiert die Formatvorlagenelemente (z. B. Leerzeichen oder ein positives oder negatives Vorzeichen), die im s-Parameter 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][Zeichen][ws]

Oder, wenn der style Parameter AllowHexSpecifierenthä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 der s angezeigt werden, wenn style die NumberStyles.AllowLeadingWhite-Kennzeichnung enthält, oder am Ende der s, wenn style die NumberStyles.AllowTrailingWhite-Kennzeichnung enthält.
$ Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die CurrencyPositivePattern-Eigenschaft des NumberFormatInfo Objekts definiert, das von der GetFormat-Methode des provider-Parameters zurückgegeben wird. Das Währungssymbol kann in s angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthält.
signieren Ein optionales Zeichen. Ein Zeichensymbol kann in s angezeigt werden, wenn style die Kennzeichnungen NumberStyles.AllowLeadingSign oder NumberStyles.AllowTrailingSign enthält.
Ziffern Eine Sequenz von Ziffern von 0 bis 9.
, 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.
fractional_digits Mindestens ein Vorkommen der Ziffer 0. Dezimalstellen können nur in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält.
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 Dezimalziffern (die dem kennzeichen NumberStyles.None entspricht) analysiert immer erfolgreich. 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 Der Dezimalkomma (.) und fractional_digits Elemente. fractional_digits darf jedoch nur aus einer oder mehreren 0 Ziffern bestehen, oder die Methode gibt falsezurück.
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 Zeichen kann vor Ziffernangezeigt werden.
NumberStyles.AllowTrailingSign Ein 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.
NumberStyles.Currency Alle Elemente. Der parameter s kann keine hexadezimale Zahl oder eine Zahl in exponentieller Schreibweise darstellen.
NumberStyles.Float Das ws--Element am Anfang oder Ende s, Zeichen am Anfang s, und das Dezimalkomma (.) Symbol. Der parameter s kann auch exponentielle Notation verwenden.
NumberStyles.Number Die ws, Zeichen, Tausendertrennzeichen (,) und Dezimalkomma (.) Elemente.
NumberStyles.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 Kennzeichen, die in style vorhanden sein können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles-Aufzählung weist eine zusammengesetzte Formatvorlage NumberStyles.HexNumberauf, die beide Leerzeichen-Flags enthält.)

Der provider-Parameter ist eine IFormatProvider Implementierung, z. B. ein CultureInfo-Objekt oder ein NumberFormatInfo-Objekt, dessen GetFormat Methode ein NumberFormatInfo-Objekt zurückgibt. Das NumberFormatInfo-Objekt stellt kulturspezifische Informationen zum Format von sbereit. Wenn providernullist, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

Gilt für: