BigInteger.TryParse Metoda

Definice

Obor názvů:

System.Numerics

Sestavení:

netstandard.dll, System.Runtime.Numerics.dll

Pokusí se převést řetězcovou reprezentaci čísla na BigInteger jeho ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

Přetížení

Name	Description
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Pokusí se převést řetězcovou reprezentaci čísla na BigInteger jeho ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, BigInteger)	Pokusí se převést reprezentaci čísla obsaženého v zadaném rozsahu znaků jen pro čtení na jeho BigInteger ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(String, BigInteger)	Pokusí se převést řetězcovou reprezentaci čísla na BigInteger jeho ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(String, IFormatProvider, BigInteger)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Pokusí se převést řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho BigInteger ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Pokusí se analyzovat rozsah znaků do hodnoty.

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

Zdroj:

BigInteger.cs

Pokusí se převést řetězcovou reprezentaci čísla na BigInteger jeho ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

public:
 static bool TryParse(ReadOnlySpan<char> value, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result) = System::Numerics::INumberBase<System::Numerics::BigInteger>::TryParse;

public static bool TryParse(ReadOnlySpan<char> value, System.Globalization.NumberStyles style, IFormatProvider? provider, out System.Numerics.BigInteger result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * BigInteger -> bool

Public Shared Function TryParse (value As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As BigInteger) As Boolean

Parametry

value

ReadOnlySpan<Char>

Reprezentace čísla jako rozsahu jen pro čtení znaků.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v value. Typická hodnota, kterou je třeba zadat, je Integer.

provider

IFormatProvider

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

result

BigInteger

Pokud tato metoda vrátí, obsahuje BigInteger ekvivalent k číslu, který je obsažen v value, nebo Zero pokud převod selhal. Převod selže, pokud value je parametr prázdným rozsahem znaků nebo není ve formátu, který je kompatibilní s style. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true pokud value byl úspěšně převeden; jinak , false.

Výjimky

ArgumentException

style není NumberStyles hodnota.

-or-

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

Poznámky

Toto přetížení je podobné Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) metodě, s tím rozdílem, že nevyvolá výjimku, pokud převod selže. Tato metoda eliminuje nutnost použít zpracování výjimek k otestování, FormatException pokud value je neplatné a nelze ji úspěšně analyzovat.

Parametr style definuje prvky stylu (například prázdné znaky nebo kladné nebo záporné znaménko), které jsou v parametru value povolené, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . V závislosti na hodnotě styleparametru value může obsahovat následující prvky:

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

Pokud parametr style obsahuje 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.

prvek	Description
Ws	Volitelné prázdné znaky. Prázdné znaky se můžou zobrazit na začátku value , pokud style příznak obsahuje NumberStyles.AllowLeadingWhite , nebo na konci value , pokud style příznak NumberStyles.AllowTrailingWhite obsahuje.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice je value definována CurrencyPositivePattern vlastností NumberFormatInfo objektu vráceného GetFormat metodou parametru provider . Symbol měny se může zobrazit, value pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku value , pokud style příznak obsahuje NumberStyles.AllowLeadingSign , a může se zobrazit na konci value , pokud style příznak NumberStyles.AllowTrailingSign obsahuje. Závorky lze použít value k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic	Posloupnost číslic od 0 do 9.
,	Oddělovač skupin specifických pro jazykovou verzi. Oddělovač skupiny jazykové verze určené jazykovou provider verzí se může zobrazit v value případě, že style obsahuje NumberStyles.AllowThousands příznak.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky zadané jazykovou provider verzí se může zobrazit v value případě, že style obsahuje NumberStyles.AllowDecimalPoint příznak.
Fractional_digits	Jeden nebo více výskytů číslice 0. Desetinná číslice se můžou zobrazovat value jenom v případě, že style příznak obsahuje NumberStyles.AllowDecimalPoint .
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr value může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak.
exponential_digits	Posloupnost číslic od 0 do 9. 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 0 až F.

Poznámka:

Všechny ukončující nulové znaky (U+0000) jsou s ignorovány operací analýzy bez ohledu na hodnotu argumentu style .

Neseparované NumberStyles hodnoty	Prvky povolené v hodnotě kromě číslic
None	Pouze desítkové číslice.
AllowDecimalPoint	Desetinná čárka (.) a fractional_digits elementy. Nicméně, fractional_digits se musí skládat pouze z jedné nebo více 0 číslic, nebo metoda vrátí false.
AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits. Pokud value představuje číslo v exponenciálním zápisu, nemůže mít nenulovou desetinnou komponentu.
AllowLeadingWhite	Prvek ws na začátku .value
AllowTrailingWhite	Prvek ws na konci .value
AllowLeadingSign	Prvek znaménka před číslicemi.
AllowTrailingSign	Prvek znaménka za číslicemi.
AllowParentheses	Prvek znaménka ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Element oddělovače skupin (,).
AllowCurrencySymbol	Prvek měny ($)
Currency	Všechny prvky. value Nelze však reprezentovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo konci znakuvalue, na začátku valueznaku a desetinné čárky (.) symbol. Parametr value může také použít exponenciální zápis.
Number	Prvky ws, znaménko, oddělovač skupin (,) a desetinná čárka (.).
Any	Všechny prvky. value Nelze však reprezentovat šestnáctkové číslo.

