BigInteger.Parse Metoda

Definice

Obor názvů:

System.Numerics

Sestavení:

System.Runtime.Numerics.dll

Převede řetězcové vyjádření čísla na jeho BigInteger ekvivalent.

Přetížení

Parse(String)	Převede řetězcovou reprezentaci čísla na jeho BigInteger ekvivalent.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků na hodnotu.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho BigInteger ekvivalent.
Parse(String, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho BigInteger ekvivalent.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede reprezentaci čísla obsaženého v zadaném rozsahu znaků jen pro čtení v zadaném stylu na jeho BigInteger ekvivalent.
Parse(String, NumberStyles, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho BigInteger ekvivalent.

Parse(String)

Zdroj:

BigInteger.cs

Převede řetězcovou reprezentaci čísla na jeho BigInteger ekvivalent.

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

Řetězec obsahující číslo k převedení.

Návraty

BigInteger

Hodnota, která odpovídá číslu zadanému v parametru value .

Výjimky

ArgumentNullException

value je null.

FormatException

value není ve správném formátu.

Příklady

Následující příklad používá metodu Parse(String) k vytvoření instance dvou BigInteger objektů. Vynásobí každý objekt jiným číslem a pak zavolá metodu Compare k určení vztahu mezi těmito dvěma hodnotami.

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.

Poznámky

Parametr value by měl být řetězcovou reprezentací čísla v následujícím formuláři.

[ws] [sign] digits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné místo.
sign	Nepovinný znak. Platné znakové znaky jsou určeny vlastnostmi NumberFormatInfo.NegativeSign a NumberFormatInfo.PositiveSign aktuální jazykové verze.
Číslic	Řada číslic od 0 do 9. Budou ignorovány všechny úvodní nuly.

Poznámka

Řetězec zadaný parametrem value je interpretován pomocí NumberStyles.Integer stylu. Nemůže obsahovat žádné oddělovače skupin ani oddělovač desetinných míst a nemůže mít desetinnou část.

Parametr value se analyzuje pomocí informací o formátování v objektu System.Globalization.NumberFormatInfo , který je inicializován pro aktuální systémovou jazykovou verzi. Další informace naleznete v tématu NumberFormatInfo.CurrentInfo. Pokud chcete analyzovat řetězec pomocí informací o formátování konkrétní jazykové verze, použijte metodu Parse(String, IFormatProvider) .

Důležité

Pokud použijete metodu Parse k zaokrouhlování řetězcové reprezentace BigInteger hodnoty, která byla výstupem ToString metody, měli byste použít metodu BigInteger.ToString(String) se specifikátorem formátu R pro vygenerování řetězcové BigInteger reprezentace hodnoty. Jinak řetězcová reprezentace BigInteger zachová pouze 50 nejvýznamnějších číslic původní hodnoty a data mohou být ztracena při použití Parse metody k obnovení BigInteger hodnoty.

Viz také

• TryParse

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:

BigInteger.cs

Parsuje rozsah znaků na hodnotu.

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>

Rozsah znaků, které se mají analyzovat.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s

Návraty

BigInteger

Výsledek analýzy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(String, NumberStyles)

Zdroj:

BigInteger.cs

Převede řetězcové vyjádření čísla v zadaném stylu na jeho BigInteger ekvivalent.

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

Řetězec obsahující číslo k převedení.

style

NumberStyles

Bitová kombinace hodnot výčtu, které určují povolený formát .value

Návraty

BigInteger

Hodnota, která odpovídá číslu zadanému v parametru value .

Výjimky

ArgumentException

style není NumberStyles hodnota.

-nebo-

style AllowHexSpecifier obsahuje příznak nebo HexNumber spolu s jinou hodnotou.

ArgumentNullException

value je null.

FormatException

value není v souladu se vzorem vstupu určeným nástrojem NumberStyles.

Příklady

Následující příklad znázorňuje volání Parse(String, NumberStyles) metody s několika možnými hodnotami parametru style . Ukazuje, jak interpretovat řetězec jako šestnáctkovou hodnotu a jak zakázat mezery a symboly znaménka.

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.

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky, symbol kladného nebo záporného znaménka, oddělovač skupin nebo symbol desetinné čárky), které jsou povoleny v parametru value , aby operace parsování byla úspěšná. styles musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style činí přetížení této metody užitečné, pokud value obsahuje řetězcovou reprezentaci šestnáctkové hodnoty, když číselný systém (desetinný nebo šestnáctkový) reprezentovaný value je známý pouze v době běhu nebo když chcete zakázat prázdné znaky nebo symbol znaménka v value.

V závislosti na hodnotě stylevalue může parametr obsahovat následující prvky:

[ws] [$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]

Pokud style parametr obsahuje NumberStyles.AllowHexSpecifier, value může parametr obsahovat následující prvky:

[ws] hexdigits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné místo. Prázdné místo se může zobrazit na začátku, value pokud style obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci, value pokud style obsahuje NumberStyles.AllowTrailingWhite příznak.
$	Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v value , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak.
sign	Nepovinný znak. Znaménko se může zobrazit na začátku, pokud příznak obsahujeNumberStyles.AllowLeadingSign, a může se zobrazit na konci, value pokud style příznak obsahujeNumberStyles.AllowTrailingSign.stylevalue Závorky lze v value použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic Fractional_digits exponential_digits	Řada číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
,	Symbol oddělovače skupin, specifický pro jazykovou verzi. Oddělovač skupin aktuální jazykové verze se může zobrazit v value , pokud style obsahuje NumberStyles.AllowThousands příznak.
.	Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v value , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak. Pouze číslice 0 se může zobrazit jako desetinná číslice, aby operace analýzy byla úspěšná; Pokud fractional_digits obsahuje jinou FormatException číslici, vyvolá se znak .
E	Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. Parametr value může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak.
šestihranné	Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.

Poznámka

Operace analýzy ignoruje všechny ukončující ZNAKY NUL (U+0000) bez s ohledu na hodnotu argumentu style .

Řetězec pouze s číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně analyzuje. Většina zbývajících NumberStyles členů řídí prvky, které mohou být přítomny, ale nemusí být přítomny, ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v nástroji value.

NumberStyles Hodnotu	Prvky povolené value spolu s číslicemi
None	Pouze prvek digits .
AllowDecimalPoint	Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis spolu s exponential_digits.
AllowLeadingWhite	Element ws na začátku .value
AllowTrailingWhite	Element ws na konci .value
AllowLeadingSign	Element sign na začátku .value
AllowTrailingSign	Element sign na konci .value
AllowParentheses	Element sign ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Prvek oddělovače skupin (,).
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. Nemůže však value představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Element ws na začátku nebo na konci value, znaménko na začátku valuea symbol desetinné čárky (.) Parametr value může také používat exponenciální zápis.
Number	Elementy ws, signoddělovač skupin (,) a desetinná čárka (.)
Any	Všechny prvky. Nemůže však value představovat šestnáctkové číslo.

Důležité

Pokud použijete metodu Parse k obnovení řetězcové reprezentace BigInteger hodnoty, která byla výstupní metodou ToString , měli byste použít metodu BigInteger.ToString(String) se specifikátorem formátu "R", abyste vygenerovali řetězcovou reprezentaci BigInteger hodnoty. Jinak řetězcová reprezentace BigInteger zachová pouze 50 nejvýznamnějších číslic původní hodnoty a data mohou být ztracena, když použijete metodu Parse k obnovení BigInteger hodnoty.

Na rozdíl od ostatních NumberStyles hodnot, které umožňují, ale nevyžadují, přítomnost určitých prvků stylu v valueNumberStyles.AllowHexSpecifier , hodnota stylu znamená, že jednotlivé číselné znaky v value souboru jsou vždy interpretovány jako šestnáctkové znaky. Platné šestnáctkové znaky jsou 0-9, A-F a a-f. Jedinými dalšími příznaky, které je možné kombinovat s parametrem, style jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , HexNumberkterý obsahuje oba příznaky prázdných znaků.)

Poznámka

Pokud value je řetězcové vyjádření šestnáctkového čísla, nemůže mu předcházet žádné dekorace (například 0x nebo &h), které ho odlišují jako šestnáctkové číslo. To způsobí selhání převodu.

Pokud value je šestnáctkový řetězec, Parse(String, NumberStyles) metoda interpretuje value jako záporné číslo uložené pomocí dvojkového doplňku reprezentace, pokud jsou jeho první dvě šestnáctkové číslice větší než nebo rovny 0x80. Jinými slovy, metoda interpretuje bit nejvyššího pořadí prvního bajtu v value jako bit znaménka. Aby se zajistilo, že je šestnáctkový řetězec správně interpretován jako kladné číslo, musí mít první číslice v value souboru hodnotu nula. Například metoda interpretuje 0x80 jako zápornou hodnotu, ale interpretuje buď 0x080 hodnotu, nebo 0x0080 jako kladnou hodnotu. Následující příklad znázorňuje rozdíl mezi hexadecimálními řetězci, které představují záporné a kladné hodnoty.

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 je analyzován pomocí informací o formátování v objektu NumberFormatInfo , který je inicializován pro aktuální jazykovou verzi systému. Chcete-li určit jazykovou verzi, jejíž informace o formátování se používají pro operaci parsování, zavolejte Parse(String, NumberStyles, IFormatProvider) přetížení.

Viz také

• TryParse

Parse(String, IFormatProvider)

Zdroj:

BigInteger.cs

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho BigInteger ekvivalent.

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);

static member Parse : string * IFormatProvider -> System.Numerics.BigInteger

Public Shared Function Parse (value As String, provider As IFormatProvider) As BigInteger

Parametry

value

String

Řetězec obsahující číslo k převedení.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro valuejazykovou verzi.

Návraty

BigInteger

Hodnota, která odpovídá číslu zadanému v parametru value .

Implementuje

Parse(String, IFormatProvider)

Výjimky

ArgumentNullException

value je null.

FormatException

value není ve správném formátu.

Příklady

Následující příklady ukazují dva způsoby, jak definovat vlnovku (~) jako záporné znaménko pro formátování BigInteger hodnot. Všimněte si, že pokud chcete zobrazit BigInteger hodnoty ve stejném formátu jako původní řetězce, musí kód zavolat metodu BigInteger.ToString(IFormatProvider) a předat jí NumberFormatInfo objekt, který poskytuje informace o formátování.

První příklad definuje třídu, která implementuje IFormatProvider a používá metodu GetFormat k vrácení objektu NumberFormatInfo , který poskytuje informace o formátování.

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

K BigInteger vytvoření instance objektu pak můžete použít následující kód:

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)

Druhý příklad je jednodušší. Předá parametru NumberFormatInfo objekt, který poskytuje informace o provider formátování.

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)

Poznámky

Parametr value by měl být řetězcovým vyjádřením čísla v následujícím tvaru:

[ws] [sign] digits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné místo.
sign	Nepovinný znak. Platné znaky znaménka jsou určeny vlastnostmi a objektuNumberFormatInfo, který je vrácen metodou objektu.providerGetFormatNumberFormatInfo.PositiveSignNumberFormatInfo.NegativeSign
Číslic	Řada číslic od 0 do 9. Budou ignorovány všechny úvodní nuly.

Poznámka

Řetězec určený parametrem value se interpretuje pomocí NumberStyles.Integer stylu . Nemůže obsahovat žádné oddělovače skupin ani oddělovač desetinných míst a nemůže mít desetinnou část.

Důležité

Pokud použijete metodu Parse k obnovení řetězcové reprezentace BigInteger hodnoty, která byla výstupní metodou ToString , měli byste použít metodu BigInteger.ToString(String) se specifikátorem formátu "R", abyste vygenerovali řetězcovou reprezentaci BigInteger hodnoty. Jinak řetězcová reprezentace BigInteger zachová pouze 50 nejvýznamnějších číslic původní hodnoty a data mohou být ztracena, když použijete metodu Parse k obnovení BigInteger hodnoty.

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace o formátování specifické pro jazykovou verzi. Při vyvolání Parse(String, IFormatProvider) metody volá metodu parametru GetFormatprovider a předá jí Type objekt, který představuje NumberFormatInfo typ. Metoda GetFormat pak vrátí NumberFormatInfo objekt, který poskytuje informace o formátu parametru value . Existují tři způsoby použití parametru provider k poskytnutí informací o vlastním formátování do operace parsování:

• Můžete předat CultureInfo objekt, který představuje jazykovou verzi, která poskytuje informace o formátování. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace o číselném formátování pro danou jazykovou verzi.

• Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o číselném formátování. (Jeho implementace pouze GetFormat vrací sama sebe.)

• Můžete předat vlastní objekt, který implementuje IFormatProvider. Jeho GetFormat metoda vytvoří instanci a vrátí NumberFormatInfo objekt, který poskytuje informace o formátování.

Pokud provider je null, formátování value je interpretováno na základě objektu NumberFormatInfo aktuální jazykové verze.

Viz také

• TryParse

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Zdroj:

BigInteger.cs

Převede reprezentaci čísla obsaženého v zadaném rozsahu znaků jen pro čtení v zadaném stylu na jeho BigInteger ekvivalent.

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>

Rozsah znaků jen pro čtení, který obsahuje číslo, které chcete převést.

style

NumberStyles

Bitová kombinace hodnot výčtu, které určují povolený formát .value

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro valuejazykovou verzi.

Návraty

BigInteger

Hodnota, která odpovídá číslu zadanému v parametru value .

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Výjimky

ArgumentException

style není NumberStyles hodnota.

-nebo-

style AllowHexSpecifier obsahuje příznak nebo HexNumber spolu s jinou hodnotou.

ArgumentNullException

value je null.

FormatException

value není v souladu se vzorem vstupu specifikovaným v style.

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky, symbol kladného nebo záporného znaménka, symbol oddělovače skupin nebo symbol desetinné čárky), které jsou povoleny v parametru value pro úspěšnou operaci analýzy. styles musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style zajišťuje, že přetížení této metody je užitečné, pokud value obsahuje reprezentaci šestnáctkové hodnoty, pokud číselný systém (desítkový nebo šestnáctkový) reprezentovaný value je znám pouze za běhu, nebo když chcete zakázat prázdné znaky nebo symbol znaménka v value.

V závislosti na hodnotě stylevalue může parametr obsahovat následující prvky:

[ws] [$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]

Pokud style obsahuje NumberStyles.AllowHexSpecifierparametr , value může parametr obsahovat následující prvky:

[ws] hexdigits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné místo. Prázdné znaky se můžou zobrazit na začátku value , pokud style obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci, value pokud style obsahuje NumberStyles.AllowTrailingWhite příznak.
$	Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v value je definována vlastnostmi NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern jazykové verze indikované parametrem provider . Symbol měny aktuální jazykové verze se může zobrazit v value , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak .
sign	Nepovinný znak. Znaménko se může zobrazit na začátku, value pokud style obsahuje NumberStyles.AllowLeadingSign příznak, a může se zobrazit na konci, value pokud style obsahuje NumberStyles.AllowTrailingSign příznak. Závorky lze v value použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic Fractional_digits exponential_digits	Řada číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
,	Symbol oddělovače skupin, specifický pro jazykovou verzi. Symbol oddělovače skupin jazykové verze se provider může zobrazit v value , pokud style obsahuje NumberStyles.AllowThousands příznak .
.	Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky jazykové verze určené nástrojem provider se může zobrazit v value , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak . Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; Pokud fractional_digits obsahuje jakoukoli jinou FormatException číslici, vyvolá se hodnota .
E	Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. Parametr value může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak .
hexdigits	Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.

Poznámka

Operace analýzy ignoruje všechny ukončující znaky s NUL (U+0000) bez ohledu na hodnotu argumentu style .

A value pouze s číslicemi (což odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů řídí prvky, které mohou být přítomny, ale nejsou nutné, aby byly přítomny v nástroji value. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v valuenástroji .

Hodnota NumberStyles	Prvky, které jsou povoleny v hodnotě kromě číslic
None	Pouze prvek digits .
AllowDecimalPoint	Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis. a exponential_digits.
AllowLeadingWhite	Element ws na začátku .value
AllowTrailingWhite	Element ws na konci .value
AllowLeadingSign	Element sign na začátku .value
AllowTrailingSign	Element sign na konci .value
AllowParentheses	Element sign ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Prvek oddělovače skupin (,).
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. Nemůže však value představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Element ws na začátku nebo na konci value, znaménko na začátku valuea symbol desetinné čárky (.) Parametr value může také používat exponenciální zápis.
Number	Elementy ws, signoddělovač skupin (,) a desetinná čárka (.)
Any	Všechny prvky. Nemůže však value představovat šestnáctkové číslo.

Na rozdíl od ostatních NumberStyles hodnot, které umožňují, ale nevyžadují přítomnost určitých prvků stylu v value, NumberStyles.AllowHexSpecifier hodnota stylu znamená, že jednotlivé číselné znaky v value souboru jsou vždy interpretovány jako šestnáctkové znaky. Platné šestnáctkové znaky jsou 0-9, A-F a a-f. Jedinými dalšími příznaky, které je možné kombinovat s parametrem, style jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , HexNumberkterý obsahuje oba příznaky prázdných znaků.)

Parametr provider je IFormatProvider implementace. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi formátu .value Obvykle provider může být některý z následujících:

• Objekt CultureInfo , který představuje jazykovou verzi poskytující informace o číselném formátování. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace o číselném formátování.

• Objekt NumberFormatInfo , který poskytuje informace o formátování. (Jeho implementace pouze GetFormat vrací sama sebe.)

• Vlastní objekt, který implementuje IFormatProvider a používá metodu GetFormat k vytvoření instance a vrácení objektu NumberFormatInfo , který poskytuje informace o formátování.

Pokud provider je null, použije se NumberFormatInfo objekt pro aktuální jazykovou verzi.

Viz také

• TryParse

Parse(String, NumberStyles, IFormatProvider)

Zdroj:

BigInteger.cs

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho BigInteger ekvivalent.

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);

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

Řetězec obsahující číslo k převedení.

style

NumberStyles

Bitová kombinace hodnot výčtu, které určují povolený formát .value

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro valuejazykovou verzi.

Návraty

BigInteger

Hodnota, která odpovídá číslu zadanému v parametru value .

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentException

style není NumberStyles hodnota.

-nebo-

style AllowHexSpecifier obsahuje příznak nebo HexNumber spolu s jinou hodnotou.

ArgumentNullException

value je null.

FormatException

value není v souladu se vzorem vstupu specifikovaným v style.

Příklady

Následující příklad provede několik volání Parse(String, NumberStyles, IFormatProvider) metody pomocí různých kombinací hodnot parametrů style a 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.

Několik jednotlivých volání Parse(String, NumberStyles, IFormatProvider) metody předává instanci následující BigIntegerFormatProvider třídy, která definuje vlnovku (~) jako záporné znaménko.

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

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky, symbol kladného nebo záporného znaménka, symbol oddělovače skupin nebo symbol desetinné čárky), které jsou povoleny v parametru value pro úspěšnou operaci analýzy. styles musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style umožňuje, aby přetížení této metody bylo užitečné, pokud value obsahuje řetězcové vyjádření šestnáctkové hodnoty, pokud je číselný systém (desítkový nebo šestnáctkový) reprezentovaný value hodnotou známý pouze za běhu, nebo pokud chcete zakázat prázdné znaky nebo symbol znaménka v value.

V závislosti na hodnotě stylevalue může parametr obsahovat následující prvky:

[ws] [$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]

Pokud style obsahuje NumberStyles.AllowHexSpecifierparametr , value může parametr obsahovat následující prvky:

[ws] hexdigits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné místo. Prázdné znaky se můžou zobrazit na začátku value , pokud style obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci, value pokud style obsahuje NumberStyles.AllowTrailingWhite příznak.
$	Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern jazykové verze označené parametrem provider . Symbol měny aktuální jazykové verze se může zobrazit v value , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak .
sign	Nepovinný znak. Znaménko se může zobrazit na začátku, value pokud style obsahuje NumberStyles.AllowLeadingSign příznak, a může se zobrazit na konci, value pokud style obsahuje NumberStyles.AllowTrailingSign příznak. Závorky lze v value použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic Fractional_digits exponential_digits	Řada číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
,	Symbol oddělovače skupin, specifický pro jazykovou verzi. Symbol oddělovače skupin jazykové verze se provider může zobrazit v value , pokud style obsahuje NumberStyles.AllowThousands příznak .
.	Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky jazykové verze určené nástrojem provider se může zobrazit v value , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak . Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; Pokud fractional_digits obsahuje jakoukoli jinou FormatException číslici, vyvolá se hodnota .
E	Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. Parametr value může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak .
hexdigits	Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.

Poznámka

Operace analýzy ignoruje všechny ukončující znaky s NUL (U+0000) bez ohledu na hodnotu argumentu style .

Řetězec pouze s číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů řídí prvky, které mohou být přítomny, ale nemusí být přítomny, ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v valuenástroji .

Hodnota NumberStyles	Prvky, které jsou povoleny v hodnotě kromě číslic
None	Pouze prvek digits .
AllowDecimalPoint	Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis. a exponential_digits.
AllowLeadingWhite	Element ws na začátku .value
AllowTrailingWhite	Element ws na konci .value
AllowLeadingSign	Element sign na začátku .value
AllowTrailingSign	Element sign na konci .value
AllowParentheses	Element sign ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Prvek oddělovače skupin (,).
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. Nemůže však value představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Element ws na začátku nebo na konci value, znaménko na začátku valuea symbol desetinné čárky (.) Parametr value může také používat exponenciální zápis.
Number	Elementy ws, signoddělovač skupin (,) a desetinná čárka (.)
Any	Všechny prvky. Nemůže však value představovat šestnáctkové číslo.

Důležité

Pokud použijete metodu Parse k obnovení řetězcové reprezentace BigInteger hodnoty, která byla výstupní metodou ToString , měli byste použít metodu BigInteger.ToString(String) se specifikátorem formátu "R", abyste vygenerovali řetězcovou reprezentaci BigInteger hodnoty. Jinak řetězcová reprezentace BigInteger zachová pouze 50 nejvýznamnějších číslic původní hodnoty a data mohou být ztracena, když použijete metodu Parse k obnovení BigInteger hodnoty.

Na rozdíl od ostatních NumberStyles hodnot, které umožňují, ale nevyžadují přítomnost určitých prvků stylu v value, NumberStyles.AllowHexSpecifier hodnota stylu znamená, že jednotlivé číselné znaky v value souboru jsou vždy interpretovány jako šestnáctkové znaky. Platné šestnáctkové znaky jsou 0-9, A-F a a-f. Jedinými dalšími příznaky, které je možné kombinovat s parametrem, style jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , HexNumberkterý obsahuje oba příznaky prázdných znaků.)

Poznámka

Pokud value je řetězcové vyjádření šestnáctkového čísla, nemůže mu předcházet žádné dekorace (například 0x nebo &h), které ho odlišují jako šestnáctkové číslo. To způsobí selhání převodu.

Pokud value je šestnáctkový řetězec, Parse(String, NumberStyles) metoda interpretuje value jako záporné číslo uložené pomocí dvojkového doplňku reprezentace, pokud jsou jeho první dvě šestnáctkové číslice větší než nebo rovny 0x80. Jinými slovy, metoda interpretuje bit nejvyššího pořadí prvního bajtu v value jako bit znaménka. Aby se zajistilo, že je šestnáctkový řetězec správně interpretován jako kladné číslo, musí mít první číslice v value souboru hodnotu nula. Například metoda interpretuje 0x80 jako zápornou hodnotu, ale interpretuje buď 0x080 hodnotu, nebo 0x0080 jako kladnou hodnotu. Následující příklad znázorňuje rozdíl mezi hexadecimálními řetězci, které představují záporné a kladné hodnoty.

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 je IFormatProvider implementace. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi formátu .value Obvykle provider může být některý z následujících:

• Objekt CultureInfo , který představuje jazykovou verzi poskytující informace o číselném formátování. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace o číselném formátování.

• Objekt NumberFormatInfo , který poskytuje informace o formátování. (Jeho implementace pouze GetFormat vrací sama sebe.)

• Vlastní objekt, který implementuje IFormatProvider a používá metodu GetFormat k vytvoření instance a vrácení objektu NumberFormatInfo , který poskytuje informace o formátování.

Pokud provider je null, použije se NumberFormatInfo objekt pro aktuální jazykovou verzi.

Viz také

• TryParse