Freigeben über


BigInteger.TryParse Methode

Definition

Versucht, die Zeichenfolgendarstellung einer Zahl in deren BigInteger-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

Überlädt

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

Versucht, die Zeichenfolgendarstellung einer Zahl in deren BigInteger-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

TryParse(String, IFormatProvider, BigInteger)

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)

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

TryParse(String, BigInteger)

Versucht, die Zeichenfolgendarstellung einer Zahl in deren BigInteger-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

TryParse(ReadOnlySpan<Char>, BigInteger)

Versucht, die Darstellung einer Zahl, die in der angegebenen schreibgeschützten Zeichenspanne enthalten ist, in ihre Entsprechung BigInteger zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in das entsprechende BigInteger und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.

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

Quelle:
BigInteger.cs
Quelle:
BigInteger.cs
Quelle:
BigInteger.cs

Versucht, die Zeichenfolgendarstellung einer Zahl in deren BigInteger-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

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

Parameter

value
ReadOnlySpan<Char>

Die Darstellung einer Zahl als schreibgeschützte Spanne von Zeichen.

style
NumberStyles

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

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu value bereitstellt.

result
BigInteger

Die Rückgabe dieser Methode enthält die BigInteger-Entsprechung der Zahl in value, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Die Konvertierung schlägt fehl, wenn der Parameter value eine leere Zeichenspanne ist oder nicht in einem Format vorliegt, das mit style kompatibel ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn value erfolgreich konvertiert wurde, andernfalls false.

Ausnahmen

style ist kein NumberStyles-Wert.

- oder -

style schließt das AllowHexSpecifier-Flag oder HexNumber-Flag mit einem anderen Wert ein.

Hinweise

Diese Überladung ähnelt der Methode, mit dem Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Unterschied, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt. Diese Methode entfällt die Notwendigkeit, die Ausnahmebehandlung zu verwenden, um zu testen, ob value ein FormatException ungültig ist und nicht erfolgreich analysiert werden kann.

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

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

Wenn der style Parameter enthält AllowHexSpecifier, kann der value Parameter die folgenden Elemente enthalten:

[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 von value angezeigt werden, wenn style das NumberStyles.AllowLeadingWhite Flag enthalten ist, oder am Ende von value , wenn style das NumberStyles.AllowTrailingWhite Flag enthalten ist.
$ Ein kulturspezifisches Währungssymbol. Seine Position in value wird durch die CurrencyPositivePattern Eigenschaft des Objekts definiert, das NumberFormatInfo von der GetFormat -Methode des provider Parameters zurückgegeben wird. Das Währungssymbol kann in value angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthalten ist.
sign Ein optionales Zeichen. Das Zeichen kann am Anfang von value angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthalten ist, und es kann am Ende value von angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthalten ist. Klammern können in value verwendet werden, um einen negativen Wert anzugeben, wenn style das NumberStyles.AllowParentheses Flag enthalten ist.
Zahlen Eine Sequenz von Ziffern von 0 bis 9.
, Ein kulturspezifisches Gruppentrennzeichen. Das Gruppentrennzeichen der von provider angegebenen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowThousands Flag enthalten ist.
. Ein kulturspezifisches Dezimalzeichensymbol. Das Dezimalstellensymbol der durch provider angegebenen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthalten ist.
fractional_digits Mindestens ein Vorkommen der Ziffer 0. Bruchstellen können nur in value angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthalten ist.
E Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller (wissenschaftlicher) Notation dargestellt wird. Der value Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthalten ist.
exponential_digits Eine Sequenz von Ziffern von 0 bis 9. Der value Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthalten ist.
hexdigits Eine Sequenz von Hexadezimalstellen von 0 bis f oder 0 bis F.

Hinweis

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

Nicht zusammengesetzte NumberStyles Werte Zusätzlich zu Ziffern zulässige Elemente
None Nur Dezimalstellen.
AllowDecimalPoint Das Dezimalzeichen (.) und fractional_digits Elemente. Fractional_digits darf jedoch nur aus einer oder mehreren 0 Ziffern bestehen, oder die -Methode gibt zurückfalse.
AllowExponent Das Zeichen "e" oder "E", das die exponentielle Notation angibt, zusammen mit exponential_digits. Wenn value eine Zahl in exponentieller Notation darstellt, darf sie keine ungleich 00,gebrochene Komponente aufweisen.
AllowLeadingWhite Das ws-Element am Anfang von value.
AllowTrailingWhite Das ws-Element am Ende von value.
AllowLeadingSign Das Vorzeichenelement vor Ziffern.
AllowTrailingSign Das Zeichenelement nach Ziffern.
AllowParentheses Das Zeichenelement in Form von Klammern, die den numerischen Wert einschließen.
AllowThousands Das Gruppentrennzeichen (,)-Element.
AllowCurrencySymbol Das Währungselement ($).
Currency Alle Elemente. Eine value hexadezimale Zahl oder eine Zahl in exponentieller Notation kann jedoch nicht dargestellt werden.
Float Das ws-Element am Anfang oder Ende von value, zeichen am Anfang von valueund das Dezimalzeichen (.). Der value Parameter kann auch die exponentielle Notation verwenden.
Number Die Elemente ws, Vorzeichen, Gruppentrennzeichen (,) und Dezimalstellen (.).
Any Alle Elemente. Eine value hexadezimale Zahl kann jedoch nicht dargestellt werden.

Wenn das NumberStyles.AllowHexSpecifier Flag verwendet wird, value muss es sich um einen Hexadezimalwert handelt. Die einzigen anderen Flags, die in style vorhanden sein können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Enumeration hat ein zusammengesetztes Format, HexNumber, das beide Leerzeichenflags enthält.)

