Sdílet prostřednictvím

BigInteger.Parse Metoda

Definice

Obor názvů:
System.Numerics
Sestavení:
System.Numerics.dll, System.Runtime.Numerics.dll
Sestavení:
netstandard.dll, System.Runtime.Numerics.dll
Sestavení:
System.Runtime.Numerics.dll
Sestavení:
System.Numerics.dll
Sestavení:
netstandard.dll

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

Přetížení

Name Description
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(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(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
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<Byte>, IFormatProvider)
Parse(ReadOnlySpan<Char>, IFormatProvider)

Parsuje rozsah znaků do hodnoty.
Parse(String, NumberStyles)

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

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

Parse(String, NumberStyles, IFormatProvider)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Převede řetězcovou reprezentaci čí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);
public:
 static System::Numerics::BigInteger Parse(System::String ^ value, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::Numerics::BigInteger>::Parse;
public static System.Numerics.BigInteger Parse(string value, System.Globalization.NumberStyles style, IFormatProvider provider);
public static System.Numerics.BigInteger Parse(string value, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> System.Numerics.BigInteger
Public Shared Function Parse (value As String, style As NumberStyles, provider As IFormatProvider) As BigInteger

Parametry

value
String

Řetězec obsahující číslo, které se má převést.

style
NumberStyles

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

provider
IFormatProvider

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

Návraty

BigInteger

Hodnota, která je ekvivalentní číslu zadanému v parametru value .

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentException

style není NumberStyles hodnota.

-or-

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

ArgumentNullException

value je null.

FormatException

value není v souladu se vstupním vzorem určeným parametrem style.

Příklady

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

// 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í metody Parse(String, NumberStyles, IFormatProvider) 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 = 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 v parametru value povolené pro úspěšnou operaci analýzy. styles musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style tuto metodu přetíží, pokud value obsahuje řetězcovou reprezentaci šestnáctkové hodnoty, když číselný systém (desítkový nebo šestnáctkový) reprezentovaný value je znám pouze za běhu, nebo pokud chcete zakázat prázdné znaky nebo symbol znaku .value

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 style tento parametr obsahuje NumberStyles.AllowHexSpecifier, value může 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 , a může se zobrazit 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 vlastnostmi NumberFormatInfo.CurrencyNegativePattern jazykové NumberFormatInfo.CurrencyPositivePattern verze označené parametrem provider . Symbol měny aktuální jazykové verze se může zobrazit v value případě, že 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

Fractional_digits

exponential_digits		 Posloupnost číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
, Symbol oddělovače skupin specifických pro jazykovou verzi. Symbol oddělovače skupin 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 jazykové verze určené jazykovou provider verzí se může zobrazit, 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 znak.
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.
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 číslicemi (který odpovídá NumberStyles.None stylu) 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 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 value.

Hodnota NumberStyles Prvky povolené v hodnotě kromě číslic
None Pouze prvek číslic .
AllowDecimalPoint Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent Znak "e" nebo "E", který označuje exponenciální zápis. spolu s exponential_digits.
AllowLeadingWhite Prvek ws na začátku .value
AllowTrailingWhite Prvek ws na konci .value
AllowLeadingSign Prvek znaménka na začátku znaku value.
AllowTrailingSign Prvek znaménka na konci znaku value.
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, signoddělovač skupin (,) a desetinná čárka (.).
Any Všechny prvky. value Nelze však reprezentovat šestnáctkové číslo.

Důležité

Pokud metodu Parse 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í Parse metody 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 jsou value 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é lze 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á 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, Parse(String, NumberStyles) 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" };
      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 o formátu value. provider Obvykle se může jednat o jednu z následujících možností:

  • Objekt CultureInfo , který představuje jazykovou verzi, která poskytuje 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í. (Její implementace GetFormat pouze vrátí 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 ano null, NumberFormatInfo použije se objekt pro aktuální jazykovou verzi.

Viz také

Platí pro

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
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);
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ů, které obsahují číslo, které se má převést, je jen pro čtení.

style
NumberStyles

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

provider
IFormatProvider

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

Návraty

BigInteger

Hodnota, která je ekvivalentní číslu zadanému v parametru value .

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Výjimky

ArgumentException

style není NumberStyles hodnota.

-or-

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

ArgumentNullException

value je null.

FormatException

value není v souladu se vstupním vzorem určeným parametrem 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 v parametru value povolené pro úspěšnou operaci analýzy. styles musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style tuto metodu přetíží, pokud value obsahuje reprezentaci šestnáctkové hodnoty, když číselný systém (desítkový nebo šestnáctkový) reprezentovaný value je znám pouze za běhu, nebo pokud chcete zakázat prázdné znaky nebo symbol znaku .value

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 style tento parametr obsahuje NumberStyles.AllowHexSpecifier, value může 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 , a může se zobrazit na konci value , pokud style příznak NumberStyles.AllowTrailingWhite obsahuje.
$ Symbol měny specifický pro jazykovou verzi. Jeho pozice value je definována vlastnostmi NumberFormatInfo.CurrencyNegativePatternNumberFormatInfo.CurrencyPositivePattern jazykové verze označené parametrem provider . Symbol měny aktuální jazykové verze se může zobrazit v value případě, že 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

Fractional_digits

exponential_digits		 Posloupnost číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
, Symbol oddělovače skupin specifických pro jazykovou verzi. Symbol oddělovače skupin 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 jazykové verze určené jazykovou provider verzí se může zobrazit, 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 znak.
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.
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 .

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

Hodnota NumberStyles Prvky povolené v hodnotě kromě číslic
None Pouze prvek číslic .
AllowDecimalPoint Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent Znak "e" nebo "E", který označuje exponenciální zápis. spolu s exponential_digits.
AllowLeadingWhite Prvek ws na začátku .value
AllowTrailingWhite Prvek ws na konci .value
AllowLeadingSign Prvek znaménka na začátku znaku value.
AllowTrailingSign Prvek znaménka na konci znaku value.
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, signoddělovač skupin (,) a desetinná čárka (.).
Any Všechny prvky. value Nelze však reprezentovat š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 jsou value 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é lze 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 o formátu value. provider Obvykle se může jednat o jednu z následujících možností:

  • Objekt CultureInfo , který představuje jazykovou verzi, která poskytuje 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í. (Její implementace GetFormat pouze vrátí 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 ano null, NumberFormatInfo použije se objekt pro aktuální jazykovou verzi.

Viz také

Platí pro

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) 

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

Parametry

utf8Text
ReadOnlySpan<Byte>
style
NumberStyles
provider
IFormatProvider

Návraty

BigInteger

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Platí pro

Parse(String, IFormatProvider)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Převede řetězcovou reprezentaci čí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);
public:
 static System::Numerics::BigInteger Parse(System::String ^ value, IFormatProvider ^ provider) = IParsable<System::Numerics::BigInteger>::Parse;
public static System.Numerics.BigInteger Parse(string value, IFormatProvider provider);
public static System.Numerics.BigInteger Parse(string value, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> System.Numerics.BigInteger
Public Shared Function Parse (value As String, provider As IFormatProvider) As BigInteger

Parametry

value
String

Řetězec obsahující číslo, které se má převést.

provider
IFormatProvider

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

Návraty

BigInteger

Hodnota, která je ekvivalentní čí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 chcete-li zobrazit BigInteger hodnoty ve stejném formátu jako původní řetězce, váš kód musí volat metodu BigInteger.ToString(IFormatProvider) a předat ho NumberFormatInfo objektu, 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

Objekt BigInteger se pak dá vytvořit pomocí následujícího kódu:

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á objekt, NumberFormatInfo který poskytuje informace o formátování parametru provider .

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

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

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

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

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

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

Poznámky

Parametr value by měl být řetězcovou reprezentací čí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 NumberFormatInfo.NegativeSign a NumberFormatInfo.PositiveSign vlastnosti objektu NumberFormatInfo , který je vrácen provider metodou objektu GetFormat .
Číslic Posloupnost číslic v rozsahu od 0 do 9 Všechny počáteční nuly se ignorují.

Poznámka:

Řetězec určený parametrem value je interpretován pomocí NumberStyles.Integer stylu. Nesmí obsahovat žádné oddělovače skupin ani oddělovač desetinných míst a nesmí obsahovat desetinnou část.

Důležité

Pokud metodu Parse 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í Parse metody 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. Parse(String, IFormatProvider) Při vyvolání metody volá metodu provider parametru GetFormat 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 zadání vlastních informací o formátování do operace analýzy:

  • 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 číselné formátování informace pro danou jazykovou verzi.

  • Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o číselném formátování. (Její implementace GetFormat pouze vrátí 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 NumberFormatInfo základě objektu aktuální jazykové verze.

Viz také

Platí pro

Parse(ReadOnlySpan<Byte>, IFormatProvider) 

public:
 static System::Numerics::BigInteger Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<System::Numerics::BigInteger>::Parse;
public static System.Numerics.BigInteger Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> System.Numerics.BigInteger
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As BigInteger

Parametry

utf8Text
ReadOnlySpan<Byte>
provider
IFormatProvider

Návraty

BigInteger

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Platí pro

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Parsuje rozsah znaků do hodnoty.

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 sformátování specifické pro jazykovou verzi .

Návraty

BigInteger

Výsledek analýzy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Platí pro

Parse(String, NumberStyles)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
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, které se má převést.

style
NumberStyles

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

Návraty

BigInteger

Hodnota, která je ekvivalentní číslu zadanému v parametru value .

Výjimky

ArgumentException

style není NumberStyles hodnota.

-or-

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

ArgumentNullException

value je null.

FormatException

value není v souladu se vstupním vzorem určeným parametrem NumberStyles.

Příklady

Následující příklad ukazuje 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, symbol oddělovače skupin nebo symbol desetinné čárky), které jsou v parametru value povolené pro úspěšnou operaci analýzy. styles musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style tuto metodu přetíží, pokud value obsahuje řetězcovou reprezentaci šestnáctkové hodnoty, když číselný systém (desítkový nebo šestnáctkový) reprezentovaný value je znám pouze za běhu, nebo pokud chcete zakázat prázdné znaky nebo symbol znaku .value

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 style obsahuje NumberStyles.AllowHexSpecifierparametr, value může 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 , a může se zobrazit 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 vlastnostmi NumberFormatInfo.CurrencyNegativePatternNumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v value případě, že 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

Fractional_digits

exponential_digits		 Posloupnost číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
, Symbol oddělovače skupin specifických pro jazykovou verzi. Oddělovač skupin aktuální jazykové verze se může zobrazit, value pokud style příznak NumberStyles.AllowThousands obsahuje.
. Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit, value pokud style příznak obsahuje NumberStyles.AllowDecimalPoint . 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 znak.
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.
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 číslicemi (který odpovídá NumberStyles.None stylu) 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 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 value.

NumberStyles hodnota Prvky povolené value kromě číslic
None Pouze prvek číslic .
AllowDecimalPoint Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
AllowLeadingWhite Prvek ws na začátku .value
AllowTrailingWhite Prvek ws na konci .value
AllowLeadingSign Prvek znaménka na začátku znaku value.
AllowTrailingSign Prvek znaménka na konci znaku value.
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, signoddělovač skupin (,) a desetinná čárka (.).
Any Všechny prvky. value Nelze však reprezentovat šestnáctkové číslo.

Důležité

Pokud metodu Parse 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í Parse metody 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 jsou value 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é lze 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á 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, Parse(String, NumberStyles) 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" };
      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í systémovou jazykovou verzi. Chcete-li určit jazykovou verzi, jejíž informace formátování se používají pro operaci analýzy, zavolejte Parse(String, NumberStyles, IFormatProvider) přetížení.

Viz také

Platí pro

Parse(String)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Převede řetězcové vyjádření čí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, které chcete převést.

Návraty

BigInteger

Hodnota, která je ekvivalentní čí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 potom 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 formátu.

[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 číslic v rozsahu od 0 do 9 Všechny počáteční nuly se ignorují.

Poznámka:

Řetězec určený value parametrem je interpretován pomocí NumberStyles.Integer stylu. Nesmí obsahovat žádné oddělovače skupin ani oddělovač desetinných míst a nesmí obsahovat desetinnou část.

Parametr value je analyzován pomocí informací o formátování v objektu System.Globalization.NumberFormatInfo , který je inicializován pro aktuální systémovou jazykovou verzi. Další informace najdete na webu NumberFormatInfo.CurrentInfo. K analýze řetězce pomocí formátování informací o konkrétní jazykové verzi použijte metodu Parse(String, IFormatProvider) .

Důležité

Pokud metodu Parse 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í Parse metody k obnovení BigInteger hodnoty.

Viz také

Platí pro