NumberStyles.AllowHexSpecifier Pokud se příznak použije, value musí být šestnáctková hodnota. Jediné ostatní příznaky, které mohou být přítomny jsou styleNumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles má složený styl, 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 o formátu value. Parametr provider může být libovolný z následujících:

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

• Objekt NumberFormatInfo , který poskytuje informace o číselném formátování. (Její implementace GetFormat pouze vrátí sama sebe.)

• Vlastní objekt, který implementuje IFormatProvider. Jeho GetFormat metoda vytvoří instanci a vrátí NumberFormatInfo objekt, který poskytuje informace o formátování.

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

Viz také

• Parse

TryParse(ReadOnlySpan<Char>, BigInteger)

Zdroj:

BigInteger.cs

Pokusí se převést reprezentaci čísla obsaženého v zadaném rozsahu znaků jen pro čtení na jeho BigInteger ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

public:
 static bool TryParse(ReadOnlySpan<char> value, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result);

public static bool TryParse(ReadOnlySpan<char> value, out System.Numerics.BigInteger result);

static member TryParse : ReadOnlySpan<char> * BigInteger -> bool

Public Shared Function TryParse (value As ReadOnlySpan(Of Char), ByRef result As BigInteger) As Boolean

Parametry

value

ReadOnlySpan<Char>

Reprezentace čísla jako rozsahu jen pro čtení znaků.

result

BigInteger

Pokud tato metoda vrátí, obsahuje BigInteger ekvivalent k číslu, který je obsažen v value, nebo nula (0), pokud převod selže. Převod selže, pokud value je parametr prázdným rozsahem znaků nebo není ve správném formátu. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true pokud value byl úspěšně převeden; jinak , false.

Viz také

• Parse

TryParse(String, BigInteger)

Zdroj:

BigInteger.cs

Pokusí se převést řetězcovou reprezentaci čísla na BigInteger jeho ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

public:
 static bool TryParse(System::String ^ value, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result);

public static bool TryParse(string? value, out System.Numerics.BigInteger result);

static member TryParse : string * BigInteger -> bool

Public Shared Function TryParse (value As String, ByRef result As BigInteger) As Boolean

Parametry

value

String

Řetězcové vyjádření čísla.

result

BigInteger

Pokud tato metoda vrátí, obsahuje BigInteger ekvivalent k číslu, který je obsažen v value, nebo nula (0), pokud převod selže. Převod selže, pokud value je null parametr nebo není ve správném formátu. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true pokud value byl úspěšně převeden; jinak , false.

Výjimky

ArgumentNullException

value je null.

Příklady

Následující příklad používá metodu TryParse(String, BigInteger) k vytvoření instance dvou BigInteger objektů. Pokud jsou převody úspěšné, vynásobí každý objekt jiným číslem a potom zavolá metodu Compare k určení vztahu mezi těmito dvěma objekty.

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

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

    let mutable number1 = BigInteger.Zero
    let mutable number2 = BigInteger.Zero

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

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

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

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

// The example displays the following output:
//      1975308642714319704 is greater than -37042602479685369.

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

Poznámky

Metoda TryParse(String, BigInteger) je podobná Parse(String) metodě, s tím rozdílem, že nevyvolá výjimku, pokud převod selže. Tato metoda eliminuje nutnost použít zpracování výjimek k otestování, FormatException pokud value je neplatné a nelze ji úspěšně analyzovat.

Parametr value by měl být řetězcovou reprezentací desetinného čísla v následující podobě:

[ws][znaménko]digits[ws]

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

prvek	Description
Ws	Volitelné prázdné znaky.
znaménko	Volitelné znaménko. Platné znaky znaménka jsou určeny vlastnostmi NumberFormatInfo.NegativeSignNumberFormatInfo.PositiveSign aktuální jazykové verze.
Číslic	Posloupnost desetinných číslic v rozsahu od 0 do 9.

Poznámka:

Řetězec určený parametrem value nemůže obsahovat žádné oddělovače skupin ani oddělovač desetinných míst a nesmí obsahovat desetinnou část.

Tento value parametr se interpretuje pomocí NumberStyles.Integer stylu. Kromě desetinných číslic jsou povoleny pouze úvodní a koncové mezery s počátečním symbolem. Chcete-li explicitně definovat prvky stylu s informacemi o formátování specifické pro jazykovou verzi, které mohou být přítomny v value, zavolejte metodu TryParse(String, NumberStyles, IFormatProvider, BigInteger) .

Parametr value je analyzován pomocí informací o formátování v objektu NumberFormatInfo pro aktuální jazykovou verzi. Další informace najdete na webu NumberFormatInfo.CurrentInfo.

Toto přetížení interpretuje všechny číslice v parametru value jako desítkové číslice. Chcete-li parsovat řetězcovou reprezentaci šestnáctkového čísla, zavolejte TryParse(String, NumberStyles, IFormatProvider, BigInteger) místo toho přetížení.

Viz také

• ToString(String)
• Parse

TryParse(String, IFormatProvider, BigInteger)

Zdroj:

BigInteger.cs

Pokusí se analyzovat řetězec do hodnoty.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result) = IParsable<System::Numerics::BigInteger>::TryParse;

public static bool TryParse(string? s, IFormatProvider? provider, out System.Numerics.BigInteger result);

static member TryParse : string * IFormatProvider * BigInteger -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As BigInteger) As Boolean

Parametry

s

String

Řetězec, který se má analyzovat.

provider

IFormatProvider

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

result

BigInteger

Pokud tato metoda vrátí, obsahuje výsledek úspěšné analýzy s nebo nedefinovanou hodnotu při selhání.

Návraty

Boolean

true pokud s byl úspěšně analyzován; jinak , false.

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Zdroj:

BigInteger.cs

Pokusí se převést řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho BigInteger ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

public:
 static bool TryParse(System::String ^ value, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result) = System::Numerics::INumberBase<System::Numerics::BigInteger>::TryParse;

public static bool TryParse(string? value, System.Globalization.NumberStyles style, IFormatProvider? provider, out System.Numerics.BigInteger result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * BigInteger -> bool

Public Shared Function TryParse (value As String, style As NumberStyles, provider As IFormatProvider, ByRef result As BigInteger) As Boolean

Parametry

value

String

Řetězcové vyjádření čísla. Řetězec se interpretuje pomocí stylu určeného znakem style.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v value. Typická hodnota, kterou je třeba zadat, je Integer.

provider

IFormatProvider

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

result

BigInteger

Pokud tato metoda vrátí, obsahuje BigInteger ekvivalent k číslu, který je obsažen v value, nebo Zero pokud převod selhal. Převod selže, pokud value je null parametr nebo není ve formátu, který je kompatibilní s style. Tento parametr se předává neinicializovaný.

Návraty

Boolean

true value pokud byl parametr úspěšně převeden; v opačném případě false.

Výjimky

ArgumentException

style není NumberStyles hodnota.

-or-

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

Příklady

Následující příklad provádí volání TryParse(String, NumberStyles, IFormatProvider, BigInteger) metody pomocí různých kombinací hodnot pro parametry style a provider parametry.

string numericString;
BigInteger number = BigInteger.Zero;

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

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

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

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

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

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

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

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

    // Call TryParse with default values of style and provider.
    let numericString = "  -300   "

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Dim numericString As String
Dim number As BigInteger = BigInteger.Zero

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

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

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

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

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

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

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

Několik jednotlivých volání metody TryParse(String, NumberStyles, IFormatProvider, BigInteger) předá 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 = new NumberFormatInfo()
                numberFormat.NegativeSign <- "~"
                numberFormat
            else
                null

Public Class BigIntegerFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                            Implements IFormatProvider.GetFormat
      If formatType Is GetType(NumberFormatInfo) Then
         Dim numberFormat As New NumberFormatInfo
         numberFormat.NegativeSign = "~"
         Return numberFormat
      Else
         Return Nothing
      End If      
   End Function
End Class

Poznámky

Metoda TryParse(String, NumberStyles, IFormatProvider, BigInteger) je podobná Parse(String, NumberStyles, IFormatProvider) metodě, s tím rozdílem, že nevyvolá výjimku, pokud převod selže. Tato metoda eliminuje nutnost použít zpracování výjimek k otestování, FormatException pokud value je neplatné a nelze ji úspěšně analyzovat.

Parametr style definuje prvky stylu (například prázdné znaky nebo kladné nebo záporné znaménko), které jsou v parametru value povolené, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . V závislosti na hodnotě styleparametru value může obsahovat následující prvky:

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

Pokud parametr style obsahuje 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.

prvek	Description
Ws	Volitelné prázdné znaky. Prázdné znaky se můžou zobrazit na začátku value , pokud style příznak obsahuje NumberStyles.AllowLeadingWhite , nebo na konci value , pokud style příznak NumberStyles.AllowTrailingWhite obsahuje.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována CurrencyPositivePattern vlastností NumberFormatInfo objektu vráceného GetFormat metodou parametru provider . Symbol měny se může zobrazit, value pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku value , pokud style příznak obsahuje NumberStyles.AllowLeadingSign , a může se zobrazit na konci value , pokud style příznak NumberStyles.AllowTrailingSign obsahuje. Závorky lze použít value k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic	Posloupnost číslic od 0 do 9.
,	Oddělovač skupin specifických pro jazykovou verzi. Oddělovač skupiny jazykové verze určené jazykovou provider verzí se může zobrazit v value případě, že style obsahuje NumberStyles.AllowThousands příznak.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky zadané jazykovou provider verzí se může zobrazit v value případě, že style obsahuje NumberStyles.AllowDecimalPoint příznak.
Fractional_digits	Jeden nebo více výskytů číslice 0. Desetinná číslice se můžou zobrazovat value jenom v případě, že style příznak obsahuje NumberStyles.AllowDecimalPoint .
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr value může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak.
exponential_digits	Posloupnost číslic od 0 do 9. 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 0 až F.

Poznámka:

Všechny ukončující nulové znaky (U+0000) jsou s ignorovány operací analýzy bez ohledu na hodnotu argumentu style .

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

Neseparované NumberStyles hodnoty	Prvky povolené v hodnotě kromě číslic
None	Pouze desítkové číslice.
AllowDecimalPoint	Desetinná čárka (.) a fractional_digits elementy. Nicméně, fractional_digits se musí skládat pouze z jedné nebo více 0 číslic, nebo metoda vrátí false.
AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits. Pokud value představuje číslo v exponenciálním zápisu, nemůže mít nenulovou desetinnou komponentu.
AllowLeadingWhite	Prvek ws na začátku .value
AllowTrailingWhite	Prvek ws na konci .value
AllowLeadingSign	Prvek znaménka před číslicemi.
AllowTrailingSign	Prvek znaménka za číslicemi.
AllowParentheses	Prvek znaménka ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Element oddělovače skupin (,).
AllowCurrencySymbol	Prvek měny ($)
Currency	Všechny prvky. value Nelze však reprezentovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo konci znakuvalue, na začátku valueznaku a desetinné čárky (.) symbol. Parametr value může také použít exponenciální zápis.
Number	Prvky ws, znaménko, oddělovač skupin (,) a desetinná čárka (.).
Any	Všechny prvky. value Nelze však reprezentovat šestnáctkové číslo.

Důležité

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

NumberStyles.AllowHexSpecifier Pokud se příznak použije, value musí být šestnáctková hodnota. Jediné ostatní příznaky, které mohou být přítomny jsou styleNumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles má složený styl, HexNumberkterý obsahuje oba příznaky prázdných znaků.)

Poznámka:

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

Pokud value je šestnáctkový řetězec, TryParse(String, NumberStyles, IFormatProvider, BigInteger) metoda interpretuje value jako záporné číslo uložené pomocí dvou doplňkových reprezentací, pokud jsou jeho první dvě šestnáctkové číslice větší nebo rovno 0x80. Jinými slovy, metoda interpretuje bit nejvyššího pořadí prvního bajtu jako value bit znaménka. Aby bylo zajištěno, že šestnáctkový řetězec je správně interpretován jako kladné číslo, musí mít první číslice value hodnotu nula. Metoda například interpretuje 0x80 jako zápornou hodnotu, ale interpretuje buď 0x080 nebo 0x0080 jako kladnou hodnotu. Následující příklad ukazuje rozdíl mezi šestnáctkový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" };
      BigInteger number = BigInteger.Zero;

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

open System.Globalization
open System.Numerics

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

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

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

Imports System.Globalization
Imports System.Numerics

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

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

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

• Objekt NumberFormatInfo , který poskytuje informace o číselném formátování. (Její implementace GetFormat pouze vrátí sama sebe.)

• Vlastní objekt, který implementuje IFormatProvider. Jeho GetFormat metoda vytvoří instanci a vrátí NumberFormatInfo objekt, který poskytuje informace o formátování.

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

Viz také

• ToString
• Parse

TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)

Zdroj:

BigInteger.cs

Pokusí se analyzovat rozsah znaků do hodnoty.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result) = ISpanParsable<System::Numerics::BigInteger>::TryParse;

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out System.Numerics.BigInteger result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * BigInteger -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As BigInteger) As Boolean

Parametry

s

ReadOnlySpan<Char>

Rozsah znaků, které se mají analyzovat.

provider

IFormatProvider

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

result

BigInteger

Pokud tato metoda vrátí, obsahuje výsledek úspěšné analýzy s, nebo nedefinovanou hodnotu při selhání.

Návraty

Boolean

true pokud s byl úspěšně analyzován; jinak , false.