Der provider Parameter ist eine IFormatProvider Implementierung. Die - GetFormat Methode gibt ein NumberFormatInfo -Objekt zurück, das kulturspezifische Informationen zum Format von valuebereitstellt. Der provider Parameter kann einer der folgenden Sein:

  • Ein CultureInfo -Objekt, das die Kultur darstellt, die Formatierungsinformationen bereitstellt. Die - GetFormat Methode gibt das NumberFormatInfo -Objekt zurück, das numerische Formatierungsinformationen für diese Kultur bereitstellt.

  • Ein NumberFormatInfo Objekt, das numerische Formatierungsinformationen bereitstellt. (Die Implementierung von GetFormat gibt sich selbst zurück.)

  • Ein benutzerdefiniertes IFormatProviderObjekt, das implementiert. Ihre GetFormat Methode instanziiert und gibt das Objekt zurück, das NumberFormatInfo Formatierungsinformationen bereitstellt.

Wenn provider ist null, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

Gilt für:

TryParse(String, IFormatProvider, BigInteger)

Quelle:
BigInteger.cs
Quelle:
BigInteger.cs
Quelle:
BigInteger.cs

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

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

Parameter

s
String

Die zu analysierende Zeichenfolge.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

result
BigInteger

Wenn diese Methode zurückgibt, enthält das Ergebnis der erfolgreichen s Analyse oder einen undefinierten Wert bei Fehler.

Gibt zurück

true , wenn s erfolgreich analysiert wurde, falseandernfalls .

Gilt für:

TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)

Quelle:
BigInteger.cs
Quelle:
BigInteger.cs
Quelle:
BigInteger.cs

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

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

Parameter

s
ReadOnlySpan<Char>

Die Spanne der zu analysierenden Zeichen.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

result
BigInteger

Wenn diese Methode zurückgibt, enthält das Ergebnis der erfolgreichen Analyse oder einen nicht definierten sWert bei Fehler.

Gibt zurück

true , wenn s erfolgreich analysiert wurde, falseandernfalls .

Gilt für:

TryParse(String, BigInteger)

Quelle:
BigInteger.cs
Quelle:
BigInteger.cs
Quelle:
BigInteger.cs

Versucht, die Zeichenfolgendarstellung einer Zahl in deren BigInteger-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

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

Parameter

value
String

Die Zeichenfolgendarstellung einer Zahl.

result
BigInteger

Die Rückgabe dieser Methode enthält die BigInteger-Entsprechung der Zahl in value, oder null (0), wenn die Konvertierung nicht ausgeführt werden konnte. Die Konvertierung schlägt fehl, wenn der value-Parameter null ist oder nicht im korrekten Format vorliegt. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn value erfolgreich konvertiert wurde, andernfalls false.

Ausnahmen

value ist null.

Beispiele

