Partilhar via

BigInteger.Parse Método

  • Referência

Definição

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

Converte a representação da cadeia de caracteres de um número no BigInteger equivalente.

Sobrecargas

Parse(String)

Converte a representação da cadeia de caracteres de um número no BigInteger equivalente.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analisa um intervalo de caracteres em um valor.
Parse(String, NumberStyles)

Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu BigInteger equivalente.
Parse(String, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato específico da cultura especificado em seu equivalente de BigInteger.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converte a representação de um número, contida no intervalo de caracteres somente leitura, em um estilo especificado para seu BigInteger equivalente.
Parse(String, NumberStyles, IFormatProvider)

Converte a representação de cadeia de caracteres de um número com um estilo especificado e um formato específico à cultura para seu BigInteger equivalente.

Parse(String)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Converte a representação da cadeia de caracteres de um número no BigInteger equivalente.

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

Parâmetros

value
String

Uma cadeia de caracteres que contém o número a ser convertido.

Retornos

BigInteger

Um valor equivalente ao número especificado no parâmetro value.

Exceções

ArgumentNullException

value é null.

FormatException

value não está no formato correto.

Exemplos

O exemplo a seguir usa o Parse(String) método para instanciar dois BigInteger objetos. Ele multiplica cada objeto por outro número e, em seguida, chama o Compare método para determinar a relação entre os dois valores.

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.

Comentários

O value parâmetro deve ser a representação de cadeia de caracteres de um número no formulário a seguir.

[ws] [sign] digits[ws]

Os elementos entre colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento Descrição
ws Espaço em branco opcional.
sign Um sinal opcional. Os caracteres de sinal válido são determinados pelas propriedades NumberFormatInfo.NegativeSign e NumberFormatInfo.PositiveSign da cultura atual.
dígitos Uma sequência de dígitos que varia de 0 a 9. Todos os zeros à esquerda são ignorados.

Observação

A cadeia de caracteres especificada pelo value parâmetro é interpretada usando o NumberStyles.Integer estilo . Ele não pode conter nenhum separador de grupo ou decimal, e não pode ter uma parte decimal.

O parâmetro value é analisado usando-se as informações de formatação em um objeto System.Globalization.NumberFormatInfo que é inicializado para a cultura do sistema atual. Para obter mais informações, consulte NumberFormatInfo.CurrentInfo. Para analisar uma cadeia de caracteres usando as informações de formatação de uma cultura específica, use o Parse(String, IFormatProvider) método .

Importante

Se você usar o Parse método para fazer uma viagem de ida e volta da representação de cadeia de caracteres de um BigInteger valor que foi gerado pelo ToString método , deverá usar o BigInteger.ToString(String) método com o especificador de formato "R" para gerar a representação de cadeia de caracteres do BigInteger valor. Caso contrário, a representação de cadeia de caracteres do BigInteger preserva apenas os 50 dígitos mais significativos do valor original e os dados podem ser perdidos quando você usa o Parse método para restaurar o BigInteger valor.

Confira também

Aplica-se a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Analisa um intervalo de caracteres em um valor.

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

Parâmetros

s
ReadOnlySpan<Char>

O intervalo de caracteres a serem analisados.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas à cultura sobre s.

Retornos

BigInteger

O resultado da análise s.

Implementações

Parse(ReadOnlySpan<Char>, IFormatProvider)

Aplica-se a

Parse(String, NumberStyles)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu BigInteger equivalente.

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

Parâmetros

value
String

Uma cadeia de caracteres que contém um número a ser convertido.

style
NumberStyles

Um combinação bit a bit de valores de enumeração que especificam o formato permitido de value.

Retornos

BigInteger

Um valor equivalente ao número especificado no parâmetro value.

Exceções

ArgumentException

style não é um valor NumberStyles.

- ou -

style inclui o sinalizador AllowHexSpecifier ou HexNumber em conjunto com outro valor.

ArgumentNullException

value é null.

FormatException

value não é compatível com o padrão de entrada especificado por NumberStyles.

Exemplos

O exemplo a seguir ilustra chamadas para o Parse(String, NumberStyles) método com vários valores possíveis para o style parâmetro . Ele ilustra como interpretar uma cadeia de caracteres como um valor hexadecimal e como não permitir espaços e símbolos de sinal.

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.

Comentários

O style parâmetro define os elementos de estilo (como espaço em branco, o símbolo de sinal positivo ou negativo, o símbolo separador de grupo ou o símbolo de ponto decimal) que são permitidos no value parâmetro para que a operação de análise tenha êxito. styles deve ser uma combinação de sinalizadores de bits da NumberStyles enumeração . O style parâmetro torna essa sobrecarga de método útil quando value contém a representação de cadeia de caracteres de um valor hexadecimal, quando o sistema de números (decimal ou hexadecimal) representado por value é conhecido apenas em tempo de execução ou quando você deseja não permitir espaço em branco ou um símbolo de sinal no value.

Dependendo do valor de style, o parâmetro value pode incluir os seguintes elementos:

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

Caso style inclua NumberStyles.AllowHexSpecifier, o parâmetro value pode conter os seguintes elementos:

[ws] hexdigits[ws]

Os elementos entre colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento Descrição
ws Espaço em branco opcional. O espaço em branco pode aparecer no início de value se incluir o NumberStyles.AllowLeadingWhite sinalizador e ele pode aparecer no final de value se style incluir o NumberStyles.AllowTrailingWhitestyle sinalizador.
$ Um símbolo de moeda específico de cultura. A posição na cadeia de caracteres é definida pelas propriedades NumberFormatInfo.CurrencyNegativePattern e NumberFormatInfo.CurrencyPositivePattern da cultura atual. O símbolo de moeda da cultura atual pode ser exibido em value caso style inclua o sinalizador NumberStyles.AllowCurrencySymbol.
sign Um sinal opcional. O sinal pode ser exibido no início de value caso style inclua o sinalizador NumberStyles.AllowLeadingSign e ele pode ser exibido no final de value caso style inclua o sinalizador NumberStyles.AllowTrailingSign. Os parênteses podem ser usados em value para indicar um valor negativo caso style inclua o sinalizador NumberStyles.AllowParentheses.
dígitos

Fractional_digits

exponential_digits		 Uma sequência de dígitos de 0 a 9. Para fractional_digits, somente o dígito 0 é válido.
, Um símbolo de separador do grupo específico da cultura. O separador de grupo da cultura atual poderá aparecer em value se style incluir o NumberStyles.AllowThousands sinalizador.
. Um símbolo de vírgula decimal específico de cultura. O símbolo da vírgula decimal da cultura atual pode ser exibido em value caso style inclua o sinalizador NumberStyles.AllowDecimalPoint. Somente o dígito 0 pode aparecer como um dígito fracionário para que a operação de análise tenha êxito; se fractional_digits incluir qualquer outro dígito, um FormatException será gerado.
E O caractere "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O parâmetro value pode representar um número em notação exponencial caso style inclua o sinalizador NumberStyles.AllowExponent.
hexdigits Uma sequência de dígitos hexadecimais de 0 a f ou de 0 a F.

Observação

Todos os caracteres NUL de terminação (U+0000) no s são ignorados pela operação de análise, independentemente do valor do style argumento.

Uma cadeia de caracteres apenas com dígitos (que corresponde ao estilo NumberStyles.None ) sempre é analisada com êxito. A maioria dos elementos de controle de membros NumberStyles restantes que podem estar presentes, mas que não precisam estar presentes, na cadeia de caracteres de entrada. A tabela a seguir indica como os membros NumberStyles individuais afetam os elementos que podem estar presentes em value.

NumberStyles valor Elementos permitidos em value além de dígitos
None Somente o elemento de dígitos .
AllowDecimalPoint Os elementos de ponto decimal (.) e de dígitos fracionários .
AllowExponent O caractere "e" ou "E", que indica notação exponencial, juntamente com exponential_digits.
AllowLeadingWhite O elemento ws no início de value.
AllowTrailingWhite O elemento ws no final de value.
AllowLeadingSign O elemento sign no início de value.
AllowTrailingSign O elemento sinal no final de value.
AllowParentheses O elemento sinal na forma de parênteses que incluem o valor numérico.
AllowThousands O elemento separador do grupo (,).
AllowCurrencySymbol O elemento de moeda ($).
Currency Todos os elementos. No entanto, value não pode representar um número hexadecimal ou um número em notação exponencial.
Float O elemento ws no início ou no final de value, sinal no início de valuee o símbolo de ponto decimal (.). O parâmetro value também pode usar notação exponencial.
Number Os elementos , , separador de grupo (,) e ponto decimal (.).wssign
Any Todos os elementos. No entanto, value não pode representar um número hexadecimal.

Importante

Se você usar o Parse método para fazer uma viagem de ida e volta da representação de cadeia de caracteres de um BigInteger valor que foi gerado pelo ToString método , deverá usar o BigInteger.ToString(String) método com o especificador de formato "R" para gerar a representação de cadeia de caracteres do BigInteger valor. Caso contrário, a representação de cadeia de caracteres do BigInteger preserva apenas os 50 dígitos mais significativos do valor original e os dados podem ser perdidos quando você usa o Parse método para restaurar o BigInteger valor.

Ao contrário dos outros NumberStyles valores, que permitem, mas não exigem, a presença de elementos de estilo específicos no value, o valor de NumberStyles.AllowHexSpecifier estilo significa que os caracteres numéricos individuais em value são sempre interpretados como caracteres hexadecimal. Os caracteres hexadecimais válidos são 0-9, A-F e a-f. Os únicos outros sinalizadores que podem ser combinados com o parâmetro style são NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. (A enumeração de NumberStyles inclui um estilo de número composto, HexNumber, que inclui ambos os sinalizadores de espaço em branco.)

Observação

Caso value seja a representação da cadeia de caracteres de um número hexadecimal, ele não pode ser precedido por qualquer decoração (como 0x ou &h) que o diferencia como um número hexadecimal. Isso faz a conversão falhar.

Se value for uma cadeia de caracteres value hexadecimal, o Parse(String, NumberStyles) método interpretará como um número negativo armazenado usando a representação complementar de dois se seus dois primeiros dígitos hexadecimal forem maiores ou iguais a 0x80. Em outras palavras, o método interpreta o bit de ordem mais alta do primeiro byte em value como o bit de sinal. Para garantir que uma cadeia de caracteres hexadecimal seja interpretada corretamente como um número positivo, o primeiro dígito em value deve ter um valor igual a zero. Por exemplo, o método interpreta 0x80 como um valor negativo, mas interpreta 0x080 ou 0x0080 como um valor positivo. O exemplo a seguir ilustra a diferença entre cadeias de caracteres hexadecimal que representam valores negativos e positivos.

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.

O parâmetro value é analisado usando-se as informações de formatação em um objeto NumberFormatInfo que é inicializado para a cultura do sistema atual. Para especificar a cultura cujas informações de formatação são usadas para a operação de análise, chame a Parse(String, NumberStyles, IFormatProvider) sobrecarga.

Confira também

Aplica-se a

Parse(String, IFormatProvider)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Converte a representação de cadeia de caracteres de um número em um formato específico da cultura especificado em seu equivalente de BigInteger.

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

Parâmetros

value
String

Uma cadeia de caracteres que contém um número a ser convertido.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas à cultura sobre value.

Retornos

BigInteger

Um valor equivalente ao número especificado no parâmetro value.

Implementações

Parse(String, IFormatProvider)

Exceções

ArgumentNullException

value é null.

FormatException

value não está no formato correto.

Exemplos

Os exemplos a seguir mostram duas maneiras de definir o bloco (~) como um sinal negativo para valores de formatação BigInteger . Observe que para exibir os BigInteger valores no mesmo formato que as cadeias de caracteres originais, seu código deve chamar o BigInteger.ToString(IFormatProvider) método e passá-lo o NumberFormatInfo objeto que fornece informações de formatação.

O primeiro exemplo define uma classe que implementa IFormatProvider e usa o GetFormat método para retornar o NumberFormatInfo objeto que fornece informações de formatação.

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

Em BigInteger seguida, um objeto pode ser instanciado com o seguinte código:

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)

O segundo exemplo é mais simples. Ele passa o NumberFormatInfo objeto que fornece informações de formatação para o provider parâmetro .

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)

Comentários

O value parâmetro deve ser a representação de cadeia de caracteres de um número no seguinte formulário:

[ws] [sign] digits[ws]

Os elementos entre colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento Descrição
ws Espaço em branco opcional.
sign Um sinal opcional. Caracteres de sinal válidos são determinados pelas NumberFormatInfo.NegativeSign propriedades e NumberFormatInfo.PositiveSign do NumberFormatInfo objeto que é retornado pelo provider método do GetFormat objeto.
dígitos Uma sequência de dígitos que varia de 0 a 9. Todos os zeros à esquerda são ignorados.

Observação

A cadeia de caracteres especificada pelo value parâmetro é interpretada usando o NumberStyles.Integer estilo . Ele não pode conter nenhum separador de grupo ou decimal, e não pode ter uma parte decimal.

Importante

Se você usar o Parse método para fazer uma viagem de ida e volta da representação de cadeia de caracteres de um BigInteger valor que foi gerado pelo ToString método , deverá usar o BigInteger.ToString(String) método com o especificador de formato "R" para gerar a representação de cadeia de caracteres do BigInteger valor. Caso contrário, a representação de cadeia de caracteres do BigInteger preserva apenas os 50 dígitos mais significativos do valor original e os dados podem ser perdidos quando você usa o Parse método para restaurar o BigInteger valor.

O provider parâmetro é uma implementação IFormatProvider cujo GetFormat método retorna um NumberFormatInfo objeto que fornece informações de formatação específicas da cultura. Quando o Parse(String, IFormatProvider) método é invocado, ele chama o provider método do GetFormat parâmetro e passa a ele um Type objeto que representa o NumberFormatInfo tipo. Em GetFormat seguida, o método retorna o NumberFormatInfo objeto que fornece informações sobre o formato do value parâmetro. Existem três maneiras de usar o parâmetro provider para fornecer informações de formatação personalizadas para a operação de análise:

  • É possível passar um objeto CultureInfo que representa a cultura que fornece informações de formatação. O método GetFormat retorna o objeto NumberFormatInfo que fornece informações de formatação numérica para essa cultura.

  • É possível passar o objeto real NumberFormatInfo que fornece informações de formatação numérica. (Sua implementação de GetFormat retorna apenas ele próprio.)

  • É possível passar um objeto personalizado que implementa IFormatProvider. O método GetFormat cria uma instância e retorna o objeto NumberFormatInfo que fornece informações de formatação.

Se provider for null, a formatação de value será interpretada com base no NumberFormatInfo objeto da cultura atual.

Confira também

Aplica-se a

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Converte a representação de um número, contida no intervalo de caracteres somente leitura, em um estilo especificado para seu BigInteger equivalente.

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

Parâmetros

value
ReadOnlySpan<Char>

Um intervalo de caracteres somente leitura que contém o número a ser convertido.

style
NumberStyles

Um combinação bit a bit de valores de enumeração que especificam o formato permitido de value.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas à cultura sobre value.

Retornos

BigInteger

Um valor equivalente ao número especificado no parâmetro value.

Implementações

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Exceções

ArgumentException

style não é um valor NumberStyles.

- ou -

style inclui o sinalizador AllowHexSpecifier ou HexNumber em conjunto com outro valor.

ArgumentNullException

value é null.

FormatException

value não é compatível com o padrão de entrada especificado por style.

Comentários

O style parâmetro define os elementos de estilo (como espaço em branco, o símbolo de sinal positivo ou negativo, o símbolo separador de grupo ou o símbolo de ponto decimal) que são permitidos no value parâmetro para que a operação de análise tenha êxito. styles deve ser uma combinação de sinalizadores de bits da NumberStyles enumeração . O style parâmetro torna essa sobrecarga de método útil quando value contém a representação de um valor hexadecimal, quando o sistema de números (decimal ou hexadecimal) representado por value é conhecido apenas em tempo de execução ou quando você deseja não permitir espaço em branco ou um símbolo de sinal no value.

Dependendo do valor de style, o parâmetro value pode incluir os seguintes elementos:

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

Se style incluir NumberStyles.AllowHexSpecifier, o value parâmetro poderá incluir os seguintes elementos:

[ws] hexdigits[ws]

Os elementos entre colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento Descrição
ws Espaço em branco opcional. O espaço em branco pode aparecer no início de value se incluir o NumberStyles.AllowLeadingWhite sinalizador e ele poderá aparecer no final de value se style incluir o NumberStyles.AllowTrailingWhitestyle sinalizador .
$ Um símbolo de moeda específico de cultura. Sua posição em value é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades e NumberFormatInfo.CurrencyPositivePattern da cultura indicada pelo provider parâmetro . O símbolo de moeda da cultura atual pode ser exibido em value caso style inclua o sinalizador NumberStyles.AllowCurrencySymbol.
sign Um sinal opcional. O sinal pode ser exibido no início de value caso style inclua o sinalizador NumberStyles.AllowLeadingSign e ele pode ser exibido no final de value caso style inclua o sinalizador NumberStyles.AllowTrailingSign. Os parênteses podem ser usados em value para indicar um valor negativo caso style inclua o sinalizador NumberStyles.AllowParentheses.
dígitos

Fractional_digits

exponential_digits		 Uma sequência de dígitos de 0 a 9. Para fractional_digits, somente o dígito 0 é válido.
, Um símbolo de separador do grupo específico da cultura. O símbolo separador de grupo da cultura especificada por provider poderá aparecer em value se style incluir o NumberStyles.AllowThousands sinalizador .
. Um símbolo de vírgula decimal específico de cultura. O símbolo de ponto decimal da cultura designada por provider poderá aparecer em value se style incluir o NumberStyles.AllowDecimalPoint sinalizador . Somente o dígito 0 pode aparecer como um dígito fracionário para que a operação de análise seja bem-sucedida; se fractional_digits incluir qualquer outro dígito, um FormatException será gerado.
E O caractere "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O parâmetro value pode representar um número em notação exponencial caso style inclua o sinalizador NumberStyles.AllowExponent.
hexdigits Uma sequência de dígitos hexadecimais de 0 a f ou de 0 a F.

Observação

Todos os caracteres NUL de terminação (U+0000) em s são ignorados pela operação de análise, independentemente do valor do style argumento.

Um value com apenas dígitos (que corresponde ao NumberStyles.None estilo) sempre analisa com êxito. A maioria dos membros restantes NumberStyles controla os elementos que podem estar presentes, mas não precisam estar presentes, em value. A tabela a seguir indica como os membros NumberStyles individuais afetam os elementos que podem estar presentes em value.

Valor NumberStyles Elementos permitidos no valor além de dígitos
None Somente o elemento de dígitos .
AllowDecimalPoint Os elementos de ponto decimal (.) e dígitos fracionários .
AllowExponent O caractere "e" ou "E", que indica a notação exponencial. junto com exponential_digits.
AllowLeadingWhite O elemento ws no início de value.
AllowTrailingWhite O elemento ws no final de value.
AllowLeadingSign O elemento sign no início de value.
AllowTrailingSign O elemento sinal no final de value.
AllowParentheses O elemento sinal na forma de parênteses que incluem o valor numérico.
AllowThousands O elemento separador do grupo (,).
AllowCurrencySymbol O elemento de moeda ($).
Currency Todos os elementos. No entanto, value não pode representar um número hexadecimal ou um número em notação exponencial.
Float O elemento ws no início ou no final de value, assina no início de valuee o símbolo de ponto decimal (.). O parâmetro value também pode usar notação exponencial.
Number Os wselementos , sign, separador de grupo (,) e ponto decimal (.).
Any Todos os elementos. No entanto, value não pode representar um número hexadecimal.

Ao contrário dos outros NumberStyles valores, que permitem, mas não exigem a presença de elementos de estilo específicos no value, o valor de NumberStyles.AllowHexSpecifier estilo significa que os caracteres numéricos individuais em value são sempre interpretados como caracteres hexadecimais. Os caracteres hexadecimais válidos são 0-9, A-F e a-f. Os únicos outros sinalizadores que podem ser combinados com o parâmetro style são NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. (A enumeração de NumberStyles inclui um estilo de número composto, HexNumber, que inclui ambos os sinalizadores de espaço em branco.)

O parâmetro provider é uma implementação de IFormatProvider. O método GetFormat retorna um objeto NumberFormatInfo que fornece informações específicas de cultura sobre o formato de value. Normalmente, provider pode ser qualquer um dos seguintes:

  • Um CultureInfo objeto que representa a cultura que fornece informações de formatação numérica. Seu GetFormat método retorna o NumberFormatInfo objeto que fornece informações de formatação numérica.

  • Um NumberFormatInfo objeto que fornece informações de formatação. (Sua implementação de GetFormat retorna apenas ele próprio.)

  • Um objeto personalizado que implementa IFormatProvider e usa o GetFormat método para instanciar e retornar o NumberFormatInfo objeto que fornece informações de formatação.

Caso provider seja null, o objeto NumberFormatInfo da cultura atual é usado.

Confira também

Aplica-se a

Parse(String, NumberStyles, IFormatProvider)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Converte a representação de cadeia de caracteres de um número com um estilo especificado e um formato específico à cultura para seu BigInteger equivalente.

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

Parâmetros

value
String

Uma cadeia de caracteres que contém um número a ser convertido.

style
NumberStyles

Um combinação bit a bit de valores de enumeração que especificam o formato permitido de value.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas à cultura sobre value.

Retornos

BigInteger

Um valor equivalente ao número especificado no parâmetro value.

Implementações

Parse(String, NumberStyles, IFormatProvider)

Exceções

ArgumentException

style não é um valor NumberStyles.

- ou -

style inclui o sinalizador AllowHexSpecifier ou HexNumber em conjunto com outro valor.

ArgumentNullException

value é null.

FormatException

value não é compatível com o padrão de entrada especificado por style.

Exemplos

O exemplo a seguir faz várias chamadas para o Parse(String, NumberStyles, IFormatProvider) método usando várias combinações de valores para os style parâmetros e provider .

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

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

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

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

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

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

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

Um número de chamadas individuais para o Parse(String, NumberStyles, IFormatProvider) método passa uma instância da classe a seguir BigIntegerFormatProvider , que define um til (~) como o sinal negativo.

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

Comentários

O style parâmetro define os elementos de estilo (como espaço em branco, o símbolo de sinal positivo ou negativo, o símbolo separador de grupo ou o símbolo de ponto decimal) que são permitidos no value parâmetro para que a operação de análise seja bem-sucedida. styles deve ser uma combinação de sinalizadores de bits da NumberStyles enumeração . O style parâmetro torna essa sobrecarga de método útil quando value contém a representação de cadeia de caracteres de um valor hexadecimal, quando o sistema numérico (decimal ou hexadecimal) representado por value é conhecido apenas em tempo de execução ou quando você deseja não permitir espaço em branco ou um símbolo de sinal no value.

Dependendo do valor de style, o parâmetro value pode incluir os seguintes elementos:

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

Se style incluir NumberStyles.AllowHexSpecifier, o value parâmetro poderá incluir os seguintes elementos:

[ws] hexdigits[ws]

Os elementos entre colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento Descrição
ws Espaço em branco opcional. O espaço em branco pode aparecer no início de value se incluir o NumberStyles.AllowLeadingWhite sinalizador e ele poderá aparecer no final de value se style incluir o NumberStyles.AllowTrailingWhitestyle sinalizador .
$ Um símbolo de moeda específico de cultura. Sua posição na cadeia de caracteres é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades e NumberFormatInfo.CurrencyPositivePattern da cultura indicada pelo provider parâmetro . O símbolo de moeda da cultura atual pode ser exibido em value caso style inclua o sinalizador NumberStyles.AllowCurrencySymbol.
sign Um sinal opcional. O sinal pode ser exibido no início de value caso style inclua o sinalizador NumberStyles.AllowLeadingSign e ele pode ser exibido no final de value caso style inclua o sinalizador NumberStyles.AllowTrailingSign. Os parênteses podem ser usados em value para indicar um valor negativo caso style inclua o sinalizador NumberStyles.AllowParentheses.
dígitos

Fractional_digits

exponential_digits		 Uma sequência de dígitos de 0 a 9. Para fractional_digits, somente o dígito 0 é válido.
, Um símbolo de separador do grupo específico da cultura. O símbolo separador de grupo da cultura especificada por provider poderá aparecer em value se style incluir o NumberStyles.AllowThousands sinalizador .
. Um símbolo de vírgula decimal específico de cultura. O símbolo de ponto decimal da cultura designada por provider poderá aparecer em value se style incluir o NumberStyles.AllowDecimalPoint sinalizador . Somente o dígito 0 pode aparecer como um dígito fracionário para que a operação de análise seja bem-sucedida; se fractional_digits incluir qualquer outro dígito, um FormatException será gerado.
E O caractere "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O parâmetro value pode representar um número em notação exponencial caso style inclua o sinalizador NumberStyles.AllowExponent.
hexdigits Uma sequência de dígitos hexadecimais de 0 a f ou de 0 a F.

Observação

Todos os caracteres NUL de terminação (U+0000) em s são ignorados pela operação de análise, independentemente do valor do style argumento.

Uma cadeia de caracteres apenas com dígitos (que corresponde ao estilo NumberStyles.None ) sempre é analisada com êxito. A maioria dos elementos de controle de membros NumberStyles restantes que podem estar presentes, mas que não precisam estar presentes, na cadeia de caracteres de entrada. A tabela a seguir indica como os membros NumberStyles individuais afetam os elementos que podem estar presentes em value.

Valor NumberStyles Elementos permitidos no valor além de dígitos
None Somente o elemento de dígitos .
AllowDecimalPoint Os elementos de ponto decimal (.) e dígitos fracionários .
AllowExponent O caractere "e" ou "E", que indica a notação exponencial. junto com exponential_digits.
AllowLeadingWhite O elemento ws no início de value.
AllowTrailingWhite O elemento ws no final de value.
AllowLeadingSign O elemento sign no início de value.
AllowTrailingSign O elemento sinal no final de value.
AllowParentheses O elemento sinal na forma de parênteses que incluem o valor numérico.
AllowThousands O elemento separador do grupo (,).
AllowCurrencySymbol O elemento de moeda ($).
Currency Todos os elementos. No entanto, value não pode representar um número hexadecimal ou um número em notação exponencial.
Float O elemento ws no início ou no final de value, assina no início de valuee o símbolo de ponto decimal (.). O parâmetro value também pode usar notação exponencial.
Number Os wselementos , sign, separador de grupo (,) e ponto decimal (.).
Any Todos os elementos. No entanto, value não pode representar um número hexadecimal.

Importante

Se você usar o Parse método para fazer uma viagem de ida e volta da representação de cadeia de caracteres de um BigInteger valor que foi gerado pelo ToString método , deverá usar o BigInteger.ToString(String) método com o especificador de formato "R" para gerar a representação de cadeia de caracteres do BigInteger valor. Caso contrário, a representação de cadeia de caracteres do BigInteger preserva apenas os 50 dígitos mais significativos do valor original e os dados podem ser perdidos quando você usa o Parse método para restaurar o BigInteger valor.

Ao contrário dos outros NumberStyles valores, que permitem, mas não exigem a presença de elementos de estilo específicos no value, o valor de NumberStyles.AllowHexSpecifier estilo significa que os caracteres numéricos individuais em value são sempre interpretados como caracteres hexadecimais. Os caracteres hexadecimais válidos são 0-9, A-F e a-f. Os únicos outros sinalizadores que podem ser combinados com o parâmetro style são NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. (A enumeração de NumberStyles inclui um estilo de número composto, HexNumber, que inclui ambos os sinalizadores de espaço em branco.)

Observação

Caso value seja a representação da cadeia de caracteres de um número hexadecimal, ele não pode ser precedido por qualquer decoração (como 0x ou &h) que o diferencia como um número hexadecimal. Isso faz a conversão falhar.

Se value for uma cadeia de caracteres value hexadecimal, o Parse(String, NumberStyles) método interpretará como um número negativo armazenado usando a representação complementar de dois se seus dois primeiros dígitos hexadecimais forem maiores ou iguais a 0x80. Em outras palavras, o método interpreta o bit de ordem mais alta do primeiro byte em value como o bit de sinal. Para garantir que uma cadeia de caracteres hexadecimal seja interpretada corretamente como um número positivo, o primeiro dígito em value deve ter um valor igual a zero. Por exemplo, o método interpreta 0x80 como um valor negativo, mas interpreta 0x080 ou 0x0080 como um valor positivo. O exemplo a seguir ilustra a diferença entre cadeias de caracteres hexadecimais que representam valores negativos e positivos.

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.

O parâmetro provider é uma implementação de IFormatProvider. O método GetFormat retorna um objeto NumberFormatInfo que fornece informações específicas de cultura sobre o formato de value. Normalmente, provider pode ser qualquer um dos seguintes:

  • Um CultureInfo objeto que representa a cultura que fornece informações de formatação numérica. Seu GetFormat método retorna o NumberFormatInfo objeto que fornece informações de formatação numérica.

  • Um NumberFormatInfo objeto que fornece informações de formatação. (Sua implementação de GetFormat retorna apenas ele próprio.)

  • Um objeto personalizado que implementa IFormatProvider e usa o GetFormat método para instanciar e retornar o NumberFormatInfo objeto que fornece informações de formatação.

Caso provider seja null, o objeto NumberFormatInfo da cultura atual é usado.

Confira também

Aplica-se a