Freigeben über

BigInteger.Parse Methode

  • Referenz

Definition

Namespace:
System.Numerics
Assembly:
System.Runtime.Numerics.dll
Assembly:
System.Numerics.dll
Assembly:
netstandard.dll

Wandelt die angegebene Zeichenfolgendarstellung einer Zahl in ihre BigInteger-Entsprechung um.

Überlädt

Parse(String)

Wandelt die angegebene Zeichenfolgendarstellung einer Zahl in ihre BigInteger-Entsprechung um.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analysiert eine Spanne von Zeichen in einen Wert.
Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die BigInteger-Entsprechung.
Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die BigInteger-Entsprechung.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konvertiert die-Darstellung einer Zahl, die in der angegebenen schreibgeschützten Spanne von Zeichen enthalten ist, in einem angegebenen Stil in die jeweilige BigInteger-Entsprechung.
Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende BigInteger.

Parse(String)

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

Wandelt die angegebene Zeichenfolgendarstellung einer Zahl in ihre BigInteger-Entsprechung um.

public:
 static System::Numerics::BigInteger Parse(System::String ^ value);
public static System.Numerics.BigInteger Parse (string value);
static member Parse : string -> System.Numerics.BigInteger
Public Shared Function Parse (value As String) As BigInteger

Parameter

value
String

Eine Zeichenfolge, die die zu konvertierende Zahl enthält.

Gibt zurück

BigInteger

Ein Wert, der der im value-Parameter angegebenen Zahl entspricht.

Ausnahmen

ArgumentNullException

value ist null.

FormatException

value weist nicht das richtige Format auf.

Beispiele

Im folgenden Beispiel wird die Parse(String) -Methode verwendet, um zwei BigInteger Objekte zu instanziieren. Es multipliziert jedes Objekt mit einer anderen Zahl und ruft dann die Compare -Methode auf, um die Beziehung zwischen den beiden Werten zu bestimmen.

string stringToParse = String.Empty;
try
{
   // Parse two strings.
   string string1, string2;
   string1 = "12347534159895123";
   string2 = "987654321357159852";
   stringToParse = string1;
   BigInteger number1 = BigInteger.Parse(stringToParse);
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number1);
   stringToParse = string2;
   BigInteger number2 = BigInteger.Parse(stringToParse);
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number2);
   // Perform arithmetic operations on the two numbers.
   number1 *= 3;
   number2 *= 2;
   // Compare the numbers.
   int result = BigInteger.Compare(number1, number2);
   switch (result)
   {
      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;
   }
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse {0}.", stringToParse);
}
// The example displays the following output:
//    Converted '12347534159895123' to 12,347,534,159,895,123.
//    Converted '987654321357159852' to 987,654,321,357,159,852.
//    1975308642714319704 is greater than 37042602479685369.

    let mutable stringToParse = ""

    try
        // Parse two strings.
        let string1 = "12347534159895123"
        let string2 = "987654321357159852"
        stringToParse <- string1
        let number1 = BigInteger.Parse stringToParse
        printfn $"Converted '{stringToParse}' to {number1:N0}."
        stringToParse <- string2
        let number2 = BigInteger.Parse stringToParse
        printfn $"Converted '{stringToParse}' to {number2:N0}."
        // Perform arithmetic operations on the two numbers.
        let number1 = number1 * bigint 3
        let number2 = number2 * bigint 2
        // Compare the numbers.
        let result = BigInteger.Compare(number1, number2)

        match result with
        | -1 -> printfn $"{number2:N0} is greater than {number1:N0}."
        | 0 -> printfn $"{number1:N0} is equal to {number2:N0}."
        | 1
        | _ -> printfn $"{number1:N0} is greater than {number2:N0}."
    with :? FormatException ->
        printfn $"Unable to parse {stringToParse}."

// The example displays the following output:
//    Converted '12347534159895123' to 12,347,534,159,895,123.
//    Converted '987654321357159852' to 987,654,321,357,159,852.
//    1975308642714319704 is greater than 37042602479685369.

Dim stringToParse As String = String.Empty
Try
   ' Parse two strings.
   Dim string1, string2 As String
   string1 = "12347534159895123"
   string2 = "987654321357159852"
   stringToParse = string1
   Dim number1 As BigInteger = BigInteger.Parse(stringToParse)
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number1)
   stringToParse = string2
   Dim number2 As BigInteger = BigInteger.Parse(stringToParse)
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number2)
   ' Perform arithmetic operations on the two numbers.
   number1 *= 3
   number2 *= 2
   ' Compare the numbers.
   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      