Im folgenden Beispiel wird die TryParse(String, BigInteger) -Methode verwendet, um zwei BigInteger Objekte zu instanziieren. Wenn die Konvertierungen erfolgreich sind, multipliziert sie jedes Objekt mit einer anderen Zahl und ruft dann die Compare -Methode auf, um die Beziehung zwischen den beiden Objekten zu bestimmen.

BigInteger number1, number2;
bool succeeded1 = BigInteger.TryParse("-12347534159895123", out number1);
bool succeeded2 = BigInteger.TryParse("987654321357159852", out number2);
if (succeeded1 && succeeded2)
{
   number1 *= 3;
   number2 *= 2;
   switch (BigInteger.Compare(number1, number2))
   {
      case -1:
         Console.WriteLine("{0} is greater than {1}.", number2, number1);
         break;
      case 0:
         Console.WriteLine("{0} is equal to {1}.", number1, number2);
         break;
      case 1:
         Console.WriteLine("{0} is greater than {1}.", number1, number2);
         break;
   }
}
else
{
   if (! succeeded1)
      Console.WriteLine("Unable to initialize the first BigInteger value.");

   if (! succeeded2)
      Console.WriteLine("Unable to initialize the second BigInteger value.");
}
// The example displays the following output:
//      1975308642714319704 is greater than -37042602479685369.
    let mutable number1 = BigInteger.Zero
    let mutable number2 = BigInteger.Zero

    let succeeded1 = BigInteger.TryParse("-12347534159895123", &number1)
    let succeeded2 = BigInteger.TryParse("987654321357159852", &number2)

    if succeeded1 && succeeded2 then
        number1 <- number1 * 3I
        number2 <- number2 * 2I

        match BigInteger.Compare(number1, number2) with
        | -1 -> printfn $"{number2} is greater than {number2}."
        | 0 -> printfn $"{number1} is equal to {number2}."
        | 1
        | _ -> printfn $"{number1} is greater than {number2}."
    else
        if not succeeded1 then
            printfn "Unable to initialize the first BigInteger value."

        if not succeeded2 then
            printfn "Unable to initialize the second BigInteger value."

// The example displays the following output:
//      1975308642714319704 is greater than -37042602479685369.
Dim number1 As BigInteger = BigInteger.Zero
Dim number2 As BigInteger = BigInteger.Zero
Dim succeeded1 As Boolean = BigInteger.TryParse("-12347534159895123", number1)
Dim succeeded2 As Boolean = BigInteger.TryParse("987654321357159852", number2)
If succeeded1 AndAlso succeeded2
   number1 *= 3
   number2 *= 2
   Select Case BigInteger.Compare(number1, number2)
      Case -1
         Console.WriteLine("{0} is greater than {1}.", number2, number1)
      Case 0
         Console.WriteLine("{0} is equal to {1}.", number1, number2)
      Case 1
         Console.WriteLine("{0} is greater than {1}.", number1, number2)
   End Select      
Else
   If Not succeeded1 Then 
      Console.WriteLine("Unable to initialize the first BigInteger value.")
   End If
   If Not succeeded2 Then
      Console.WriteLine("Unable to initialize the second BigInteger value.")
   
   End If
End If
' The example displays the following output:
'      1975308642714319704 is greater than -37042602479685369.

Hinweise

Die TryParse(String, BigInteger) -Methode ähnelt der -Methode, mit dem Parse(String) Unterschied, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt. Diese Methode entfällt die Notwendigkeit, die Ausnahmebehandlung zu verwenden, um zu testen, ob value ein FormatException ungültig ist und nicht erfolgreich analysiert werden kann.

Der value Parameter sollte die Zeichenfolgendarstellung einer Dezimalzahl in der folgenden Form sein:

[ws] [sign] digits[ws]

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

Element BESCHREIBUNG
ws Optionaler Leerraum.
sign Ein optionales Zeichen. Gültige Zeichen werden durch die NumberFormatInfo.NegativeSign Eigenschaften und NumberFormatInfo.PositiveSign der aktuellen Kultur bestimmt.
Zahlen Eine Sequenz von Dezimalstellen im Bereich von 0 bis 9.

Hinweis

Die durch den value Parameter angegebene Zeichenfolge darf keine Gruppentrennzeichen oder Dezimaltrennzeichen enthalten, und sie kann keinen Dezimalteil aufweisen.

