Comparteix a través de

BigInteger.Parse Método

  • Referencia

Definición

Espacio de nombres:
System.Numerics
Ensamblado:
System.Runtime.Numerics.dll
Ensamblado:
System.Numerics.dll
Ensamblado:
netstandard.dll

Convierte la representación en forma de cadena de un número en su BigInteger equivalente.

Sobrecargas

Parse(String)

Convierte la representación en forma de cadena de un número en su BigInteger equivalente.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analiza un intervalo de caracteres en un valor.
Parse(String, NumberStyles)

Convierte la representación de cadena de un número con un estilo especificado en su BigInteger equivalente.
Parse(String, IFormatProvider)

Convierte la representación en forma de cadena de un número con el formato específico de la referencia cultural indicada en su BigInteger equivalente.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convierte la representación de un número, incluida en el intervalo de solo lectura especificado de caracteres, en un estilo especificado en su equivalente BigInteger.
Parse(String, NumberStyles, IFormatProvider)

Convierte la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en su equivalente de BigInteger.

Parse(String)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Convierte la representación en forma de cadena de un número en su 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

Cadena que contiene el número que se va a convertir.

Devoluciones

BigInteger

Valor equivalente al número especificado en el parámetro value.

Excepciones

ArgumentNullException

value es null.

FormatException

value no tiene el formato correcto.

Ejemplos

En el ejemplo siguiente se usa el Parse(String) método para crear instancias de dos BigInteger objetos. Multiplica cada objeto por otro número y, a continuación, llama al Compare método para determinar la relación entre los dos 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.

Comentarios

El value parámetro debe ser la representación de cadena de un número en el formato siguiente.

[ws] [sign] digits[ws]

Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.

Elemento Descripción
ws Espacio en blanco opcional.
sign Un signo opcional. Los caracteres de signo válidos se determinan mediante las NumberFormatInfo.NegativeSign propiedades y NumberFormatInfo.PositiveSign de la referencia cultural actual.
dígitos Secuencia de dígitos comprendidos entre 0 y 9. Se omiten los ceros iniciales.

Nota

La cadena especificada por el value parámetro se interpreta mediante el NumberStyles.Integer estilo . No puede contener separadores de grupo ni separadores decimales y no puede tener una parte decimal.

El value parámetro se analiza mediante la información de formato de un System.Globalization.NumberFormatInfo objeto que se inicializa para la referencia cultural del sistema actual. Para obtener más información, vea NumberFormatInfo.CurrentInfo. Para analizar una cadena mediante la información de formato de una referencia cultural específica, use el Parse(String, IFormatProvider) método .

Importante

Si usa el Parse método para realizar un recorrido de ida y vuelta la representación de cadena de un BigInteger valor generado por el ToString método , debe usar el BigInteger.ToString(String) método con el especificador de formato "R" para generar la representación de cadena del BigInteger valor. De lo contrario, la representación de cadena de BigInteger conserva solo los 50 dígitos más significativos del valor original y los datos se pueden perder cuando se usa el Parse método para restaurar el BigInteger valor.

Consulte también

Se aplica a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Analiza un intervalo de caracteres en un 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>

Intervalo de caracteres que se van a analizar.

provider
IFormatProvider

Un objeto que proporciona información de formato específica de la referencia cultural sobre s.

Devoluciones

BigInteger

Resultado del análisis sde .

Implementaciones

Parse(ReadOnlySpan<Char>, IFormatProvider)

Se aplica a

Parse(String, NumberStyles)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Convierte la representación de cadena de un número con un estilo especificado en su 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

Cadena que contiene un número que se va a convertir.

style
NumberStyles

Combinación bit a bit de los valores de enumeración que especifican el formato permitido de value.

Devoluciones

BigInteger

Valor equivalente al número especificado en el parámetro value.

Excepciones

ArgumentException

style no es un valor NumberStyles.

o bien

style incluye la marca AllowHexSpecifier o HexNumber junto con otro valor.

ArgumentNullException

value es null.

FormatException

value no cumple el modelo de entrada especificado por NumberStyles.

Ejemplos

En el ejemplo siguiente se muestran las llamadas al Parse(String, NumberStyles) método con varios valores posibles para el style parámetro . Muestra cómo interpretar una cadena como un valor hexadecimal y cómo no permitir espacios y firmar símbolos.

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.

Comentarios

El style parámetro define los elementos de estilo (como el espacio en blanco, el símbolo de signo positivo o negativo, el símbolo separador de grupo o el símbolo de separador decimal) que se permiten en el value parámetro para que la operación de análisis se realice correctamente. styles debe ser una combinación de marcas de bits de la NumberStyles enumeración . El style parámetro hace que esta sobrecarga de método sea útil cuando value contiene la representación de cadena de un valor hexadecimal, cuando el sistema numérico (decimal o hexadecimal) representado por value solo se conoce en tiempo de ejecución, o cuando se desea denegar el espacio en blanco o un símbolo de signo en value.

Según el valor de style, el value parámetro puede incluir los siguientes elementos:

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

Si style incluye NumberStyles.AllowHexSpecifier, el value parámetro puede contener los siguientes elementos:

[ws] hexdigits[ws]

Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.

Elemento Descripción
ws Espacio en blanco opcional. El espacio en blanco puede aparecer al principio de value si incluye la NumberStyles.AllowLeadingWhite marca y puede aparecer al final de value si style incluye la NumberStyles.AllowTrailingWhitestyle marca.
$ Símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las NumberFormatInfo.CurrencyNegativePattern propiedades y NumberFormatInfo.CurrencyPositivePattern de la referencia cultural actual. El símbolo de moneda de la referencia cultural actual puede aparecer en value si style incluye la NumberStyles.AllowCurrencySymbol marca .
sign Un signo opcional. El signo puede aparecer al principio de value si incluye la NumberStyles.AllowLeadingSign marca y puede aparecer al final de value si style incluye la NumberStyles.AllowTrailingSignstyle marca . Los paréntesis se pueden usar en value para indicar un valor negativo si style incluye la NumberStyles.AllowParentheses marca .
dígitos

fractional_digits

exponential_digits		 Secuencia de dígitos de 0 a 9. Para fractional_digits, solo el dígito 0 es válido.
, Símbolo separador de grupo específico de la referencia cultural. El separador de grupo de la referencia cultural actual puede aparecer en value si style incluye la NumberStyles.AllowThousands marca .
. Símbolo de separador decimal específico de la referencia cultural. El símbolo decimal de la referencia cultural actual puede aparecer en value si style incluye la NumberStyles.AllowDecimalPoint marca . Solo el dígito 0 puede aparecer como un dígito fraccionario para que la operación de análisis se realice correctamente; si fractional_digits incluye cualquier otro dígito, se produce una FormatException excepción .
E Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El value parámetro puede representar un número en notación exponencial si style incluye la NumberStyles.AllowExponent marca .
hexdigits Secuencia de dígitos hexadecimales de 0 a f, o de 0 a F.

Nota

La operación de análisis omite los caracteres NUL (U+0000) terminados, s independientemente del valor del style argumento.

Una cadena con dígitos solo (que corresponde al NumberStyles.None estilo) siempre analiza correctamente. La mayoría de los miembros restantes NumberStyles controlan los elementos que pueden estar presentes, pero no son necesarios para estar presentes, en la cadena de entrada. En la tabla siguiente se indica cómo afectan los miembros individuales NumberStyles a los elementos que pueden estar presentes en value.

Valor de NumberStyles Elementos permitidos además value de dígitos
None Solo el elemento digits .
AllowDecimalPoint Los elementos decimal point (.) y fractional-digits .
AllowExponent Carácter "e" o "E", que indica la notación exponencial, junto con exponential_digits.
AllowLeadingWhite Elemento ws al principio de value.
AllowTrailingWhite Elemento ws al final de value.
AllowLeadingSign Elemento de signo al principio de value.
AllowTrailingSign Elemento de signo al final de value.
AllowParentheses Elemento de signo en forma de paréntesis que incluye el valor numérico.
AllowThousands Elemento separador de grupo (,).
AllowCurrencySymbol Elemento currency ($).
Currency Todos los elementos. Sin embargo, value no puede representar un número hexadecimal o un número en notación exponencial.
Float El elemento ws al principio o al final de value, firma al principio de valuey el símbolo decimal (.). El value parámetro también puede usar la notación exponencial.
Number Elementos wsseparadores de signgrupo (,) y separadores decimales (.).
Any Todos los elementos. Sin embargo, value no puede representar un número hexadecimal.

Importante

Si usa el Parse método para realizar un recorrido de ida y vuelta la representación de cadena de un BigInteger valor generado por el ToString método , debe usar el BigInteger.ToString(String) método con el especificador de formato "R" para generar la representación de cadena del BigInteger valor. De lo contrario, la representación de cadena de BigInteger conserva solo los 50 dígitos más significativos del valor original y los datos se pueden perder cuando se usa el Parse método para restaurar el BigInteger valor.

A diferencia de los demás NumberStyles valores, que permiten, pero no requieren, la presencia de elementos de estilo concretos en value, el NumberStyles.AllowHexSpecifier valor de estilo significa que los caracteres numéricos individuales de value siempre se interpretan como caracteres hexadecimales. Los caracteres hexadecimales válidos son 0-9, A-F y a-f. Las únicas marcas que se pueden combinar con el style parámetro son NumberStyles.AllowLeadingWhite y NumberStyles.AllowTrailingWhite. (La NumberStyles enumeración incluye un estilo de número compuesto, HexNumber, que incluye ambas marcas de espacio en blanco).

Nota

Si value es la representación de cadena de un número hexadecimal, no puede ir precedida de ninguna decoración (como 0x o &h) que la diferencie como un número hexadecimal. Esto hace que se produzca un error en la conversión.

Si value es una cadena hexadecimal, el Parse(String, NumberStyles) método interpreta value como un número negativo almacenado mediante la representación complementaria de dos si sus dos primeros dígitos hexadecimales son mayores o iguales que 0x80. En otras palabras, el método interpreta el bit de orden más alto del primer byte de value como bit de signo. Para asegurarse de que una cadena hexadecimal se interpreta correctamente como un número positivo, el primer dígito de value debe tener un valor de cero. Por ejemplo, el método interpreta 0x80 como un valor negativo, pero interpreta o 0x0800x0080 como un valor positivo. En el ejemplo siguiente se muestra la diferencia entre las cadenas hexadecimales que representan valores negativos y 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.

El value parámetro se analiza mediante la información de formato de un NumberFormatInfo objeto que se inicializa para la referencia cultural del sistema actual. Para especificar la referencia cultural cuya información de formato se usa para la operación de análisis, llame a la Parse(String, NumberStyles, IFormatProvider) sobrecarga.

Consulte también

Se aplica a

Parse(String, IFormatProvider)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Convierte la representación en forma de cadena de un número con el formato específico de la referencia cultural indicada en su BigInteger equivalente.

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

Cadena que contiene un número que se va a convertir.

provider
IFormatProvider

Un objeto que proporciona información de formato específica de la referencia cultural sobre value.

Devoluciones

BigInteger

Valor equivalente al número especificado en el parámetro value.

Implementaciones

Parse(String, IFormatProvider)

Excepciones

ArgumentNullException

value es null.

FormatException

value no tiene el formato correcto.

Ejemplos

En los ejemplos siguientes se muestran dos maneras de definir la tilde (~) como un signo negativo para los valores de formato BigInteger . Tenga en cuenta que para mostrar los BigInteger valores en el mismo formato que las cadenas originales, el código debe llamar al BigInteger.ToString(IFormatProvider) método y pasarlo al NumberFormatInfo objeto que proporciona información de formato.

En el primer ejemplo se define una clase que implementa IFormatProvider y usa el GetFormat método para devolver el NumberFormatInfo objeto que proporciona información de formato.

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

A continuación, se puede crear una instancia de un BigInteger objeto con el código siguiente:

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)

El segundo ejemplo es más sencillo. Pasa el NumberFormatInfo objeto que proporciona información de formato al 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)

Comentarios

El value parámetro debe ser la representación de cadena de un número de la forma siguiente:

[ws] [sign] digits[ws]

Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.

Elemento Descripción
ws Espacio en blanco opcional.
sign Un signo opcional. Los caracteres de signo válidos se determinan mediante las NumberFormatInfo.NegativeSign propiedades y NumberFormatInfo.PositiveSign del NumberFormatInfo objeto devuelto por el provider método del GetFormat objeto.
dígitos Secuencia de dígitos comprendidos entre 0 y 9. Se omiten los ceros iniciales.

Nota

La cadena especificada por el value parámetro se interpreta mediante el NumberStyles.Integer estilo . No puede contener separadores de grupo ni separadores decimales y no puede tener una parte decimal.

Importante

Si usa el Parse método para realizar un recorrido de ida y vuelta la representación de cadena de un BigInteger valor generado por el ToString método , debe usar el BigInteger.ToString(String) método con el especificador de formato "R" para generar la representación de cadena del BigInteger valor. De lo contrario, la representación de cadena de BigInteger conserva solo los 50 dígitos más significativos del valor original y los datos se pueden perder cuando se usa el Parse método para restaurar el BigInteger valor.

El provider parámetro es una IFormatProvider implementación cuyo GetFormat método devuelve un NumberFormatInfo objeto que proporciona información de formato específica de la referencia cultural. Cuando se invoca el Parse(String, IFormatProvider) método , llama al provider método del GetFormat parámetro y lo pasa un Type objeto que representa el NumberFormatInfo tipo. A GetFormat continuación, el método devuelve el NumberFormatInfo objeto que proporciona información sobre el formato del value parámetro . Hay tres maneras de usar el provider parámetro para proporcionar información de formato personalizada a la operación de análisis:

  • Puede pasar un CultureInfo objeto que representa la referencia cultural que proporciona información de formato. Su GetFormat método devuelve el NumberFormatInfo objeto que proporciona información de formato numérico para esa referencia cultural.

  • Puede pasar el objeto real NumberFormatInfo que proporciona información de formato numérico. (Su implementación de GetFormat solo devuelve a sí mismo).

  • Puede pasar un objeto personalizado que implemente IFormatProvider. Su GetFormat método crea una instancia de y devuelve el NumberFormatInfo objeto que proporciona información de formato.

Si provider es null, el formato de value se interpreta en función del NumberFormatInfo objeto de la referencia cultural actual.

Consulte también

Se aplica a

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Convierte la representación de un número, incluida en el intervalo de solo lectura especificado de caracteres, en un estilo especificado en su equivalente BigInteger.

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>

Intervalo de solo lectura de caracteres que contiene el número que se va a convertir.

style
NumberStyles

Combinación bit a bit de los valores de enumeración que especifican el formato permitido de value.

provider
IFormatProvider

Un objeto que proporciona información de formato específica de la referencia cultural sobre value.

Devoluciones

BigInteger

Valor equivalente al número especificado en el parámetro value.

Implementaciones

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Excepciones

ArgumentException

style no es un valor NumberStyles.

o bien

style incluye la marca AllowHexSpecifier o HexNumber junto con otro valor.

ArgumentNullException

value es null.

FormatException

value no cumple el modelo de entrada especificado por style.

Comentarios

El style parámetro define los elementos de estilo (como el espacio en blanco, el símbolo de signo positivo o negativo, el símbolo separador de grupo o el símbolo de separador decimal) que se permiten en el value parámetro para que la operación de análisis se realice correctamente. styles debe ser una combinación de marcas de bits de la NumberStyles enumeración . El style parámetro hace que esta sobrecarga de método sea útil cuando value contiene la representación de un valor hexadecimal, cuando el sistema numérico (decimal o hexadecimal) representado por value solo se conoce en tiempo de ejecución, o cuando se desea denegar el espacio en blanco o un símbolo de signo en value.

Según el valor de style, el value parámetro puede incluir los siguientes elementos:

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

Si style incluye NumberStyles.AllowHexSpecifier, el value parámetro puede incluir los siguientes elementos:

[ws] hexdigits[ws]

Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.

Elemento Descripción
ws Espacio en blanco opcional. El espacio en blanco puede aparecer al principio de value si incluye la NumberStyles.AllowLeadingWhite marca y puede aparecer al final de value si style incluye la NumberStyles.AllowTrailingWhitestyle marca.
$ Símbolo de moneda específico de la referencia cultural. Su posición en value se define mediante las NumberFormatInfo.CurrencyNegativePattern propiedades y NumberFormatInfo.CurrencyPositivePattern de la referencia cultural indicada por el provider parámetro . El símbolo de moneda de la referencia cultural actual puede aparecer en value si style incluye la NumberStyles.AllowCurrencySymbol marca .
sign Un signo opcional. El signo puede aparecer al principio de value si incluye la NumberStyles.AllowLeadingSign marca y puede aparecer al final de value si style incluye la NumberStyles.AllowTrailingSignstyle marca . Los paréntesis se pueden usar en value para indicar un valor negativo si style incluye la NumberStyles.AllowParentheses marca .
dígitos

fractional_digits

exponential_digits		 Secuencia de dígitos de 0 a 9. Para fractional_digits, solo el dígito 0 es válido.
, Símbolo separador de grupo específico de la referencia cultural. El símbolo separador de grupo de la referencia cultural especificada por provider puede aparecer en value si style incluye la NumberStyles.AllowThousands marca .
. Símbolo de separador decimal específico de la referencia cultural. El símbolo de separador decimal de la referencia cultural designada por provider puede aparecer en value si style incluye la NumberStyles.AllowDecimalPoint marca . Solo el dígito 0 puede aparecer como un dígito fraccionario para que la operación de análisis se realice correctamente; si fractional_digits incluye cualquier otro dígito, se produce una FormatException excepción .
E Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El value parámetro puede representar un número en notación exponencial si style incluye la NumberStyles.AllowExponent marca .
hexdigits Secuencia de dígitos hexadecimales de 0 a f, o de 0 a F.

Nota

La operación de análisis omite los caracteres NUL (U+0000) terminados, s independientemente del valor del style argumento.

Un value con dígitos solo (que corresponde al NumberStyles.None estilo) siempre analiza correctamente. La mayoría de los miembros restantes NumberStyles controlan los elementos que pueden estar presentes, pero no son necesarios para estar presentes, en value. En la tabla siguiente se indica cómo afectan los miembros individuales NumberStyles a los elementos que pueden estar presentes en value.

Valor NumberStyles Elementos permitidos en el valor además de dígitos
None Solo el elemento digits .
AllowDecimalPoint Los elementos decimal point (.) y fractional-digits .
AllowExponent Carácter "e" o "E", que indica la notación exponencial. junto con exponential_digits.
AllowLeadingWhite Elemento ws al principio de value.
AllowTrailingWhite Elemento ws al final de value.
AllowLeadingSign Elemento de signo al principio de value.
AllowTrailingSign Elemento de signo al final de value.
AllowParentheses Elemento de signo en forma de paréntesis que incluye el valor numérico.
AllowThousands Elemento separador de grupo (,).
AllowCurrencySymbol Elemento currency ($).
Currency Todos los elementos. Sin embargo, value no puede representar un número hexadecimal o un número en notación exponencial.
Float El elemento ws al principio o al final de value, firma al principio de valuey el símbolo decimal (.). El value parámetro también puede usar la notación exponencial.
Number Elementos wsseparadores de signgrupo (,) y separadores decimales (.).
Any Todos los elementos. Sin embargo, value no puede representar un número hexadecimal.

A diferencia de los demás NumberStyles valores, que permiten pero no requieren la presencia de elementos de estilo concretos en value, el NumberStyles.AllowHexSpecifier valor de estilo significa que los caracteres numéricos individuales de value siempre se interpretan como caracteres hexadecimales. Los caracteres hexadecimales válidos son 0-9, A-F y a-f. Las únicas marcas que se pueden combinar con el style parámetro son NumberStyles.AllowLeadingWhite y NumberStyles.AllowTrailingWhite. (La NumberStyles enumeración incluye un estilo de número compuesto, HexNumber, que incluye ambas marcas de espacio en blanco).

El provider parámetro es una IFormatProvider implementación. Su GetFormat método devuelve un NumberFormatInfo objeto que proporciona información específica de la referencia cultural sobre el formato de value. Normalmente, provider puede ser cualquiera de los siguientes:

  • Objeto CultureInfo que representa la referencia cultural que proporciona información de formato numérico. Su GetFormat método devuelve el NumberFormatInfo objeto que proporciona información de formato numérico.

  • Objeto NumberFormatInfo que proporciona información de formato. (Su implementación de GetFormat solo devuelve a sí mismo).

  • Objeto personalizado que implementa IFormatProvider y usa el GetFormat método para crear instancias y devolver el NumberFormatInfo objeto que proporciona información de formato.

Si provider es null, se usa el NumberFormatInfo objeto de la referencia cultural actual.

Consulte también

Se aplica a

Parse(String, NumberStyles, IFormatProvider)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Convierte la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en su equivalente de BigInteger.

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

Cadena que contiene un número que se va a convertir.

style
NumberStyles

Combinación bit a bit de los valores de enumeración que especifican el formato permitido de value.

provider
IFormatProvider

Un objeto que proporciona información de formato específica de la referencia cultural sobre value.

Devoluciones

BigInteger

Valor equivalente al número especificado en el parámetro value.

Implementaciones

Parse(String, NumberStyles, IFormatProvider)

Excepciones

ArgumentException

style no es un valor NumberStyles.

o bien

style incluye la marca AllowHexSpecifier o HexNumber junto con otro valor.

ArgumentNullException

value es null.

FormatException

value no cumple el modelo de entrada especificado por style.

Ejemplos

En el ejemplo siguiente se realiza varias llamadas al Parse(String, NumberStyles, IFormatProvider) método mediante varias combinaciones de valores para los style parámetros y 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.

Una serie de llamadas individuales al Parse(String, NumberStyles, IFormatProvider) método pasan una instancia de la siguiente BigIntegerFormatProvider clase, que define una tilde (~) como signo 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

Comentarios

El style parámetro define los elementos de estilo (como el espacio en blanco, el símbolo de signo positivo o negativo, el símbolo separador de grupo o el símbolo de separador decimal) que se permiten en el value parámetro para que la operación de análisis se realice correctamente. styles debe ser una combinación de marcas de bits de la NumberStyles enumeración . El style parámetro hace que esta sobrecarga de método sea útil cuando value contiene la representación de cadena de un valor hexadecimal, cuando el sistema numérico (decimal o hexadecimal) representado por value solo se conoce en tiempo de ejecución, o cuando se desea denegar el espacio en blanco o un símbolo de signo en value.

Según el valor de style, el value parámetro puede incluir los siguientes elementos:

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

Si style incluye NumberStyles.AllowHexSpecifier, el value parámetro puede incluir los siguientes elementos:

[ws] hexdigits[ws]

Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.

Elemento Descripción
ws Espacio en blanco opcional. El espacio en blanco puede aparecer al principio de value si incluye la NumberStyles.AllowLeadingWhite marca y puede aparecer al final de value si style incluye la NumberStyles.AllowTrailingWhitestyle marca.
$ Símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las NumberFormatInfo.CurrencyNegativePattern propiedades y NumberFormatInfo.CurrencyPositivePattern de la referencia cultural indicada por el provider parámetro . El símbolo de moneda de la referencia cultural actual puede aparecer en value si style incluye la NumberStyles.AllowCurrencySymbol marca .
sign Un signo opcional. El signo puede aparecer al principio de value si incluye la NumberStyles.AllowLeadingSign marca y puede aparecer al final de value si style incluye la NumberStyles.AllowTrailingSignstyle marca . Los paréntesis se pueden usar en value para indicar un valor negativo si style incluye la NumberStyles.AllowParentheses marca .
dígitos

fractional_digits

exponential_digits		 Secuencia de dígitos de 0 a 9. Para fractional_digits, solo el dígito 0 es válido.
, Símbolo separador de grupo específico de la referencia cultural. El símbolo separador de grupo de la referencia cultural especificada por provider puede aparecer en value si style incluye la NumberStyles.AllowThousands marca .
. Símbolo de separador decimal específico de la referencia cultural. El símbolo decimal de la referencia cultural designada por provider puede aparecer en value si style incluye la NumberStyles.AllowDecimalPoint marca . Solo el dígito 0 puede aparecer como un dígito fraccionario para que la operación de análisis se realice correctamente; si fractional_digits incluye cualquier otro dígito, se produce una FormatException excepción .
E El carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El value parámetro puede representar un número en notación exponencial si style incluye la NumberStyles.AllowExponent marca .
hexdigits Secuencia de dígitos hexadecimales de 0 a f, o 0 a F.

Nota

La operación de análisis omite todos los caracteres NUL (U+0000) de s , independientemente del valor del style argumento.

Una cadena solo con dígitos (que corresponde al NumberStyles.None estilo) siempre analiza correctamente. La mayoría de los miembros restantes NumberStyles controlan los elementos que pueden estar presentes, pero no son necesarios para estar presentes, en la cadena de entrada. En la tabla siguiente se indica cómo afectan los miembros individuales NumberStyles a los elementos que pueden estar presentes en value.

Valor NumberStyles Elementos permitidos en el valor además de dígitos
None Solo el elemento digits .
AllowDecimalPoint Elementos decimales (.) y fracciones de dígitos .
AllowExponent El carácter "e" o "E", que indica la notación exponencial. junto con exponential_digits.
AllowLeadingWhite Elemento ws al principio de value.
AllowTrailingWhite Elemento ws al final de value.
AllowLeadingSign Elemento sign al principio de value.
AllowTrailingSign Elemento sign al final de value.
AllowParentheses Elemento de signo en forma de paréntesis que incluye el valor numérico.
AllowThousands Elemento separador de grupo (,).
AllowCurrencySymbol Elemento currency ($).
Currency Todos los elementos. Sin embargo, value no puede representar un número hexadecimal o un número en notación exponencial.
Float El elemento ws al principio o al final de value, firma al principio de valuey el símbolo de separador decimal (.). El value parámetro también puede usar la notación exponencial.
Number Elementos wsseparadores signde grupo (,) y separador decimal (.).
Any Todos los elementos. Sin embargo, value no puede representar un número hexadecimal.

Importante

Si usa el Parse método para realizar un recorrido de ida y vuelta, la representación de cadena de un BigInteger valor generado por el ToString método , debe usar el BigInteger.ToString(String) método con el especificador de formato "R" para generar la representación de cadena del BigInteger valor. De lo contrario, la representación de cadena de BigInteger conserva solo los 50 dígitos más significativos del valor original y los datos se pueden perder cuando se usa el Parse método para restaurar el BigInteger valor.

A diferencia de los demás NumberStyles valores, que permiten pero no requieren la presencia de elementos de estilo concretos en value, el valor de NumberStyles.AllowHexSpecifier estilo significa que los caracteres numéricos individuales de value siempre se interpretan como caracteres hexadecimales. Los caracteres hexadecimales válidos son 0-9, A-F y a-f. Las únicas marcas que se pueden combinar con el style parámetro son NumberStyles.AllowLeadingWhite y NumberStyles.AllowTrailingWhite. (La NumberStyles enumeración incluye un estilo de número compuesto, HexNumber, que incluye ambas marcas de espacio en blanco).

Nota

Si value es la representación de cadena de un número hexadecimal, no puede ir precedida de ninguna decoración (como 0x o &h) que la diferencie como un número hexadecimal. Esto hace que se produzca un error en la conversión.

Si value es una cadena hexadecimal, el Parse(String, NumberStyles) método interpreta value como un número negativo almacenado mediante la representación complementaria de dos si sus dos primeros dígitos hexadecimales son mayores o iguales que 0x80. En otras palabras, el método interpreta el bit de orden más alto del primer byte de value como bit de signo. Para asegurarse de que una cadena hexadecimal se interpreta correctamente como un número positivo, el primer dígito value de debe tener un valor de cero. Por ejemplo, el método interpreta 0x80 como un valor negativo, pero interpreta 0x080 o 0x0080 como un valor positivo. En el ejemplo siguiente se muestra la diferencia entre las cadenas hexadecimales que representan valores negativos y 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.

El provider parámetro es una IFormatProvider implementación. Su GetFormat método devuelve un NumberFormatInfo objeto que proporciona información específica de la referencia cultural sobre el formato de value. Normalmente, provider puede ser cualquiera de los siguientes:

  • Objeto CultureInfo que representa la referencia cultural que proporciona información de formato numérico. Su GetFormat método devuelve el NumberFormatInfo objeto que proporciona información de formato numérico.

  • Objeto NumberFormatInfo que proporciona información de formato. (Su implementación de GetFormat simplemente devuelve a sí mismo).

  • Objeto personalizado que implementa IFormatProvider y usa el GetFormat método para crear instancias y devolver el NumberFormatInfo objeto que proporciona información de formato.

Si provider es null, se usa el NumberFormatInfo objeto de la referencia cultural actual.

Consulte también

Se aplica a