BigInteger.Parse Método

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte utiliza o Parse(String) método para instanciar dois BigInteger objetos. Multiplica cada objeto por outro número e depois 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.

Observações

O value parâmetro deve ser a representação em cadeia de um número na seguinte forma.

[ws][sinal]dígitos[ws]

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

Elemento	Description
ws	Espaço em branco opcional.
assinar	Um sinal opcional. Caracteres de signo válidos são determinados pelas NumberFormatInfo.NegativeSign propriedades e NumberFormatInfo.PositiveSign da cultura atual.
dígitos	Uma sequência de dígitos que varia de 0 a 9. Quaisquer zeros à esquerda são ignorados.

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

Ver também

• TryParse

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte ilustra chamadas ao Parse(String, NumberStyles) método com vários valores possíveis para o style parâmetro. Ilustra como interpretar uma cadeia como um valor hexadecimal e como proibir espaços e símbolos de signos.

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.

Observações

O style parâmetro define os elementos de estilo (como espaço em branco, símbolo de sinal positivo ou negativo, símbolo de separador de grupo ou símbolo de ponto decimal) que são permitidos no value parâmetro para que a operação de análise sintática tenha sucesso. styles deve ser uma combinação de flags de bits da NumberStyles enumeração. O style parâmetro torna este método sobrecarregado útil quando value contém a representação em cadeia de um valor hexadecimal, quando o sistema numérico (decimal ou hexadecimal) representado por value é conhecido apenas em tempo de execução, ou quando se pretende impedir espaço em branco ou um símbolo de sinal em value.

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

[ws][$][signo][dígitos,]dígitos[.fractional_digits][E[sign]exponential_digits][ws]

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

[ws]hexdigits[ws]

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

Elemento	Description
ws	Espaço em branco opcional. O espaço em branco pode aparecer no início de value if style inclui a NumberStyles.AllowLeadingWhite bandeira, e pode aparecer no final de value if style inclui a NumberStyles.AllowTrailingWhite bandeira.
$	Um símbolo monetário específico de cada cultura. A sua posição na corda é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades e NumberFormatInfo.CurrencyPositivePattern da cultura atual. O símbolo monetário da cultura atual pode aparecer se valuestyle incluir a NumberStyles.AllowCurrencySymbol bandeira.
assinar	Um sinal opcional. O sinal pode aparecer no início de value se incluir a NumberStyles.AllowLeadingSign bandeira, e pode aparecer no final de value se style incluir a NumberStyles.AllowTrailingSignstyle bandeira. Parênteses podem ser usados value para indicar um valor negativo se style incluir a NumberStyles.AllowParentheses bandeira.
dígitos fractional_digits exponential_digits	Uma sequência de dígitos de 0 a 9. Para fractional_digits, apenas o dígito 0 é válido.
,	Um símbolo separador de grupo específico de cada cultura. O separador de grupo da cultura atual pode aparecer em value se style incluir a NumberStyles.AllowThousands bandeira.
.	Um símbolo de ponto decimal específico para cada cultura. O símbolo de ponto decimal da cultura atual pode aparecer em value se style incluir a NumberStyles.AllowDecimalPoint bandeira. Apenas o dígito 0 pode aparecer como um dígito fracionário para que a operação de análise sintética tenha sucesso; Se fractional_digits incluir qualquer outro dígito, a FormatException é lançado.
E	O carácter "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O value parâmetro pode representar um número em notação exponencial se style incluir a NumberStyles.AllowExponent bandeira.
Hexdigits	Uma sequência de dígitos hexadecimais de 0 a f, ou de 0 a F.

Uma sequência apenas com dígitos (que corresponde ao NumberStyles.None estilo) faz sempre pars com sucesso. A maioria dos membros restantes NumberStyles controla elementos que podem estar presentes, mas não são obrigados a estar, na cadeia de entrada. A tabela seguinte indica como os membros individuais NumberStyles afetam os elementos que podem estar presentes em value.

NumberStyles valor	Elementos permitidos value além dos dígitos
None	Apenas o elemento dígitos .
AllowDecimalPoint	Os elementos de ponto decimal (.) e de dígitos fracionários .
AllowExponent	O carácter "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 signo no início de value.
AllowTrailingSign	O elemento signo no final de value.
AllowParentheses	O elemento do signo na forma de parênteses que envolvem o valor numérico.
AllowThousands	O elemento separador de grupo (,).
AllowCurrencySymbol	O elemento da 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 fim de value, sinal no início de value, e o símbolo da vírgula decimal (.). O value parâmetro 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 em value, o NumberStyles.AllowHexSpecifier valor de estilo significa que os caracteres numéricos individuais em value são sempre interpretados como caracteres hexadecimais. Caracteres hexadecimais válidos são 0-9, A-F e a-f. Os únicos outros flags que podem ser combinados com o style parâmetro são NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. (A NumberStyles enumeração inclui um estilo numérico composto, HexNumber, que inclui ambas as bandeiras de espaço em branco.)

Se value for uma cadeia hexadecimal, o Parse(String, NumberStyles) método interpreta value como um número negativo armazenado usando a representação do complemento de dois se os seus dois primeiros dígitos hexadecimais forem maiores ou iguais a 0x80. Por 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 hexadecimal é corretamente interpretada como um número positivo, o primeiro dígito em value deve ter um valor zero. Por exemplo, o método interpreta 0x80 como um valor negativo, mas interpreta como ou 0x0800x0080 como um valor positivo. O exemplo seguinte ilustra a diferença entre cadeias 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 value parâmetro é analisado utilizando a informação de formatação num NumberFormatInfo objeto que é inicializado para a cultura do sistema atual. Para especificar a cultura cuja informação de formatação é usada para a operação de análise sintática, chame-se a Parse(String, NumberStyles, IFormatProvider) sobrecarga.

Ver também

• TryParse

public:
 static System::Numerics::BigInteger Parse(System::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

Devoluções

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

Exceções

Exemplos

Os exemplos seguintes mostram duas formas de definir o tilde (~) como sinal negativo para valores de BigInteger formatação. Note que, para mostrar os BigInteger valores no mesmo formato das strings originais, o seu código deve chamar o BigInteger.ToString(IFormatProvider) método e passar-lhe o NumberFormatInfo objeto que fornece a informação de formatação.

O primeiro exemplo define uma classe que implementa IFormatProvider e utiliza o GetFormat método para devolver o NumberFormatInfo objeto que fornece a informação 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

Um BigInteger objeto pode então 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 direto. Passa o NumberFormatInfo objeto que fornece a informação de formatação ao 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)

Observações

O value parâmetro deve ser a representação em cadeia de um número na seguinte forma:

[ws][sinal]dígitos[ws]

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

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

O provider parâmetro é uma IFormatProvider implementação cujo GetFormat método devolve um NumberFormatInfo objeto que fornece informação de formatação específica para a cultura. Quando o Parse(String, IFormatProvider) método é invocado, chama o provider método do GetFormat parâmetro e passa-lhe um Type objeto que representa o NumberFormatInfo tipo. O GetFormat método devolve então o NumberFormatInfo objeto que fornece informação sobre o formato do value parâmetro. Existem três formas de usar o provider parâmetro para fornecer informação de formatação personalizada à operação de análise sintática:

• Pode passar um CultureInfo objeto que representa a cultura que fornece a informação de formatação. O seu GetFormat método devolve o NumberFormatInfo objeto que fornece informação numérica de formatação para essa cultura.

• Pode passar o objeto real NumberFormatInfo que fornece a informação numérica de formatação. (A sua implementação de GetFormat simplesmente devolve-se a si própria.)

• Podes passar um objeto personalizado que implementa IFormatProvider. O seu GetFormat método instancia e devolve o NumberFormatInfo objeto que fornece a informação de formatação.

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

Ver também

• TryParse

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

Devoluções

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

Exceções

Observações

O style parâmetro define os elementos de estilo (como espaço em branco, símbolo de sinal positivo ou negativo, símbolo de separador de grupo ou símbolo de ponto decimal) que são permitidos no value parâmetro para que a operação de análise sintática tenha sucesso. styles deve ser uma combinação de flags de bits da NumberStyles enumeração. O style parâmetro torna este método de sobrecarga útil quando value contém a representação de um valor hexadecimal, quando o sistema numérico (decimal ou hexadecimal) representado por value é conhecido apenas em tempo de execução, ou quando se pretende impedir espaço em branco ou um símbolo de sinal em value.

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

[ws][$][sinal][dígitos,]dígitos[.fractional_digits][E[sinal]exponential_digits][ws]

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

[ws]hexdigits[ws]

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

Elemento	Description
ws	Espaço em branco opcional. O espaço em branco pode aparecer no início de value if style inclui a NumberStyles.AllowLeadingWhite bandeira, e pode aparecer no final de value if style inclui a NumberStyles.AllowTrailingWhite bandeira.
$	Um símbolo monetário específico de cada cultura. A sua posição em value é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades e NumberFormatInfo.CurrencyPositivePattern da cultura indicadas pelo provider parâmetro. O símbolo monetário da cultura atual pode aparecer se valuestyle incluir a NumberStyles.AllowCurrencySymbol bandeira.
assinar	Um sinal opcional. O sinal pode aparecer no início de value se incluir a NumberStyles.AllowLeadingSign bandeira, e pode aparecer no final de value se style incluir a NumberStyles.AllowTrailingSignstyle bandeira. Parênteses podem ser usados value para indicar um valor negativo se style incluir a NumberStyles.AllowParentheses bandeira.
dígitos fractional_digits exponential_digits	Uma sequência de dígitos de 0 a 9. Para fractional_digits, apenas o dígito 0 é válido.
,	Um símbolo separador de grupo específico de cada cultura. O símbolo separador de grupo da cultura especificada por provider pode aparecer em value se style incluir a NumberStyles.AllowThousands bandeira.
.	Um símbolo de ponto decimal específico para cada cultura. O símbolo da vírgula decimal da cultura designada por provider pode aparecer em value se style incluir a NumberStyles.AllowDecimalPoint bandeira. Apenas o dígito 0 pode aparecer como um dígito fracionário para que a operação de análise sintética tenha sucesso; Se fractional_digits incluir qualquer outro dígito, a FormatException é lançado.
E	O carácter "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O value parâmetro pode representar um número em notação exponencial se style incluir a NumberStyles.AllowExponent bandeira.
Hexdigits	Uma sequência de dígitos hexadecimais de 0 a f, ou de 0 a F.

A value apenas com dígitos (que corresponde ao NumberStyles.None estilo) faz sempre análises com sucesso. A maioria dos membros restantes NumberStyles controla elementos que podem estar presentes, mas não são obrigados a estar presentes, em value. A tabela seguinte indica como os membros individuais NumberStyles afetam os elementos que podem estar presentes em value.

Valor de NumberStyles	Elementos permitidos em valor além dos dígitos
None	Apenas o elemento dígitos .
AllowDecimalPoint	Os elementos de ponto decimal (.) e de dígitos fracionários .
AllowExponent	O carácter "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 signo no início de value.
AllowTrailingSign	O elemento signo no final de value.
AllowParentheses	O elemento do signo na forma de parênteses que envolvem o valor numérico.
AllowThousands	O elemento separador de grupo (,).
AllowCurrencySymbol	O elemento da 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 fim de value, sinal no início de value, e o símbolo da vírgula decimal (.). O value parâmetro também pode usar notação exponencial.
Number	Os ws, sign, separador de grupo (,) e os elementos da vírgula 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 em value, o NumberStyles.AllowHexSpecifier valor de estilo significa que os caracteres numéricos individuais em value são sempre interpretados como caracteres hexadecimais. Caracteres hexadecimais válidos são 0-9, A-F e a-f. Os únicos outros flags que podem ser combinados com o style parâmetro são NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. (A NumberStyles enumeração inclui um estilo numérico composto, HexNumber, que inclui ambas as bandeiras de espaço em branco.)

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

• Um CultureInfo objeto que representa a cultura que fornece informação numérica de formatação. O seu GetFormat método devolve o NumberFormatInfo objeto que fornece a informação numérica de formatação.

• Um NumberFormatInfo objeto que fornece informação de formatação. (A sua implementação de GetFormat simplesmente devolve-se a si própria.)

• Um objeto personalizado que implementa IFormatProvider e utiliza o GetFormat método para instanciar e devolver o NumberFormatInfo objeto que fornece informação de formatação.

Se provider for null, o NumberFormatInfo objeto para a cultura atual é usado.

Ver também

• TryParse

public:
 static System::Numerics::BigInteger Parse(System::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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte faz várias chamadas ao 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.

Várias das chamadas individuais ao Parse(String, NumberStyles, IFormatProvider) método passam por uma instância da classe seguinte BigIntegerFormatProvider , que define um tilde (~) como 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

Observações

O style parâmetro define os elementos de estilo (como espaço em branco, símbolo de sinal positivo ou negativo, símbolo de separador de grupo ou símbolo de ponto decimal) que são permitidos no value parâmetro para que a operação de análise sintática tenha sucesso. styles deve ser uma combinação de flags de bits da NumberStyles enumeração. O style parâmetro torna este método sobrecarregado útil quando value contém a representação em cadeia de um valor hexadecimal, quando o sistema numérico (decimal ou hexadecimal) representado por value é conhecido apenas em tempo de execução, ou quando se pretende impedir espaço em branco ou um símbolo de sinal em value.

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

[ws][$][sinal][dígitos,]dígitos[.fractional_digits][E[sinal]exponential_digits][ws]

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

[ws]hexdigits[ws]

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

Elemento	Description
ws	Espaço em branco opcional. O espaço em branco pode aparecer no início de value if style inclui a NumberStyles.AllowLeadingWhite bandeira, e pode aparecer no final de value if style inclui a NumberStyles.AllowTrailingWhite bandeira.
$	Um símbolo monetário específico de cada cultura. A sua posição na corda é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades e NumberFormatInfo.CurrencyPositivePattern da cultura indicadas pelo provider parâmetro. O símbolo monetário da cultura atual pode aparecer se valuestyle incluir a NumberStyles.AllowCurrencySymbol bandeira.
assinar	Um sinal opcional. O sinal pode aparecer no início de value se incluir a NumberStyles.AllowLeadingSign bandeira, e pode aparecer no final de value se style incluir a NumberStyles.AllowTrailingSignstyle bandeira. Parênteses podem ser usados value para indicar um valor negativo se style incluir a NumberStyles.AllowParentheses bandeira.
dígitos fractional_digits exponential_digits	Uma sequência de dígitos de 0 a 9. Para fractional_digits, apenas o dígito 0 é válido.
,	Um símbolo separador de grupo específico de cada cultura. O símbolo separador de grupo da cultura especificada por provider pode aparecer em value se style incluir a NumberStyles.AllowThousands bandeira.
.	Um símbolo de ponto decimal específico para cada cultura. O símbolo da vírgula decimal da cultura designada por provider pode aparecer em value se style incluir a NumberStyles.AllowDecimalPoint bandeira. Apenas o dígito 0 pode aparecer como um dígito fracionário para que a operação de análise sintética tenha sucesso; Se fractional_digits incluir qualquer outro dígito, a FormatException é lançado.
E	O carácter "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O value parâmetro pode representar um número em notação exponencial se style incluir a NumberStyles.AllowExponent bandeira.
Hexdigits	Uma sequência de dígitos hexadecimais de 0 a f, ou de 0 a F.

Uma sequência apenas com dígitos (que corresponde ao NumberStyles.None estilo) faz sempre pars com sucesso. A maioria dos membros restantes NumberStyles controla elementos que podem estar presentes, mas não são obrigados a estar, na cadeia de entrada. A tabela seguinte indica como os membros individuais NumberStyles afetam os elementos que podem estar presentes em value.

Valor de NumberStyles	Elementos permitidos em valor além dos dígitos
None	Apenas o elemento dígitos .
AllowDecimalPoint	Os elementos de ponto decimal (.) e de dígitos fracionários .
AllowExponent	O carácter "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 signo no início de value.
AllowTrailingSign	O elemento signo no final de value.
AllowParentheses	O elemento do signo na forma de parênteses que envolvem o valor numérico.
AllowThousands	O elemento separador de grupo (,).
AllowCurrencySymbol	O elemento da 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 fim de value, sinal no início de value, e o símbolo da vírgula decimal (.). O value parâmetro também pode usar notação exponencial.
Number	Os ws, sign, separador de grupo (,) e os elementos da vírgula 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 em value, o NumberStyles.AllowHexSpecifier valor de estilo significa que os caracteres numéricos individuais em value são sempre interpretados como caracteres hexadecimais. Caracteres hexadecimais válidos são 0-9, A-F e a-f. Os únicos outros flags que podem ser combinados com o style parâmetro são NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. (A NumberStyles enumeração inclui um estilo numérico composto, HexNumber, que inclui ambas as bandeiras de espaço em branco.)

Se value for uma cadeia hexadecimal, o Parse(String, NumberStyles) método interpreta value como um número negativo armazenado usando a representação do complemento de dois se os seus dois primeiros dígitos hexadecimais forem maiores ou iguais a 0x80. Por 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 hexadecimal é corretamente interpretada como um número positivo, o primeiro dígito em value deve ter um valor zero. Por exemplo, o método interpreta 0x80 como um valor negativo, mas interpreta como ou 0x0800x0080 como um valor positivo. O exemplo seguinte ilustra a diferença entre cadeias 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 provider parâmetro é uma IFormatProvider implementação. O seu GetFormat método devolve um NumberFormatInfo objeto que fornece informação específica da cultura sobre o formato de value. Normalmente, provider pode ser qualquer um dos seguintes:

• Um CultureInfo objeto que representa a cultura que fornece informação numérica de formatação. O seu GetFormat método devolve o NumberFormatInfo objeto que fornece a informação numérica de formatação.

• Um NumberFormatInfo objeto que fornece informação de formatação. (A sua implementação de GetFormat simplesmente devolve-se a si própria.)

• Um objeto personalizado que implementa IFormatProvider e utiliza o GetFormat método para instanciar e devolver o NumberFormatInfo objeto que fornece informação de formatação.

Se provider for null, o NumberFormatInfo objeto para a cultura atual é usado.

Ver também

• TryParse