Der value Parameter wird mithilfe des Stils NumberStyles.Integer interpretiert. Zusätzlich zu den Dezimalstellen sind nur führende und nachfolgende Leerzeichen mit einem vorangestellten Zeichen zulässig. Rufen Sie die -Methode auf, um die Stilelemente explizit mit den kulturspezifischen Formatierungsinformationen zu definieren, die TryParse(String, NumberStyles, IFormatProvider, BigInteger) in valuevorhanden sein können.

Der value Parameter wird analysiert, indem die Formatierungsinformationen in einem NumberFormatInfo Objekt für die aktuelle Kultur verwendet werden. Weitere Informationen finden Sie unter NumberFormatInfo.CurrentInfo.

Diese Überladung interpretiert alle Ziffern im value Parameter als Dezimalstellen. Um die Zeichenfolgendarstellung einer Hexadezimalzahl zu analysieren, rufen Sie stattdessen die TryParse(String, NumberStyles, IFormatProvider, BigInteger) Überladung auf.

Weitere Informationen

Gilt für:

TryParse(ReadOnlySpan<Char>, BigInteger)

Quelle:
BigInteger.cs
Quelle:
BigInteger.cs
Quelle:
BigInteger.cs

Versucht, die Darstellung einer Zahl, die in der angegebenen schreibgeschützten Zeichenspanne enthalten ist, in ihre Entsprechung BigInteger zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.

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

Parameter

value
ReadOnlySpan<Char>

Die Darstellung einer Zahl als schreibgeschützte Spanne von Zeichen.

result
BigInteger

Die Rückgabe dieser Methode enthält die BigInteger-Entsprechung der Zahl in value, oder null (0), wenn die Konvertierung nicht ausgeführt werden konnte. Die Konvertierung schlägt fehl, wenn der value-Parameter eine leere Zeichenspanne ist oder nicht im richtigen Format vorliegt. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn value erfolgreich konvertiert wurde, andernfalls false.

Weitere Informationen

Gilt für:

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Quelle:
BigInteger.cs
Quelle:
BigInteger.cs
Quelle:
BigInteger.cs

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in das entsprechende BigInteger und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.

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

Parameter

value
String

Die Zeichenfolgendarstellung einer Zahl. Die Zeichenfolge wird unter Verwendung des durch style angegebenen Formats interpretiert.

style
NumberStyles

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

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu value bereitstellt.

result
BigInteger

Die Rückgabe dieser Methode enthält die BigInteger-Entsprechung der Zahl in value, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Die Konvertierung schlägt fehl, wenn der value-Parameter gleich null ist oder nicht in einem Format vorliegt, das mit style kompatibel ist. Dieser Parameter wird nicht initialisiert übergeben.

Gibt zurück

true, wenn der value-Parameter erfolgreich konvertiert wurde, andernfalls false.

Ausnahmen

style ist kein NumberStyles-Wert.

- oder -

style schließt das AllowHexSpecifier-Flag oder HexNumber-Flag mit einem anderen Wert ein.

Beispiele

Im folgenden Beispiel werden einige Aufrufe der TryParse(String, NumberStyles, IFormatProvider, BigInteger) -Methode unter Verwendung verschiedener Kombinationen von Werten für die Parameter und provider ausgeführtstyle.

string numericString;
BigInteger number = BigInteger.Zero;

// Call TryParse with default values of style and provider.
numericString = "  -300   ";
if (BigInteger.TryParse(numericString, NumberStyles.Integer,
                       null, out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with the default value of style and
// a provider supporting the tilde as negative sign.
numericString = "  -300   ";
if (BigInteger.TryParse(numericString, NumberStyles.Integer,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
// Method returns false because of presence of negative sign.
numericString = "  -500   ";
if (BigInteger.TryParse(numericString,
                        NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite,
                        new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with AllowHexSpecifier and a hex value.
numericString = "F14237FFAAC086455192";
if (BigInteger.TryParse(numericString,
                        NumberStyles.AllowHexSpecifier,
                        null, out number))
   Console.WriteLine("'{0}' was converted to {1} (0x{1:x}).",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with AllowHexSpecifier and a negative hex value.
// Conversion fails because of presence of negative sign.
numericString = "-3af";
if (BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with only NumberStyles.None.
// Conversion fails because of presence of white space and sign.
numericString = " -300 ";
if (BigInteger.TryParse(numericString, NumberStyles.None,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
// Conversion fails because the string is formatted for the en-US culture.
numericString = "9,031,425,666,123,546.00";
if (BigInteger.TryParse(numericString, NumberStyles.Any,
                       new CultureInfo("fr-FR"), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
// Conversion succeeds because the string is properly formatted
// For the fr-FR culture.
numericString = "9 031 425 666 123 546,00";
if (BigInteger.TryParse(numericString, NumberStyles.Any,
                       new CultureInfo("fr-FR"), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);
// The example displays the following output:
//    '  -300   ' was converted to -300.
//    Conversion of '  -300   ' to a BigInteger failed.
//    Conversion of '  -500   ' to a BigInteger failed.
//    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
//    Conversion of '-3af' to a BigInteger failed.
//    Conversion of ' -300 ' to a BigInteger failed.
//    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
//    '9 031 425 666 123 546,00' was converted to 9031425666123546.
    // Call TryParse with default values of style and provider.
    let numericString = "  -300   "

    match BigInteger.TryParse(numericString, NumberStyles.Integer, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with the default value of style and
    // a provider supporting the tilde as negative sign.
    let numericString = "  -300   "

    match BigInteger.TryParse(numericString, NumberStyles.Integer, new BigIntegerFormatProvider()) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
    // Method returns false because of presence of negative sign.
    let numericString = "  -500   "

    match
        BigInteger.TryParse(
            numericString,
            NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite,
            new BigIntegerFormatProvider()
        )
    with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with AllowHexSpecifier and a hex value.
    let numericString = "F14237FFAAC086455192"

    match BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}, or 0x{number:x}."
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with AllowHexSpecifier and a negative hex value.
    // Conversion fails because of presence of negative sign.
    let numericString = "-3af"

    match BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}, or 0x{number:x}."
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with only NumberStyles.None.
    // Conversion fails because of presence of white space and sign.
    let numericString = " -300 "

    match BigInteger.TryParse(numericString, NumberStyles.None, new BigIntegerFormatProvider()) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
    // Conversion fails because the string is formatted for the en-US culture.
    let numericString = "9,031,425,666,123,546.00"

    match BigInteger.TryParse(numericString, NumberStyles.Any, new CultureInfo("fr-FR")) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
    // Conversion succeeds because the string is properly formatted
    // For the fr-FR culture.
    let numericString = "9 031 425 666 123 546,00"

    match BigInteger.TryParse(numericString, NumberStyles.Any, new CultureInfo("fr-FR")) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

// The example displays the following output:
//    '  -300   ' was converted to -300.
//    Conversion of '  -300   ' to a BigInteger failed.
//    Conversion of '  -500   ' to a BigInteger failed.
//    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
//    Conversion of '-3af' to a BigInteger failed.
//    Conversion of ' -300 ' to a BigInteger failed.
//    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
//    '9 031 425 666 123 546,00' was converted to 9031425666123546.
Dim numericString As String
Dim number As BigInteger = BigInteger.Zero

' Call TryParse with default values of style and provider.
numericString = "  -300   "
If BigInteger.TryParse(numericString, NumberStyles.Integer,
                       Nothing, number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with the default value of style and 
' a provider supporting the tilde as negative sign.
numericString = "  -300   "
If BigInteger.TryParse(numericString, NumberStyles.Integer,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
' Method returns false because of presence of negative sign.
numericString = "  -500   "
If BigInteger.TryParse(numericString,
                    NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite,
                    New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with AllowHexSpecifier and a hex value.
numericString = "F14237FFAAC086455192"
If BigInteger.TryParse(numericString,
                    NumberStyles.AllowHexSpecifier,
                    Nothing, number) Then
   Console.WriteLine("'{0}' was converted to {1} (0x{1:x}).",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with AllowHexSpecifier and a negative hex value.
' Conversion fails because of presence of negative sign.
numericString = "-3af"
If BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with only NumberStyles.None.
' Conversion fails because of presence of white space and sign.
numericString = " -300 "
If BigInteger.TryParse(numericString, NumberStyles.None,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If 
                                            
' Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
' Conversion fails because the string is formatted for the en-US culture.
numericString = "9,031,425,666,123,546.00"
If BigInteger.TryParse(numericString, NumberStyles.Any,
                       New CultureInfo("fr-FR"), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If

' Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
' Conversion succeeds because the string is properly formatted 
' For the fr-FR culture.
numericString = "9 031 425 666 123 546,00"
If BigInteger.TryParse(numericString, NumberStyles.Any,
                       New CultureInfo("fr-FR"), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If
' The example displays the following output:
'    '  -300   ' was converted to -300.
'    Conversion of '  -300   ' to a BigInteger failed.
'    Conversion of '  -500   ' to a BigInteger failed.
'    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
'    Conversion of '-3af' to a BigInteger failed.
'    Conversion of ' -300 ' to a BigInteger failed.
'    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
'    '9 031 425 666 123 546,00' was converted to 9031425666123546.

Eine Reihe der einzelnen Aufrufe der TryParse(String, NumberStyles, IFormatProvider, BigInteger) -Methode übergeben eine instance der folgenden BigIntegerFormatProvider Klasse, die eine Tilde (~) als negatives Vorzeichen definiert.

public class BigIntegerFormatProvider : IFormatProvider
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(NumberFormatInfo))
      {
         NumberFormatInfo numberFormat = new NumberFormatInfo();
         numberFormat.NegativeSign = "~";
         return numberFormat;
      }
      else
      {
         return null;
      }
   }
}
type BigIntegerFormatProvider() =
    interface IFormatProvider with
        member _.GetFormat(formatType: Type) =
            if formatType = typeof<NumberFormatInfo> then
                let numberFormat = new NumberFormatInfo()
                numberFormat.NegativeSign <- "~"
                numberFormat
            else
                null
Public Class BigIntegerFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                            Implements IFormatProvider.GetFormat
      If formatType Is GetType(NumberFormatInfo) Then
         Dim numberFormat As New NumberFormatInfo
         numberFormat.NegativeSign = "~"
         Return numberFormat
      Else
         Return Nothing
      End If      
   End Function
End Class

Hinweise

Die TryParse(String, NumberStyles, IFormatProvider, BigInteger) -Methode ähnelt der -Methode, mit dem Parse(String, NumberStyles, IFormatProvider) Unterschied, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt. Diese Methode entfällt die Notwendigkeit, die Ausnahmebehandlung zu verwenden, um zu testen, ob value ein FormatException ungültig ist und nicht erfolgreich analysiert werden kann.

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

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

Wenn der style Parameter enthält AllowHexSpecifier, kann der value Parameter die folgenden Elemente enthalten:

[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 von value angezeigt werden, wenn style das NumberStyles.AllowLeadingWhite Flag enthalten ist, oder am Ende von value , wenn style das NumberStyles.AllowTrailingWhite Flag enthalten ist.
$ Ein kulturspezifisches Währungssymbol. Seine Position in der Zeichenfolge wird durch die CurrencyPositivePattern Eigenschaft des Objekts definiert, das NumberFormatInfo von der GetFormat -Methode des provider Parameters zurückgegeben wird. Das Währungssymbol kann in value angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthalten ist.
sign Ein optionales Zeichen. Das Zeichen kann am Anfang von value angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthalten ist, und es kann am Ende value von angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthalten ist. Klammern können in value verwendet werden, um einen negativen Wert anzugeben, wenn style das NumberStyles.AllowParentheses Flag enthalten ist.
Zahlen Eine Sequenz von Ziffern von 0 bis 9.
, Ein kulturspezifisches Gruppentrennzeichen. Das Gruppentrennzeichen der von provider angegebenen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowThousands Flag enthalten ist.
. Ein kulturspezifisches Dezimalzeichensymbol. Das Dezimalstellensymbol der durch provider angegebenen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthalten ist.
fractional_digits Mindestens ein Vorkommen der Ziffer 0. Bruchstellen können nur in value angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthalten ist.
E Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller (wissenschaftlicher) Notation dargestellt wird. Der value Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthalten ist.
exponential_digits Eine Sequenz von Ziffern von 0 bis 9. Der value Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthalten ist.
hexdigits Eine Sequenz von Hexadezimalstellen von 0 bis f oder 0 bis F.

Hinweis

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

Eine Zeichenfolge nur mit Dezimalstellen (die dem NumberStyles.None Flag entspricht) analysiert immer erfolgreich. Die meisten der verbleibenden NumberStyles Member steuert Elemente, die in dieser Eingabezeichenfolge möglicherweise vorhanden sind, aber nicht vorhanden sein müssen. Die folgende Tabelle gibt an, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die in valuevorhanden sein können.

Nicht zusammengesetzte NumberStyles Werte Zulässige Elemente im Wert zusätzlich zu Ziffern
None Nur Dezimalstellen.
AllowDecimalPoint Das Dezimaltrennzeichen (.) und fractional_digits Elemente. Fractional_digits darf jedoch nur aus einer oder mehreren 0 Ziffern bestehen, oder die -Methode gibt zurückfalse.
AllowExponent Das Zeichen "e" oder "E", das die exponentielle Notation angibt, zusammen mit exponential_digits. Wenn value eine Zahl in exponentieller Notation darstellt, kann sie keine Bruchkomponente ungleich 0 (Null) aufweisen.
AllowLeadingWhite Das ws-Element am Anfang von value.
AllowTrailingWhite Das ws-Element am Ende von value.
AllowLeadingSign Das Vorzeichenelement vor Ziffern.
AllowTrailingSign Das Zeichenelement nach Ziffern.
AllowParentheses Das Zeichenelement in Form von Klammern, die den numerischen Wert einschließen.
AllowThousands Das Gruppentrennzeichen (,)-Element.
AllowCurrencySymbol Das Währungselement ($).
Currency Alle Elemente. Kann jedoch value keine hexadezimale Zahl oder eine Zahl in exponentieller Notation darstellen.
Float Das ws-Element am Anfang oder Ende von value, signieren am Anfang von valueund das Dezimaltrennzeichen (.). Der value Parameter kann auch exponentielle Notation verwenden.
Number Die Elemente ws, sign, group separator (,) und decimal point (.)
Any Alle Elemente. Kann jedoch value keine Hexadezimalzahl darstellen.

Wichtig

Wenn Sie die TryParse -Methode verwenden, um die Zeichenfolgendarstellung eines BigInteger Von der ToString -Methode ausgegebenen Werts zu roundtripen, sollten Sie die BigInteger.ToString(String) -Methode mit dem Formatbezeichner "R" verwenden, um die Zeichenfolgendarstellung des BigInteger Werts zu generieren. Andernfalls behält die Zeichenfolgendarstellung des BigInteger nur die 50 wichtigsten Ziffern des ursprünglichen Werts bei, und daten gehen möglicherweise verloren, wenn Sie die TryParse -Methode zum Wiederherstellen des Werts BigInteger verwenden.

Wenn das NumberStyles.AllowHexSpecifier Flag verwendet wird, value muss ein Hexadezimalwert sein. Die einzigen anderen Flags, die in style vorhanden sein können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Enumeration weist ein zusammengesetztes Format auf, HexNumberdas beide Leerzeichenflags enthält.)

Hinweis

Wenn value die Zeichenfolgendarstellung einer Hexadezimalzahl ist, kann ihr keine Dekoration (z 0x . B. oder &h) vorangestellt werden, die sie als hexadezimale Zahl unterscheidet. Dies führt dazu, dass die Konvertierung fehlschlägt.

Wenn value eine hexadezimale Zeichenfolge ist, interpretiert value die Methode als negative Zahl, die TryParse(String, NumberStyles, IFormatProvider, BigInteger) mithilfe der Komplementdarstellung von zwei gespeichert wird, wenn die ersten beiden Hexadezimalstellen größer oder gleich 0x80sind. Anders ausgedrückt: Die -Methode interpretiert das Bit der höchsten Ordnung des ersten Byte in value als Vorzeichenbit. Um sicherzustellen, dass eine Hexadezimalzeichenfolge ordnungsgemäß als positive Zahl interpretiert wird, muss die erste Ziffer in value den Wert 0 (null) aufweisen. Beispielsweise interpretiert die -Methode als negativer 0x80 Wert, interpretiert aber entweder 0x080 oder 0x0080 als positiver Wert. Das folgende Beispiel veranschaulicht den Unterschied zwischen hexadezimalen Zeichenfolgen, die negative und positive Werte darstellen.

using System;
using System.Globalization;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      string[] hexStrings = { "80", "E293", "F9A2FF", "FFFFFFFF",
                              "080", "0E293", "0F9A2FF", "0FFFFFFFF",
                              "0080", "00E293", "00F9A2FF", "00FFFFFFFF" };
      BigInteger number = BigInteger.Zero;

      foreach (string hexString in hexStrings)
      {
         if (BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier,
                                 null, out number))
            Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
         else
            Console.WriteLine("Cannot convert '{0}' to a BigInteger.", hexString);
      }
   }
}
// The example displays the following output:
//       Converted 0x80 to -128.
//       Converted 0xE293 to -7533.
//       Converted 0xF9A2FF to -417025.
//       Converted 0xFFFFFFFF to -1.
//       Converted 0x080 to 128.
//       Converted 0x0E293 to 58003.
//       Converted 0x0F9A2FF to 16360191.
//       Converted 0x0FFFFFFFF to 4294967295.
//       Converted 0x0080 to 128.
//       Converted 0x00E293 to 58003.
//       Converted 0x00F9A2FF to 16360191.
//       Converted 0x00FFFFFFFF to 4294967295.
open System.Globalization
open System.Numerics

let hexStrings =
    [| "80"
       "E293"
       "F9A2FF"
       "FFFFFFFF"
       "080"
       "0E293"
       "0F9A2FF"
       "0FFFFFFFF"
       "0080"
       "00E293"
       "00F9A2FF"
       "00FFFFFFFF" |]

for hexString in hexStrings do
    match BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"Converted 0x{hexString} to {number}."
    | _ -> printfn $"Cannot convert '{hexString}' to a BigInteger."

// The example displays the following output:
//       Converted 0x80 to -128.
//       Converted 0xE293 to -7533.
//       Converted 0xF9A2FF to -417025.
//       Converted 0xFFFFFFFF to -1.
//       Converted 0x080 to 128.
//       Converted 0x0E293 to 58003.
//       Converted 0x0F9A2FF to 16360191.
//       Converted 0x0FFFFFFFF to 4294967295.
//       Converted 0x0080 to 128.
//       Converted 0x00E293 to 58003.
//       Converted 0x00F9A2FF to 16360191.
//       Converted 0x00FFFFFFFF to 4294967295.
Imports System.Globalization
Imports System.Numerics

Module Example
   Public Sub Main()
      Dim hexStrings() As String = { "80", "E293", "F9A2FF", "FFFFFFFF", 
                                     "080", "0E293", "0F9A2FF", "0FFFFFFFF",  
                                     "0080", "00E293", "00F9A2FF", "00FFFFFFFF" }
      Dim number As BigInteger = BigInteger.Zero
      
      For Each hexString As String In hexStrings
         If BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier, 
                                Nothing, number) Then
            Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
         Else
            Console.WriteLine("Cannot convert '{0}' to a BigInteger.", hexString)
         End If
      Next         
   End Sub
End Module
' The example displays the following output:
'       Converted 0x80 to -128.
'       Converted 0xE293 to -7533.
'       Converted 0xF9A2FF to -417025.
'       Converted 0xFFFFFFFF to -1.
'       Converted 0x080 to 128.
'       Converted 0x0E293 to 58003.
'       Converted 0x0F9A2FF to 16360191.
'       Converted 0x0FFFFFFFF to 4294967295.
'       Converted 0x0080 to 128.
'       Converted 0x00E293 to 58003.
'       Converted 0x00F9A2FF to 16360191.
'       Converted 0x00FFFFFFFF to 4294967295.

Der provider Parameter ist eine IFormatProvider Implementierung. Die - GetFormat Methode gibt ein NumberFormatInfo -Objekt zurück, das kulturspezifische Informationen über das Format von valuebereitstellt. Der provider Parameter kann einer der folgenden Parameter sein:

  • Ein CultureInfo -Objekt, das die Kultur darstellt, die Formatierungsinformationen bereitstellt. Die - GetFormat Methode gibt das NumberFormatInfo -Objekt zurück, das numerische Formatierungsinformationen für diese Kultur bereitstellt.

  • Ein NumberFormatInfo -Objekt, das numerische Formatierungsinformationen bereitstellt. (Seine Implementierung von GetFormat gibt sich einfach selbst zurück.)

  • Ein benutzerdefiniertes IFormatProviderObjekt, das implementiert. Die - GetFormat Methode instanziiert und gibt das NumberFormatInfo -Objekt zurück, das Formatierungsinformationen bereitstellt.

Wenn provider ist null, wird das NumberFormatInfo -Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

Gilt für: