Udostępnij za pośrednictwem

BigInteger.Parse Metoda

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Numerics
Zestaw:
System.Runtime.Numerics.dll
Zestaw:
System.Numerics.dll
Zestaw:
netstandard.dll

Konwertuje reprezentację ciągu liczby na BigInteger równoważną.

Przeciążenia

Parse(String)

Konwertuje reprezentację ciągu liczby na BigInteger równoważną.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analizuje zakres znaków w wartości.
Parse(String, NumberStyles)

Konwertuje reprezentację ciągu liczby w określonym stylu na BigInteger jej odpowiednik.
Parse(String, IFormatProvider)

Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na BigInteger jego odpowiednik.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konwertuje reprezentację liczby zawartej w określonym zakresie znaków tylko do odczytu w określonym stylu na BigInteger jego odpowiednik.
Parse(String, NumberStyles, IFormatProvider)

Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na BigInteger jego odpowiednik.

Parse(String)

Źródło:
BigInteger.cs
Źródło:
BigInteger.cs
Źródło:
BigInteger.cs

Konwertuje reprezentację ciągu liczby na BigInteger równoważną.

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

Parametry

value
String

Ciąg zawierający liczbę, którą należy przekształcić.

Zwraca

BigInteger

Wartość równoważna liczbie określonej w parametrze value .

Wyjątki

ArgumentNullException

value to null.

FormatException

value nie jest w poprawnym formacie.

Przykłady

W poniższym przykładzie użyto metody do Parse(String) utworzenia wystąpienia dwóch BigInteger obiektów. Mnoży każdy obiekt przez inną liczbę, a następnie wywołuje Compare metodę w celu określenia relacji między dwiema wartościami.

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.

Uwagi

Parametr value powinien być reprezentacją ciągu liczby w poniższym formularzu.

[ws] [znak] cyfry[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W tabeli poniżej opisano każdy element.

Element Opis
Ws Opcjonalny odstęp.
sign Opcjonalny znak. Prawidłowe znaki są określane przez NumberFormatInfo.NegativeSign właściwości i NumberFormatInfo.PositiveSign bieżącej kultury.
Cyfr Sekwencja cyfr od 0 do 9. Wszystkie zera wiodące są ignorowane.

Uwaga

Ciąg określony przez value parametr jest interpretowany przy użyciu NumberStyles.Integer stylu. Nie może zawierać żadnych separatorów grup ani separatorów dziesiętnych, a także mieć części dziesiętnej.

Parametr value jest analizowany przy użyciu informacji o formatowaniu w obiekcie zainicjowanym System.Globalization.NumberFormatInfo dla bieżącej kultury systemu. Aby uzyskać więcej informacji, zobacz NumberFormatInfo.CurrentInfo. Aby przeanalizować ciąg przy użyciu informacji o formatowaniu określonej kultury, użyj Parse(String, IFormatProvider) metody .

Ważne

Jeśli używasz Parse metody , aby zaokrąglić ciąg reprezentujący BigInteger wartość, która została wygenerowana przez ToString metodę, należy użyć BigInteger.ToString(String) metody z specyfikatorem formatu "R", aby wygenerować reprezentację BigInteger ciągu wartości. W przeciwnym razie reprezentacja BigInteger ciągu zachowuje tylko 50 najbardziej znaczących cyfr oryginalnej wartości, a dane mogą zostać utracone, gdy użyjesz Parse metody w celu przywrócenia BigInteger wartości.

Zobacz też

Dotyczy

Parse(ReadOnlySpan<Char>, IFormatProvider)

Źródło:
BigInteger.cs
Źródło:
BigInteger.cs
Źródło:
BigInteger.cs

Analizuje zakres znaków w wartości.

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

Parametry

s
ReadOnlySpan<Char>

Zakres znaków do przeanalizowania.

provider
IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury dotyczące selementu .

Zwraca

BigInteger

Wynik analizy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Dotyczy

Parse(String, NumberStyles)

Źródło:
BigInteger.cs
Źródło:
BigInteger.cs
Źródło:
BigInteger.cs

Konwertuje reprezentację ciągu liczby w określonym stylu na BigInteger jej odpowiednik.

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

Parametry

value
String

Ciąg zawierający liczbę, którą należy przekształcić.

style
NumberStyles

Bitowa kombinacja wartości wyliczenia, które określają dozwolony format .value

Zwraca

BigInteger

Wartość równoważna liczbie określonej w parametrze value .

Wyjątki

ArgumentException

style nie jest wartością NumberStyles .

-lub-

style zawiera flagę AllowHexSpecifier lub HexNumber wraz z inną wartością.

ArgumentNullException

value to null.

FormatException

value nie jest zgodny ze wzorcem wejściowym określonym przez NumberStyles.

Przykłady

Poniższy przykład ilustruje wywołania Parse(String, NumberStyles) metody z kilkoma możliwymi wartościami parametru style . Ilustruje ona sposób interpretowania ciągu jako wartości szesnastkowej oraz sposobu nie zezwalania na spacje i symbole znaku.

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.

Uwagi

Parametr style definiuje elementy stylu (takie jak biały znak, symbol znaku dodatniego lub ujemnego, symbol separatora grupy lub symbol punktu dziesiętnego), które są dozwolone w parametrze value dla operacji analizy, aby zakończyć się powodzeniem. styles musi być kombinacją flag bitowych z wyliczenia NumberStyles . Parametr style sprawia, że ta metoda jest przydatna, gdy value zawiera reprezentację ciągu wartości szesnastkowej, gdy system liczbowy (dziesiętny lub szesnastkowy) reprezentowany przez value jest znany tylko w czasie wykonywania, lub gdy chcesz uniemożliwić białe znaki lub symbol znaku w value.

W zależności od wartości parametr może stylevalue zawierać następujące elementy:

[ws] [][$znak][cyfry,]cyfry[.fractional_digits][E[znak]exponential_digits][ws]

Jeśli style parametr zawiera NumberStyles.AllowHexSpecifierparametr , value może zawierać następujące elementy:

[ws] hexdigits[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W tabeli poniżej opisano każdy element.

Element Opis
Ws Opcjonalny odstęp. Biały znak może pojawić się na początku, value jeśli zawiera flagę NumberStyles.AllowLeadingWhite i może pojawić się na końcuvalue, jeśli style zawiera flagę NumberStyles.AllowTrailingWhitestyle.
$ Symbol waluty specyficzny dla kultury. Jego pozycja w ciągu jest definiowana przez NumberFormatInfo.CurrencyNegativePattern właściwości i NumberFormatInfo.CurrencyPositivePattern bieżącej kultury. Symbol waluty bieżącej kultury może być wyświetlany, value jeśli style zawiera flagę NumberStyles.AllowCurrencySymbol .
sign Opcjonalny znak. Znak może pojawić się na początku, value jeśli style zawiera flagę NumberStyles.AllowLeadingSign i może pojawić się na końcu value , jeśli style zawiera flagę NumberStyles.AllowTrailingSign . Nawiasy mogą służyć do wskazywania wartości ujemnej, value jeśli style zawiera flagę NumberStyles.AllowParentheses .
Cyfr

fractional_digits

exponential_digits		 Sekwencja cyfr od 0 do 9. W przypadku fractional_digits tylko cyfra 0 jest prawidłowa.
, Symbol separatora grupy specyficzny dla kultury. Separator grupy bieżącej kultury może pojawić się, value jeśli style zawiera flagę NumberStyles.AllowThousands .
. Symbol dziesiętny specyficzny dla kultury. Symbol punktu dziesiętnego bieżącej kultury może pojawić się, value jeśli style zawiera flagę NumberStyles.AllowDecimalPoint . Tylko cyfra 0 może być wyświetlana jako cyfra ułamkowa dla operacji analizy, która zakończy się powodzeniem; jeśli fractional_digits zawiera inną cyfrę FormatException , zostanie zgłoszony.
E Znak „e” lub „E”, który wskazuje, że wartość jest reprezentowana w zapisie wykładniczym (naukowym). Parametr value może reprezentować liczbę w notacji wykładniczej, jeśli style zawiera flagę NumberStyles.AllowExponent .
hexdigits Sekwencja cyfr szesnastkowych od 0 do f lub od 0 do F.

Uwaga

Wszelkie znaki zakończenia NUL (U+0000) w obiekcie s są ignorowane przez operację analizowania, niezależnie od wartości argumentu style .

Ciąg z cyframi (odpowiadający NumberStyles.None stylowi) zawsze jest analizowanych pomyślnie. Większość pozostałych NumberStyles elementów członkowskich kontroluje, które mogą być obecne, ale nie są wymagane do obecności w ciągu wejściowym. Poniższa tabela wskazuje, jak poszczególne NumberStyles elementy członkowskie wpływają na elementy, które mogą być obecne w elemecie value.

NumberStyles Wartość Elementy dozwolone value oprócz cyfr
None Tylko element cyfry .
AllowDecimalPoint Elementy punktów dziesiętnych (.) i cyfr ułamkowych .
AllowExponent Znak "e" lub "E", który wskazuje notację wykładniczą wraz z exponential_digits.
AllowLeadingWhite Element ws na początku value.
AllowTrailingWhite Element ws na końcu valueelementu .
AllowLeadingSign Element znaku na początku value.
AllowTrailingSign Element znaku na końcu elementu value.
AllowParentheses Element znaku w postaci nawiasów otaczających wartość liczbową.
AllowThousands Element separatora grupy (,).
AllowCurrencySymbol Element określający walutę ($).
Currency Wszystkie elementy. value Nie można jednak reprezentować liczby szesnastkowej ani liczby w notacji wykładniczej.
Float Element ws na początku lub na końcu value, znak na początku value, i symbol dziesiętny (.). Parametr value może również używać notacji wykładniczej.
Number wsElementy separatora grup (sign,) i separatora dziesiętnego (.).
Any Wszystkie elementy. value Nie można jednak reprezentować liczby szesnastkowej.

Ważne

Jeśli używasz Parse metody , aby zaokrąglić ciąg reprezentujący BigInteger wartość, która została wygenerowana przez ToString metodę, należy użyć BigInteger.ToString(String) metody z specyfikatorem formatu "R", aby wygenerować reprezentację BigInteger ciągu wartości. W przeciwnym razie reprezentacja BigInteger ciągu zachowuje tylko 50 najbardziej znaczących cyfr oryginalnej wartości, a dane mogą zostać utracone, gdy użyjesz Parse metody w celu przywrócenia BigInteger wartości.

W przeciwieństwie do innych NumberStyles wartości, które umożliwiają, ale nie wymagają, obecność określonych elementów stylu w elemecie , NumberStyles.AllowHexSpecifier wartość stylu oznacza, że poszczególne znaki liczbowe w value obiekcie valuesą zawsze interpretowane jako znaki szesnastkowe. Prawidłowe znaki szesnastkowe to 0-9, A-F i a-f. Jedyną inną flagą, którą można połączyć z parametrem style , są NumberStyles.AllowLeadingWhite i NumberStyles.AllowTrailingWhite. (Wyliczenie NumberStyles zawiera styl liczb złożonych, HexNumber, który zawiera obie flagi odstępu).

Uwaga

Jeśli value jest reprezentacją ciągu liczby szesnastkowej, nie może być poprzedzona żadną dekoracją (taką jak 0x lub &h), która rozróżnia ją jako liczbę szesnastkowa. To powoduje niepowodzenie konwersji.

Jeśli value jest ciągiem szesnastkowym, Parse(String, NumberStyles) metoda interpretuje value jako liczbę ujemną przechowywaną przy użyciu reprezentacji uzupełniającej dwóch pierwszych cyfr szesnastkowych jest większa lub równa 0x80. Innymi słowy, metoda interpretuje bit o najwyższej kolejności pierwszego bajtu w value postaci bitu znaku. Aby upewnić się, że ciąg szesnastkowy jest poprawnie interpretowany jako liczba dodatnia, pierwsza cyfra w value musi mieć wartość zero. Na przykład metoda interpretuje 0x80 jako wartość ujemną, ale interpretuje wartość 0x080 lub 0x0080 jako wartość dodatnią. W poniższym przykładzie przedstawiono różnicę między ciągami szesnastkowymi reprezentującymi wartości ujemne i dodatnie.

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.

Parametr value jest analizowany przy użyciu informacji o formatowaniu w obiekcie zainicjowanym NumberFormatInfo dla bieżącej kultury systemu. Aby określić kulturę, której informacje dotyczące formatowania są używane do operacji analizowania, wywołaj Parse(String, NumberStyles, IFormatProvider) przeciążenie.

Zobacz też

Dotyczy

Parse(String, IFormatProvider)

Źródło:
BigInteger.cs
Źródło:
BigInteger.cs
Źródło:
BigInteger.cs

Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na BigInteger jego odpowiednik.

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

Parametry

value
String

Ciąg zawierający liczbę, którą należy przekształcić.

provider
IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury dotyczące valueelementu .

Zwraca

BigInteger

Wartość równoważna liczbie określonej w parametrze value .

Implementuje

Parse(String, IFormatProvider)

Wyjątki

ArgumentNullException

value to null.

FormatException

value nie jest w poprawnym formacie.

Przykłady

W poniższych przykładach przedstawiono dwa sposoby definiowania tyldy (~) jako znaku ujemnego na potrzeby formatowania BigInteger wartości. Należy pamiętać, że aby wyświetlić BigInteger wartości w tym samym formacie co oryginalne ciągi, kod musi wywołać metodę BigInteger.ToString(IFormatProvider) i przekazać go do NumberFormatInfo obiektu udostępniającego informacje o formatowaniu.

Pierwszy przykład definiuje klasę, która implementuje IFormatProvider i używa GetFormat metody , aby zwrócić NumberFormatInfo obiekt, który udostępnia informacje o formatowaniu.

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

Następnie BigInteger można utworzyć wystąpienie obiektu za pomocą następującego kodu:

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)

Drugi przykład jest bardziej prosty. Przekazuje NumberFormatInfo on obiekt, który dostarcza informacje o formatowaniu do parametru provider .

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)

Uwagi

Parametr value powinien być reprezentacją ciągu liczby w następującym formularzu:

[ws] [znak] cyfry[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W tabeli poniżej opisano każdy element.

Element Opis
Ws Opcjonalny odstęp.
sign Opcjonalny znak. Prawidłowe znaki są określane przez NumberFormatInfo.NegativeSign właściwości NumberFormatInfo i NumberFormatInfo.PositiveSign obiektu zwracanego przez metodę provider obiektuGetFormat.
Cyfr Sekwencja cyfr od 0 do 9. Wszystkie zera wiodące są ignorowane.

Uwaga

Ciąg określony przez value parametr jest interpretowany przy użyciu NumberStyles.Integer stylu. Nie może zawierać żadnych separatorów grup ani separatorów dziesiętnych, a także mieć części dziesiętnej.

Ważne

Jeśli używasz Parse metody , aby zaokrąglić ciąg reprezentujący BigInteger wartość, która została wygenerowana przez ToString metodę, należy użyć BigInteger.ToString(String) metody z specyfikatorem formatu "R", aby wygenerować reprezentację BigInteger ciągu wartości. W przeciwnym razie reprezentacja BigInteger ciągu zachowuje tylko 50 najbardziej znaczących cyfr oryginalnej wartości, a dane mogą zostać utracone, gdy użyjesz Parse metody w celu przywrócenia BigInteger wartości.

Parametr provider jest implementacją IFormatProvider , której GetFormat metoda zwraca NumberFormatInfo obiekt, który dostarcza informacji o formatowaniu specyficznym dla kultury. Parse(String, IFormatProvider) Po wywołaniu metody wywołuje metodę provider parametru GetFormat i przekazuje go do obiektu reprezentującego TypeNumberFormatInfo typ. Następnie GetFormat metoda zwraca NumberFormatInfo obiekt, który zawiera informacje o formacie parametru value . Istnieją trzy sposoby używania parametru provider do podawania niestandardowych informacji o formatowaniu do operacji analizowania:

  • Można przekazać obiekt reprezentujący kulturę CultureInfo , która dostarcza informacje o formatowaniu. Metoda GetFormat zwraca NumberFormatInfo obiekt, który udostępnia informacje o formatowaniu liczbowym dla tej kultury.

  • Możesz przekazać rzeczywisty NumberFormatInfo obiekt, który udostępnia informacje o formatowaniu liczbowym. (Jego implementacja GetFormat po prostu zwraca się).

  • Można przekazać obiekt niestandardowy, który implementuje IFormatProviderobiekt . Metoda GetFormat tworzy wystąpienie i zwraca NumberFormatInfo obiekt, który udostępnia informacje o formatowaniu.

Jeśli provider jest to null, formatowanie jest value interpretowane na NumberFormatInfo podstawie obiektu bieżącej kultury.

Zobacz też

Dotyczy

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Źródło:
BigInteger.cs
Źródło:
BigInteger.cs
Źródło:
BigInteger.cs

Konwertuje reprezentację liczby zawartej w określonym zakresie znaków tylko do odczytu w określonym stylu na jego BigInteger odpowiednik.

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

Parametry

value
ReadOnlySpan<Char>

Zakres znaków tylko do odczytu zawierający liczbę do przekonwertowania.

style
NumberStyles

Bitowa kombinacja wartości wyliczenia, które określają dozwolony format .value

provider
IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury dotyczące valueelementu .

Zwraca

BigInteger

Wartość równoważna liczbie określonej w parametrze value .

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Wyjątki

ArgumentException

style nie jest wartością NumberStyles .

-lub-

style zawiera flagę AllowHexSpecifier lub HexNumber wraz z inną wartością.

ArgumentNullException

value to null.

FormatException

value nie jest zgodny ze wzorcem wejściowym określonym przez style.

Uwagi

Parametr style definiuje elementy stylu (takie jak biały znak, symbol znaku dodatniego lub ujemnego, symbol separatora grupy lub symbol punktu dziesiętnego), które są dozwolone w parametrze value dla operacji analizy, aby zakończyć się powodzeniem. styles musi być kombinacją flag bitowych z wyliczenia NumberStyles . Parametr style sprawia, że ta metoda jest przydatna, gdy value zawiera reprezentację wartości szesnastkowej, gdy system liczbowy (dziesiętny lub szesnastkowy) reprezentowany przez value jest znany tylko w czasie wykonywania, lub gdy chcesz uniemożliwić białe znaki lub symbol znaku w value.

W zależności od wartości parametr może stylevalue zawierać następujące elementy:

[ws] [$][znak][cyfry,]cyfry[.fractional_digits][E[znak]exponential_digits][ws]

Jeśli style parametr zawiera NumberStyles.AllowHexSpecifierparametr , value może zawierać następujące elementy:

[ws] hexdigits[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W tabeli poniżej opisano każdy element.

Element Opis
Ws Opcjonalny odstęp. Białe znaki mogą pojawić się na początku value , jeśli style zawiera flagę NumberStyles.AllowLeadingWhite , i może pojawić się na końcu value , jeśli style zawiera flagę NumberStyles.AllowTrailingWhite .
$ Symbol waluty specyficzny dla kultury. Jego pozycja w value pliku jest definiowana NumberFormatInfo.CurrencyNegativePattern przez właściwości i NumberFormatInfo.CurrencyPositivePattern kultury wskazanej provider przez parametr . Symbol waluty bieżącej kultury może pojawić się, value jeśli style zawiera flagę NumberStyles.AllowCurrencySymbol .
sign Opcjonalny znak. Znak może pojawić się na początku value , jeśli style zawiera flagę NumberStyles.AllowLeadingSign i może pojawić się na końcu value , jeśli style zawiera flagę NumberStyles.AllowTrailingSign . Nawiasy mogą służyć value do wskazywania wartości ujemnej, jeśli style zawiera flagę NumberStyles.AllowParentheses .
Cyfr

fractional_digits

exponential_digits		 Sekwencja cyfr od 0 do 9. W przypadku fractional_digits tylko cyfra 0 jest prawidłowa.
, Symbol separatora grupy specyficzny dla kultury. Symbol separatora grup określonej przez provider kulturę może pojawić się w pliku , value jeśli style zawiera flagę NumberStyles.AllowThousands .
. Symbol dziesiętny specyficzny dla kultury. Symbol punktu dziesiętnego kultury wyznaczonej przez provider program może pojawić się w value pliku , jeśli style zawiera flagę NumberStyles.AllowDecimalPoint . Tylko cyfra 0 może być wyświetlana jako cyfra ułamkowa, aby operacja analizy powiodła się; jeśli fractional_digits zawiera dowolną inną cyfrę FormatException , jest zgłaszana wartość .
E Znak „e” lub „E”, który wskazuje, że wartość jest reprezentowana w zapisie wykładniczym (naukowym). Parametr value może reprezentować liczbę w notacji wykładniczej, jeśli style zawiera flagę NumberStyles.AllowExponent .
hexdigits Sekwencja cyfr szesnastkowych od 0 do f lub od 0 do F.

Uwaga

Wszystkie znaki NUL zakończenia (U+0000) w s obiekcie są ignorowane przez operację analizowania, niezależnie od wartości argumentu style .

Element value z tylko cyframi (odpowiadający NumberStyles.None stylowi) zawsze analizuje się pomyślnie. Większość pozostałych NumberStyles elementów członkowskich kontroluje, które mogą być obecne, ale nie muszą być obecne, w .value W poniższej tabeli przedstawiono, jak poszczególne NumberStyles elementy członkowskie wpływają na elementy, które mogą być obecne w programie value.

Wartość wyliczenia NumberStyles Dodatkowe (poza cyframi) elementy dozwolone w wartości
None Tylko element digits .
AllowDecimalPoint Elementy separatora dziesiętnego (.) i cyfr ułamkowych .
AllowExponent Znak „e” lub znak „E”, co oznacza zapis wykładniczy. wraz z exponential_digits.
AllowLeadingWhite Element ws na początku .value
AllowTrailingWhite Element ws na końcu elementu value.
AllowLeadingSign Element znaku na początku .value
AllowTrailingSign Element znaku na końcu elementu value.
AllowParentheses Element znaku w postaci nawiasów otaczających wartość liczbową.
AllowThousands Element separatora grupy (,).
AllowCurrencySymbol Element określający walutę ($).
Currency Wszystkie elementy. value Nie można jednak reprezentować liczby szesnastkowej ani liczby w notacji wykładniczej.
Float Element ws na początku lub na końcu valueznaku na początku , i symbol separatora dziesiętnego value(.). Parametr value może również używać notacji wykładniczej.
Number wsElementy separatora grup , sign(,) i separatora dziesiętnego (.).
Any Wszystkie elementy. value Nie można jednak reprezentować liczby szesnastkowej.

W przeciwieństwie do innych NumberStyles wartości, które umożliwiają, ale nie wymagają obecności określonych elementów stylu w valueobiekcie , NumberStyles.AllowHexSpecifier wartość stylu oznacza, że poszczególne znaki liczbowe w value obiekcie są zawsze interpretowane jako znaki szesnastkowe. Prawidłowe znaki szesnastkowe to 0-9, A-F i a-f. Jedynymi innymi flagami, które można połączyć z parametrem style , są NumberStyles.AllowLeadingWhite i NumberStyles.AllowTrailingWhite. (Wyliczenie NumberStyles zawiera styl liczby złożonej, HexNumber, który zawiera obie flagi odstępu).

Parametr provider jest implementacją IFormatProvider . Metoda GetFormat zwraca NumberFormatInfo obiekt, który dostarcza informacji specyficznych dla kultury o formacie value. provider Zazwyczaj może to być dowolny z następujących elementów:

  • CultureInfo Obiekt reprezentujący kulturę, która dostarcza informacje o formatowaniu liczbowym. Metoda GetFormat zwraca NumberFormatInfo obiekt, który udostępnia informacje o formatowaniu liczbowym.

  • NumberFormatInfo Obiekt, który udostępnia informacje o formatowaniu. (Jego implementacja GetFormat samego zwraca się).

  • Obiekt niestandardowy, który implementuje IFormatProvider metodę GetFormat i używa jej do utworzenia wystąpienia i zwrócenia NumberFormatInfo obiektu, który udostępnia informacje o formatowaniu.

Jeśli provider parametr ma nullwartość , NumberFormatInfo używany jest obiekt bieżącej kultury.

Zobacz też

Dotyczy

Parse(String, NumberStyles, IFormatProvider)

Źródło:
BigInteger.cs
Źródło:
BigInteger.cs
Źródło:
BigInteger.cs

Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na BigInteger jego odpowiednik.

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

Parametry

value
String

Ciąg zawierający liczbę, którą należy przekształcić.

style
NumberStyles

Bitowa kombinacja wartości wyliczenia, które określają dozwolony format .value

provider
IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury.value

Zwraca

BigInteger

Wartość równoważna liczbie określonej w parametrze value .

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Wyjątki

ArgumentException

style nie jest wartością NumberStyles .

-lub-

style zawiera flagę AllowHexSpecifier lub HexNumber wraz z inną wartością.

ArgumentNullException

value to null.

FormatException

value program nie jest zgodny ze wzorcem wejściowym określonym przez style.

Przykłady

Poniższy przykład wykonuje kilka wywołań metody Parse(String, NumberStyles, IFormatProvider) przy użyciu różnych kombinacji wartości dla style parametrów i provider .

// 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.

Liczba pojedynczych wywołań Parse(String, NumberStyles, IFormatProvider) metody przekazuje wystąpienie następującej BigIntegerFormatProvider klasy, która definiuje tyldę (~) jako znak ujemny.

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

Uwagi

Parametr style definiuje elementy stylu (takie jak biały znak, symbol znaku dodatniego lub ujemnego, symbol separatora grupy lub symbol separatora dziesiętnego), które są dozwolone w parametrze value dla operacji analizy pomyślne. styles musi być kombinacją flag bitowych z NumberStyles wyliczenia. Parametr style sprawia, że ta metoda jest przydatna, gdy value zawiera reprezentację ciągu wartości szesnastkowej, gdy system liczbowy (dziesiętny lub szesnastkowy) reprezentowany przez value element jest znany tylko w czasie wykonywania lub gdy chcesz uniemożliwić biały znak lub symbol znaku w .value

W zależności od wartości styleparametr może value zawierać następujące elementy:

[ws] [$][znak][cyfry,]cyfry[.fractional_digits][E[znak]exponential_digits][ws]

Jeśli style parametr zawiera NumberStyles.AllowHexSpecifierparametr , value może zawierać następujące elementy:

[ws] hexdigits[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W tabeli poniżej opisano każdy element.

Element Opis
Ws Opcjonalny odstęp. Białe znaki mogą pojawić się na początku value , jeśli style zawiera flagę NumberStyles.AllowLeadingWhite , i może pojawić się na końcu value , jeśli style zawiera flagę NumberStyles.AllowTrailingWhite .
$ Symbol waluty specyficzny dla kultury. Jego pozycja w ciągu jest definiowana przez NumberFormatInfo.CurrencyNegativePattern właściwości i NumberFormatInfo.CurrencyPositivePattern kultury wskazanej provider przez parametr . Symbol waluty bieżącej kultury może pojawić się, value jeśli style zawiera flagę NumberStyles.AllowCurrencySymbol .
sign Opcjonalny znak. Znak może pojawić się na początku value , jeśli style zawiera flagę NumberStyles.AllowLeadingSign i może pojawić się na końcu value , jeśli style zawiera flagę NumberStyles.AllowTrailingSign . Nawiasy mogą służyć value do wskazywania wartości ujemnej, jeśli style zawiera flagę NumberStyles.AllowParentheses .
Cyfr

fractional_digits

exponential_digits		 Sekwencja cyfr od 0 do 9. W przypadku fractional_digits tylko cyfra 0 jest prawidłowa.
, Symbol separatora grupy specyficzny dla kultury. Symbol separatora grup określonej przez provider kulturę może pojawić się, value jeśli style zawiera flagę NumberStyles.AllowThousands .
. Symbol dziesiętny specyficzny dla kultury. Symbol punktu dziesiętnego kultury wyznaczonej przez provider program może pojawić się, value jeśli style zawiera flagę NumberStyles.AllowDecimalPoint . Tylko cyfra 0 może być wyświetlana jako cyfra ułamkowa dla operacji analizy, która zakończy się powodzeniem; jeśli fractional_digits zawiera inną cyfrę FormatException , zostanie zgłoszony.
E Znak „e” lub „E”, który wskazuje, że wartość jest reprezentowana w zapisie wykładniczym (naukowym). Parametr value może reprezentować liczbę w notacji wykładniczej, jeśli style zawiera flagę NumberStyles.AllowExponent .
hexdigits Sekwencja cyfr szesnastkowych od 0 do f lub od 0 do F.

Uwaga

Wszelkie znaki zakończenia NUL (U+0000) w obiekcie s są ignorowane przez operację analizowania, niezależnie od wartości argumentu style .

Ciąg z cyframi (odpowiadający NumberStyles.None stylowi) zawsze jest analizowanych pomyślnie. Większość pozostałych NumberStyles elementów członkowskich kontroluje, które mogą być obecne, ale nie są wymagane do obecności w ciągu wejściowym. Poniższa tabela wskazuje, jak poszczególne NumberStyles elementy członkowskie wpływają na elementy, które mogą być obecne w elemecie value.

Wartość wyliczenia NumberStyles Dodatkowe (poza cyframi) elementy dozwolone w wartości
None Tylko element cyfry .
AllowDecimalPoint Elementy punktów dziesiętnych (.) i cyfr ułamkowych .
AllowExponent Znak „e” lub znak „E”, co oznacza zapis wykładniczy. wraz z exponential_digits.
AllowLeadingWhite Element ws na początku value.
AllowTrailingWhite Element ws na końcu valueelementu .
AllowLeadingSign Element znaku na początku value.
AllowTrailingSign Element znaku na końcu elementu value.
AllowParentheses Element znaku w postaci nawiasów otaczających wartość liczbową.
AllowThousands Element separatora grupy (,).
AllowCurrencySymbol Element określający walutę ($).
Currency Wszystkie elementy. value Nie można jednak reprezentować liczby szesnastkowej ani liczby w notacji wykładniczej.
Float Element ws na początku lub na końcu value, znak na początku value, i symbol dziesiętny (.). Parametr value może również używać notacji wykładniczej.
Number wsElementy separatora grup (sign,) i separatora dziesiętnego (.).
Any Wszystkie elementy. value Nie można jednak reprezentować liczby szesnastkowej.

Ważne

Jeśli używasz Parse metody , aby zaokrąglić ciąg reprezentujący BigInteger wartość, która została wygenerowana przez ToString metodę, należy użyć BigInteger.ToString(String) metody z specyfikatorem formatu "R", aby wygenerować reprezentację BigInteger ciągu wartości. W przeciwnym razie reprezentacja BigInteger ciągu zachowuje tylko 50 najbardziej znaczących cyfr oryginalnej wartości, a dane mogą zostać utracone, gdy użyjesz Parse metody w celu przywrócenia BigInteger wartości.

W przeciwieństwie do innych NumberStyles wartości, które umożliwiają, ale nie wymagają obecności określonych elementów stylu w , NumberStyles.AllowHexSpecifier wartość stylu oznacza, że poszczególne znaki liczbowe w value obiekcie valuesą zawsze interpretowane jako znaki szesnastkowe. Prawidłowe znaki szesnastkowe to 0-9, A-F i a-f. Jedyną inną flagą, którą można połączyć z parametrem style , są NumberStyles.AllowLeadingWhite i NumberStyles.AllowTrailingWhite. (Wyliczenie NumberStyles zawiera styl liczb złożonych, HexNumber, który zawiera obie flagi odstępu).

Uwaga

Jeśli value jest reprezentacją ciągu liczby szesnastkowej, nie może być poprzedzona żadną dekoracją (taką jak 0x lub &h), która rozróżnia ją jako liczbę szesnastkowa. To powoduje niepowodzenie konwersji.

Jeśli value jest ciągiem szesnastkowym, Parse(String, NumberStyles) metoda interpretuje value jako liczbę ujemną przechowywaną przy użyciu reprezentacji uzupełniającej dwóch pierwszych cyfr szesnastkowych jest większa lub równa 0x80. Innymi słowy, metoda interpretuje bit o najwyższej kolejności pierwszego bajtu w value postaci bitu znaku. Aby upewnić się, że ciąg szesnastkowy jest poprawnie interpretowany jako liczba dodatnia, pierwsza cyfra w value musi mieć wartość zero. Na przykład metoda interpretuje 0x80 jako wartość ujemną, ale interpretuje wartość 0x080 lub 0x0080 jako wartość dodatnią. W poniższym przykładzie przedstawiono różnicę między ciągami szesnastkowymi reprezentującymi wartości ujemne i dodatnie.

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.

Parametr provider jest implementacją IFormatProvider . Metoda GetFormat zwraca NumberFormatInfo obiekt, który udostępnia informacje specyficzne dla kultury dotyczące formatu value. provider Zazwyczaj może to być dowolny z następujących elementów:

  • CultureInfo Obiekt reprezentujący kulturę, która udostępnia informacje o formatowaniu liczbowym. Metoda GetFormat zwraca NumberFormatInfo obiekt, który udostępnia informacje o formatowaniu liczbowym.

  • NumberFormatInfo Obiekt, który udostępnia informacje o formatowaniu. (Jego implementacja GetFormat po prostu zwraca się).

  • Obiekt niestandardowy, który implementuje IFormatProvider metodę GetFormat i używa jej do tworzenia wystąpienia i zwracania NumberFormatInfo obiektu, który udostępnia informacje o formatowaniu.

Jeśli provider jest to null, NumberFormatInfo używany jest obiekt bieżącej kultury.

Zobacz też

Dotyczy