Catch e As FormatException
   Console.WriteLine("Unable to parse {0}.", stringToParse)
End Try
' The example displays the following output:
'    Converted '12347534159895123' to 12,347,534,159,895,123.
'    Converted '987654321357159852' to 987,654,321,357,159,852.
'    1975308642714319704 is greater than 37042602479685369.

Hinweise

Der value Parameter sollte die Zeichenfolgendarstellung einer Zahl im folgenden Format 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 Vorzeichen werden durch die NumberFormatInfo.NegativeSign Eigenschaften und NumberFormatInfo.PositiveSign der aktuellen Kultur bestimmt.
Zahlen Eine Sequenz von Ziffern im Bereich von 0 bis 9. Alle führenden Nullen werden ignoriert.

Hinweis

Die durch den value -Parameter angegebene Zeichenfolge wird mithilfe des Stils NumberStyles.Integer interpretiert. Sie kann keine Gruppentrennzeichen oder Dezimaltrennzeichen enthalten und keinen Dezimalteil haben.

Der value Parameter wird mithilfe der Formatierungsinformationen in einem System.Globalization.NumberFormatInfo Objekt analysiert, das für die aktuelle Systemkultur initialisiert wird. Weitere Informationen finden Sie unter NumberFormatInfo.CurrentInfo. Verwenden Parse(String, IFormatProvider) Sie die -Methode, um eine Zeichenfolge mithilfe der Formatierungsinformationen einer bestimmten Kultur zu analysieren.

Wichtig

Wenn Sie die Parse -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 Parse -Methode zum Wiederherstellen des Werts BigInteger verwenden.

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Char>, IFormatProvider)

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

Analysiert eine Spanne von Zeichen in einen Wert.

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

Parameter

s
ReadOnlySpan<Char>

Die Spanne der zu analysierenden Zeichen.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

Gibt zurück

BigInteger

Das Ergebnis der Analyse svon .

Implementiert

Parse(ReadOnlySpan<Char>, IFormatProvider)

Gilt für:

Parse(String, NumberStyles)

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

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die BigInteger-Entsprechung.

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

Parameter

value
String

Eine Zeichenfolge, die eine zu konvertierende Zahl enthält.

style
NumberStyles

Eine bitweise Kombination der Enumerationswerte, die das zulässige Format von value angeben.

Gibt zurück

BigInteger

Ein Wert, der der im value-Parameter angegebenen Zahl entspricht.

Ausnahmen

ArgumentException

style ist kein NumberStyles-Wert.

- oder -

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

ArgumentNullException

value ist null.

FormatException

value folgt nicht dem mit NumberStyles angegebenen Eingabemuster.

Beispiele

Im folgenden Beispiel werden Aufrufe der Parse(String, NumberStyles) -Methode mit mehreren möglichen Werten für den style Parameter veranschaulicht. Es veranschaulicht, wie eine Zeichenfolge als Hexadezimalwert interpretiert wird und wie Leerzeichen und Zeichensymbole nicht zugelassen werden.

BigInteger number;
// Method should succeed (white space and sign allowed)
number = BigInteger.Parse("   -68054   ", NumberStyles.Integer);
Console.WriteLine(number);
// Method should succeed (string interpreted as hexadecimal)
number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier);
Console.WriteLine(number);
// Method call should fail: sign not allowed
try
{
   number = BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite
                                            | NumberStyles.AllowTrailingWhite);
   Console.WriteLine(number);
}
catch (FormatException e)
{
   Console.WriteLine(e.Message);
}
// Method call should fail: white space not allowed
try
{
   number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign);
   Console.WriteLine(number);
}
catch (FormatException e)
{
   Console.WriteLine(e.Message);
}
//
// The method produces the following output:
//
//     -68054
//     426068
//     Input string was not in a correct format.
//     Input string was not in a correct format.

    let number = BigInteger.Parse("   -68054   ", NumberStyles.Integer)
    printfn $"{number}"
    let number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier)
    printfn $"{number}"

    try
        let number =
            BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite)

        printfn $"{number}"
    with :? FormatException as e ->
        printfn $"{e.Message}"

    try
        let number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign)
        printfn $"{number}"
    with :? FormatException as e ->
        printfn $"{e.Message}"
// The method produces the following output:
//     -68054
//     426068
//     Input string was not in a correct format.
//     Input string was not in a correct format.

Dim number As BigInteger 
' Method should succeed (white space and sign allowed)
number = BigInteger.Parse("   -68054   ", NumberStyles.Integer)
Console.WriteLine(number)
' Method should succeed (string interpreted as hexadecimal)
number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier)
Console.WriteLine(number)
' Method call should fail: sign not allowed
Try
   number = BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite _
                                            Or NumberStyles.AllowTrailingWhite)
   Console.WriteLine(number)
Catch e As FormatException
   Console.WriteLine(e.Message)
End Try                                                     
' Method call should fail: white space not allowed
Try
   number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign)
   Console.WriteLine(number)
Catch e As FormatException
   Console.WriteLine(e.Message)
End Try    
'
' The method produces the following output:
'
'     -68054
'     426068
'     Input string was not in a correct format.
'     Input string was not in a correct format.

Hinweise

Der style Parameter definiert die Stilelemente (z. B. Leerzeichen, positives oder negatives Vorzeichen, Gruppentrennzeichensymbol oder Dezimaltrennzeichen), die im value Parameter zulässig sind, damit der Analysevorgang erfolgreich ist. styles muss eine Kombination von Bitflags aus der NumberStyles Enumeration sein. Der style -Parameter macht diese Methodenüberladung nützlich, wenn value die Zeichenfolgendarstellung eines Hexadezimalwerts enthält, wenn das Zahlensystem (dezimal oder hexadezimal) nur value zur Laufzeit bekannt ist oder wenn Sie Leerzeichen oder ein Zeichensymbol in valuenicht zulassen möchten.

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 style enthält NumberStyles.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, und es kann am Ende von value angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag enthält.
$ Ein kulturspezifisches Währungssymbol. Seine Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyNegativePattern Eigenschaften und NumberFormatInfo.CurrencyPositivePattern der aktuellen Kultur definiert. Das Währungssymbol der aktuellen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthält.
sign Ein optionales Zeichen. Das Zeichen kann am Anfang von value angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann am Ende von value angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthält. Klammern können in value verwendet 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 Gruppentrennzeichensymbol. Das Gruppentrennzeichen der aktuellen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowThousands Flag enthält.
. Ein kulturspezifisches Dezimaltrennzeichen. Das Dezimalzeichensymbol der aktuellen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält. Nur die Ziffer 0 kann als Bruchziffer angezeigt werden, damit der Analysevorgang erfolgreich ist. wenn fractional_digits eine andere Ziffer enthält, wird eine FormatException ausgelöst.
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.
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 mit nur Ziffern (die dem NumberStyles.None Format entsprechen) analysiert immer erfolgreich. Die meisten der verbleibenden NumberStyles Member steuern Elemente, die in der 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.

Wert vom Typ NumberStyles Zusätzlich zu Ziffern zulässige value Elemente
None Nur das Digits-Element .
AllowDecimalPoint Die Elemente Dezimalstellen (.) und Bruchstellen .
AllowExponent Das Zeichen "e" oder "E", das die exponentielle Notation angibt, zusammen mit exponential_digits.
AllowLeadingWhite Das ws-Element am Anfang von value.
AllowTrailingWhite Das ws-Element am Ende von value.
AllowLeadingSign Das Zeichenelement am Anfang von value.
AllowTrailingSign Das Zeichenelement am Ende von value.
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 wsElemente , , sign, Gruppentrennzeichen (,) und Dezimalstellen (.).
Any Alle Elemente. Eine value hexadezimale Zahl kann jedoch nicht dargestellt werden.

Wichtig

Wenn Sie die Parse -Methode verwenden, um die Zeichenfolgendarstellung eines BigInteger von der ToString -Methode ausgegebenen Werts zu runden, 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 Parse -Methode zum Wiederherstellen des Werts BigInteger verwenden.

Im Gegensatz zu den anderen NumberStyles Werten, die bestimmte Stilelemente in valuezulassen, aber nicht erfordern, bedeutet der NumberStyles.AllowHexSpecifier Formatvorlagenwert, dass die einzelnen numerischen Zeichen in value immer als hexadezimale Zeichen interpretiert werden. Gültige Hexadezimalzeichen sind 0-9, A-F und a-f. Die einzigen anderen Flags, die mit dem style -Parameter kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Enumeration enthält eine zusammengesetzte Zahlenart, HexNumber, die beide Leerzeichenflags enthält.)

Hinweis

Wenn value die Zeichenfolgendarstellung einer hexadezimalen Zahl 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 es sich um eine hexadezimale value Zeichenfolge handelt, interpretiert die Methode als negative Zahl, die Parse(String, NumberStyles) 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 Reihenfolge des ersten Byte in value als Zeichenbit. Um sicherzustellen, dass eine hexadezimale Zeichenfolge ordnungsgemäß als positive Zahl interpretiert wird, muss die erste Ziffer in value den Wert 0 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" };
      foreach (string hexString in hexStrings)
      {
         BigInteger number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
      }
   }
}
// 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
    let number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
    printfn $"Converted 0x{hexString} to {number:N0}."
// 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" }
      For Each hexString As String In hexStrings
         Dim number As BigInteger = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
      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 value Parameter wird analysiert, indem die Formatierungsinformationen in einem NumberFormatInfo Objekt verwendet werden, das für die aktuelle Systemkultur initialisiert wird. Um die Kultur anzugeben, deren Formatierungsinformationen für den Analysevorgang verwendet werden, rufen Sie die Parse(String, NumberStyles, IFormatProvider) Überladung auf.

Weitere Informationen

Gilt für:

Parse(String, IFormatProvider)

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

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die BigInteger-Entsprechung.

public:
 static System::Numerics::BigInteger Parse(System::String ^ value, IFormatProvider ^ provider);
public:
 static System::Numerics::BigInteger Parse(System::String ^ value, IFormatProvider ^ provider) = IParsable<System::Numerics::BigInteger>::Parse;
public static System.Numerics.BigInteger Parse (string value, IFormatProvider provider);
public static System.Numerics.BigInteger Parse (string value, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> System.Numerics.BigInteger
Public Shared Function Parse (value As String, provider As IFormatProvider) As BigInteger

Parameter

value
String

Eine Zeichenfolge, die eine zu konvertierende Zahl enthält.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu value bereitstellt.

Gibt zurück

BigInteger

Ein Wert, der der im value-Parameter angegebenen Zahl entspricht.

Implementiert

Parse(String, IFormatProvider)

Ausnahmen

ArgumentNullException

value ist null.

FormatException

value weist nicht das richtige Format auf.

Beispiele

Die folgenden Beispiele zeigen zwei Möglichkeiten, die Tilde (~) als negatives Zeichen für Formatierungswerte BigInteger zu definieren. Beachten Sie, dass ihr Code die BigInteger -Methode aufrufen und das -Objekt übergeben NumberFormatInfo muss, das Formatierungsinformationen bereitstellt, um die BigInteger.ToString(IFormatProvider) Werte im gleichen Format wie die ursprünglichen Zeichenfolgen anzuzeigen.

Im ersten Beispiel wird eine Klasse definiert, die die GetFormat -Methode implementiert und verwendet, um das Objekt zurückzugeben, das NumberFormatInfo Formatierungsinformationen IFormatProvider bereitstellt.

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 = 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

Ein BigInteger Objekt kann dann mit dem folgenden Code instanziiert werden:

BigInteger number = BigInteger.Parse("~6354129876", new BigIntegerFormatProvider());
// Display value using same formatting information
Console.WriteLine(number.ToString(new BigIntegerFormatProvider()));
// Display value using formatting of current culture
Console.WriteLine(number);

let number = BigInteger.Parse("~6354129876", BigIntegerFormatProvider())
printfn $"{number.ToString(BigIntegerFormatProvider())}"
printfn $"{number}"

Dim number As BigInteger = BigInteger.Parse("~6354129876", New BigIntegerFormatProvider)
' Display value using same formatting information
Console.WriteLine(number.ToString(New BigIntegerFormatProvider))
' Display value using formatting of current culture
Console.WriteLine(number)

Das zweite Beispiel ist einfacher. Das -Objekt, das NumberFormatInfo Formatierungsinformationen bereitstellt, wird an den provider Parameter übergeben.

NumberFormatInfo fmt = new NumberFormatInfo();
fmt.NegativeSign = "~";

BigInteger number = BigInteger.Parse("~6354129876", fmt);
// Display value using same formatting information
Console.WriteLine(number.ToString(fmt));
// Display value using formatting of current culture
Console.WriteLine(number);

let fmt = NumberFormatInfo()
fmt.NegativeSign <- "~"

let number = BigInteger.Parse("~6354129876", fmt)
printfn $"{number.ToString fmt}"
printfn $"{number}"

Dim fmt As New NumberFormatInfo()
fmt.NegativeSign = "~"

Dim number As BigInteger = BigInteger.Parse("~6354129876", fmt)
' Display value using same formatting information
Console.WriteLine(number.ToString(fmt))
' Display value using formatting of current culture
Console.WriteLine(number)

Hinweise

Der value Parameter sollte die Zeichenfolgendarstellung einer Zahl 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 des NumberFormatInfo Objekts bestimmt, das von der provider -Methode des GetFormat Objekts zurückgegeben wird.
Zahlen Eine Sequenz von Ziffern zwischen 0 und 9. Alle führenden Nullen werden ignoriert.

Hinweis

Die durch den value Parameter angegebene Zeichenfolge wird mithilfe des Stils NumberStyles.Integer interpretiert. Sie kann keine Gruppentrennzeichen oder Dezimaltrennzeichen enthalten und keinen Dezimalteil aufweisen.

Wichtig

Wenn Sie die Parse -Methode verwenden, um die Zeichenfolgendarstellung eines BigInteger von der ToString -Methode ausgegebenen Werts zu runden, 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 Parse -Methode zum Wiederherstellen des Werts BigInteger verwenden.

Der provider Parameter ist eine IFormatProvider Implementierung, deren GetFormat Methode ein NumberFormatInfo Objekt zurückgibt, das kulturspezifische Formatierungsinformationen bereitstellt. Wenn die Parse(String, IFormatProvider) Methode aufgerufen wird, ruft sie die Methode des providerGetFormat Parameters auf und übergibt ihr ein Type Objekt, das den NumberFormatInfo Typ darstellt. Die GetFormat -Methode gibt dann das NumberFormatInfo -Objekt zurück, das Informationen zum Format des value Parameters bereitstellt. Es gibt drei Möglichkeiten, den provider Parameter zum Bereitstellen benutzerdefinierter Formatierungsinformationen für den Analysevorgang zu verwenden:

  • Sie können ein CultureInfo -Objekt übergeben, das die Kultur darstellt, die Formatierungsinformationen bereitstellt. Die - GetFormat Methode gibt das NumberFormatInfo -Objekt zurück, das numerische Formatierungsinformationen für diese Kultur bereitstellt.

  • Sie können das tatsächliche NumberFormatInfo Objekt übergeben, das numerische Formatierungsinformationen bereitstellt. (Die Implementierung von GetFormat gibt sich selbst zurück.)

  • Sie können ein benutzerdefiniertes IFormatProviderObjekt übergeben, das implementiert. Ihre GetFormat Methode instanziiert und gibt das Objekt zurück, das NumberFormatInfo Formatierungsinformationen bereitstellt.

Wenn provider ist null, wird die Formatierung von value basierend auf dem NumberFormatInfo Objekt der aktuellen Kultur interpretiert.

Weitere Informationen

Gilt für:

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

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

Konvertiert die-Darstellung einer Zahl, die in der angegebenen schreibgeschützten Spanne von Zeichen enthalten ist, in einem angegebenen Stil in die jeweilige BigInteger-Entsprechung.

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

Parameter

value
ReadOnlySpan<Char>

Eine schreibgeschützte Spanne von Zeichen, die die zu konvertierende Zahl enthält.

style
NumberStyles

Eine bitweise Kombination der Enumerationswerte, die das zulässige Format von value angeben.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu value bereitstellt.

Gibt zurück

BigInteger

Ein Wert, der der im value-Parameter angegebenen Zahl entspricht.

Implementiert

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Ausnahmen

ArgumentException

style ist kein NumberStyles-Wert.

- oder -

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

ArgumentNullException

value ist null.

FormatException

value folgt nicht dem mit style angegebenen Eingabemuster.

Hinweise

Der style -Parameter definiert die Stilelemente (z. B. Leerzeichen, positives oder negatives Zeichensymbol, Gruppentrennzeichenzeichen oder Dezimalzeichensymbol), die im value Parameter zulässig sind, damit der Analysevorgang erfolgreich ausgeführt werden kann. styles muss eine Kombination von Bitflags aus der NumberStyles Enumeration sein. Der style Parameter macht diese Methodenüberladung nützlich, wenn value sie die Darstellung eines hexadezimalen Werts enthält, wenn das von dargestellte value Zahlensystem (dezimal oder hexadezimal) nur zur Laufzeit bekannt ist oder wenn Sie Leerzeichen oder ein Zeichensymbol in valuenicht zulassen möchten.

Abhängig vom Wert von stylekann der value Parameter die folgenden Elemente enthalten:

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

Wenn style enthält NumberStyles.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, und es kann am Ende von value angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag enthält.
$ Ein kulturspezifisches Währungssymbol. Seine Position in value wird durch die NumberFormatInfo.CurrencyNegativePattern Eigenschaften und NumberFormatInfo.CurrencyPositivePattern der durch den provider -Parameter angegebenen Kultur definiert. Das Währungssymbol der aktuellen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthält.
sign Ein optionales Zeichen. Das Zeichen kann am Anfang von value angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann am Ende von value angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthält. Klammern können in value verwendet 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 Gruppentrennzeichensymbol. Das Gruppentrennzeichensymbol der von provider angegebenen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowThousands Flag enthält.
. Ein kulturspezifisches Dezimaltrennzeichen. Das Dezimaltrennzeichen der kultur, die durch bezeichnet wird provider , kann in value angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält. Nur die Ziffer 0 kann als Bruchziffer angezeigt werden, damit der Analysevorgang erfolgreich ist. wenn fractional_digits eine andere Ziffer enthält, wird eine FormatException ausgelöst.
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.
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.

Ein value -Wert mit nur Ziffern (die der NumberStyles.None Formatvorlage entsprechen) analysiert immer erfolgreich. Die meisten der verbleibenden NumberStyles Member steuert Elemente, die möglicherweise vorhanden sind, aber nicht vorhanden sein müssen, in value. Die folgende Tabelle gibt an, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die in valuevorhanden sein können.

NumberStyles-Wert Zulässige Elemente im Wert zusätzlich zu Ziffern
None Nur das Digits-Element .
AllowDecimalPoint Das Dezimaltrennzeichen (.) und die Bruchstellenelemente .
AllowExponent Das Zeichen "e" oder "E", das die exponentielle Notation angibt. zusammen mit exponential_digits.
AllowLeadingWhite Das ws-Element am Anfang von value.
AllowTrailingWhite Das ws-Element am Ende von value.
AllowLeadingSign Das Zeichenelement am Anfang von value.
AllowTrailingSign Das Zeichenelement am Ende von value.
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 wsElemente , , signGruppierungstrennzeichen (,) und Dezimalstellen (.).
Any Alle Elemente. Kann jedoch value keine Hexadezimalzahl darstellen.

Im Gegensatz zu den anderen NumberStyles Werten, die das Vorhandensein bestimmter Stilelemente in valuezulassen, aber nicht erfordern, bedeutet der NumberStyles.AllowHexSpecifier Formatvorlagenwert, dass die einzelnen numerischen Zeichen in value immer als Hexadezimalzeichen interpretiert werden. Gültige Hexadezimalzeichen sind 0-9, A-F und a-f. Die einzigen anderen Flags, die mit dem style -Parameter kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Enumeration enthält eine zusammengesetzte Zahlenformatvorlage, HexNumber, die beide Leerzeichenflags enthält.)

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

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

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

  • Ein benutzerdefiniertes Objekt, das die GetFormat -Methode implementiert und verwendet, um das Objekt, das NumberFormatInfo Formatierungsinformationen IFormatProvider bereitstellt, zu instanziieren und zurückzugeben.

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

Weitere Informationen

Gilt für:

Parse(String, NumberStyles, IFormatProvider)

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

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende BigInteger.

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

Parameter

value
String

Eine Zeichenfolge, die eine zu konvertierende Zahl enthält.

style
NumberStyles

Eine bitweise Kombination der Enumerationswerte, die das zulässige Format von value angeben.

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu value bereitstellt.

Gibt zurück

BigInteger

Ein Wert, der der im value-Parameter angegebenen Zahl entspricht.

Implementiert

Parse(String, NumberStyles, IFormatProvider)

Ausnahmen

ArgumentException

style ist kein NumberStyles-Wert.

- oder -

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

ArgumentNullException

value ist null.

FormatException

value folgt nicht dem mit style angegebenen Eingabemuster.

Beispiele

Im folgenden Beispiel werden mehrere Aufrufe der Parse(String, NumberStyles, IFormatProvider) -Methode ausgeführt, wobei verschiedene Kombinationen von Werten für die style Parameter und provider verwendet werden.

// Call parse with default values of style and provider
Console.WriteLine(BigInteger.Parse("  -300   ",
                  NumberStyles.Integer, CultureInfo.CurrentCulture));
// Call parse with default values of style and provider supporting tilde as negative sign
Console.WriteLine(BigInteger.Parse("   ~300  ",
                                   NumberStyles.Integer, new BigIntegerFormatProvider()));
// Call parse with only AllowLeadingWhite and AllowTrailingWhite
// Exception thrown because of presence of negative sign
try
{
   Console.WriteLine(BigInteger.Parse("    ~300   ",
                                NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite,
                                new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// Call parse with only AllowHexSpecifier
// Exception thrown because of presence of negative sign
try
{
   Console.WriteLine(BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier,
                                      new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// Call parse with only NumberStyles.None
// Exception thrown because of presence of white space and sign
try
{
   Console.WriteLine(BigInteger.Parse(" -300 ", NumberStyles.None,
                                      new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// The example displays the followingoutput:
//       -300
//       -300
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.

    // Call parse with default values of style and provider
    printfn $"""{BigInteger.Parse("  -300   ", NumberStyles.Integer, CultureInfo.CurrentCulture)}"""

    // Call parse with default values of style and provider supporting tilde as negative sign
    printfn $"""{BigInteger.Parse("   ~300  ", NumberStyles.Integer, new BigIntegerFormatProvider())}"""

    // Call parse with only AllowLeadingWhite and AllowTrailingWhite
    // Exception thrown because of presence of negative sign
    try
        printfn
            $"""{BigInteger.Parse(
                     "    ~300   ",
                     NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite,
                     new BigIntegerFormatProvider()
                 )}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"

    // Call parse with only AllowHexSpecifier
    // Exception thrown because of presence of negative sign
    try
        printfn $"""{BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier, new BigIntegerFormatProvider())}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"

    // Call parse with only NumberStyles.None
    // Exception thrown because of presence of white space and sign
    try
        printfn $"""{BigInteger.Parse(" -300 ", NumberStyles.None, new BigIntegerFormatProvider())}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"
// The example displays the followingoutput:
//       -300
//       -300
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.

' Call parse with default values of style and provider
Console.WriteLine(BigInteger.Parse("  -300   ", _
                  NumberStyles.Integer, CultureInfo.CurrentCulture))
' Call parse with default values of style and provider supporting tilde as negative sign
Console.WriteLine(BigInteger.Parse("   ~300  ", _
                                   NumberStyles.Integer, New BigIntegerFormatProvider()))
' Call parse with only AllowLeadingWhite and AllowTrailingWhite
' Exception thrown because of presence of negative sign
Try
   Console.WriteLIne(BigInteger.Parse("    ~300   ", _
                                      NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try                                   
' Call parse with only AllowHexSpecifier
' Exception thrown because of presence of negative sign
Try
   Console.WriteLIne(BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try                                 
' Call parse with only NumberStyles.None
' Exception thrown because of presence of white space and sign
Try
   Console.WriteLIne(BigInteger.Parse(" -300 ", NumberStyles.None, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try
' The example displays the following output:
'       -300
'       -300
'       FormatException:
'          The value could not be parsed.
'       FormatException:
'          The value could not be parsed.
'       FormatException:
'          The value could not be parsed.

Eine Anzahl der einzelnen Aufrufe der Parse(String, NumberStyles, IFormatProvider) -Methode übergibt eine instance der folgenden BigIntegerFormatProvider Klasse, die eine Tilde (~) als negatives Zeichen 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 = 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

Der style Parameter definiert die Stilelemente (z. B. Leerzeichen, positives oder negatives Vorzeichen, Gruppentrennzeichensymbol oder Dezimaltrennzeichen), die im value Parameter zulässig sind, damit der Analysevorgang erfolgreich ist. styles muss eine Kombination von Bitflags aus der NumberStyles Enumeration sein. Der style -Parameter macht diese Methodenüberladung nützlich, wenn value die Zeichenfolgendarstellung eines Hexadezimalwerts enthält, wenn das Zahlensystem (dezimal oder hexadezimal) nur value zur Laufzeit bekannt ist oder wenn Sie Leerzeichen oder ein Zeichensymbol in valuenicht zulassen möchten.

Abhängig vom Wert von stylekann der value Parameter die folgenden Elemente enthalten:

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

Wenn style enthält NumberStyles.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, und es kann am Ende von value angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag enthält.
$ Ein kulturspezifisches Währungssymbol. Seine Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyNegativePattern Eigenschaften und NumberFormatInfo.CurrencyPositivePattern der Kultur definiert, die durch den provider -Parameter angegeben wird. Das Währungssymbol der aktuellen Kultur kann in value angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthält.
sign Ein optionales Zeichen. Das Zeichen kann am Anfang von value angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann am Ende von value angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthält. Klammern können in value verwendet 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 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 Dezimalpunktsymbol der Kultur, die durch provider bezeichnet wird, kann in value angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthalten ist. Nur die Ziffer 0 kann als Bruchziffer angezeigt werden, damit der Analysevorgang erfolgreich ist. wenn fractional_digits eine andere Ziffer enthält, wird ein FormatException ausgelöst.
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.
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.

Eine Zeichenfolge nur mit Ziffern (die dem NumberStyles.None Format entspricht) analysiert immer erfolgreich. Die meisten der verbleibenden NumberStyles Member-Steuerelementelemente, die möglicherweise vorhanden sind, aber nicht erforderlich sind, um in der Eingabezeichenfolge vorhanden zu sein. Die folgende Tabelle gibt an, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die möglicherweise in valuevorhanden sind.

NumberStyles-Wert Zusätzlich zu Ziffern zulässige Elemente
None Nur das Digits-Element .
AllowDecimalPoint Die Elemente Dezimalstellen (.) und Bruchstellen .
AllowExponent Das Zeichen "e" oder "E", das die exponentielle Notation angibt. zusammen mit exponential_digits.
AllowLeadingWhite Das ws-Element am Anfang von value.
AllowTrailingWhite Das ws-Element am Ende von value.
AllowLeadingSign Das Zeichenelement am Anfang von value.
AllowTrailingSign Das Zeichenelement am Ende von value.
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 wsElemente , , sign, Gruppentrennzeichen (,) und Dezimalstellen (.).
Any Alle Elemente. Eine value hexadezimale Zahl kann jedoch nicht dargestellt werden.

Wichtig

Wenn Sie die Parse -Methode verwenden, um die Zeichenfolgendarstellung eines BigInteger von der ToString -Methode ausgegebenen Werts zu runden, 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 Parse -Methode zum Wiederherstellen des Werts BigInteger verwenden.

Im Gegensatz zu den anderen NumberStyles Werten, die das Vorhandensein bestimmter Stilelemente in valuezulassen, aber nicht erfordern, bedeutet der NumberStyles.AllowHexSpecifier Formatvorlagenwert, dass die einzelnen numerischen Zeichen in value immer als hexadezimale Zeichen interpretiert werden. Gültige Hexadezimalzeichen sind 0-9, A-F und a-f. Die einzigen anderen Flags, die mit dem style -Parameter kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Enumeration enthält eine zusammengesetzte Zahlenart, HexNumber, die beide Leerzeichenflags enthält.)

Hinweis

Wenn value die Zeichenfolgendarstellung einer hexadezimalen Zahl 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 es sich um eine hexadezimale value Zeichenfolge handelt, interpretiert die Methode als negative Zahl, die Parse(String, NumberStyles) 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 Reihenfolge des ersten Byte in value als Zeichenbit. Um sicherzustellen, dass eine hexadezimale Zeichenfolge ordnungsgemäß als positive Zahl interpretiert wird, muss die erste Ziffer in value den Wert 0 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" };
      foreach (string hexString in hexStrings)
      {
         BigInteger number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
      }
   }
}
// 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
    let number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
    printfn $"Converted 0x{hexString} to {number:N0}."
// 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" }
      For Each hexString As String In hexStrings
         Dim number As BigInteger = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
      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 zum Format von valuebereitstellt. provider In der Regel kann es sich um eine der folgenden Aktionen handelt:

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

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

  • Ein benutzerdefiniertes Objekt, das die GetFormat -Methode implementiert und verwendet, um das Objekt, das NumberFormatInfo Formatierungsinformationen IFormatProvider bereitstellt, zu instanziieren und zurückzugeben.

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

Weitere Informationen

Gilt für: