Condividi tramite

BigInteger.Parse Metodo

Definizione

Spazio dei nomi:
System.Numerics
Assembly:
System.Numerics.dll, System.Runtime.Numerics.dll
Assembly:
netstandard.dll, System.Runtime.Numerics.dll
Assembly:
System.Runtime.Numerics.dll
Assembly:
System.Numerics.dll
Assembly:
netstandard.dll

Converte la rappresentazione di stringa di un numero nell'equivalente BigInteger .

Overload

Nome Descrizione
Parse(String, NumberStyles, IFormatProvider)

Converte la rappresentazione di stringa di un numero in uno stile e un formato specifico delle impostazioni cultura specificati nell'equivalente BigInteger .
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converte la rappresentazione di un numero, contenuta nell'intervallo di caratteri di sola lettura specificato, in uno stile specificato nell'equivalente BigInteger .
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
Parse(String, IFormatProvider)

Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura specificato nell'equivalente BigInteger .
Parse(ReadOnlySpan<Byte>, IFormatProvider)
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analizza un intervallo di caratteri in un valore.
Parse(String, NumberStyles)

Converte la rappresentazione di stringa di un numero in uno stile specificato nell'equivalente BigInteger .
Parse(String)

Converte la rappresentazione di stringa di un numero nell'equivalente BigInteger .

Parse(String, NumberStyles, IFormatProvider)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte la rappresentazione di stringa di un numero in uno stile e un formato specifico delle impostazioni cultura specificati nell'equivalente 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

Parametri

value
String

Stringa contenente un numero da convertire.

style
NumberStyles

Combinazione bit per bit dei valori di enumerazione che specificano il formato consentito di value.

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su value.

Restituisce

BigInteger

Valore equivalente al numero specificato nel value parametro .

Implementazioni

Parse(String, NumberStyles, IFormatProvider)

Eccezioni

ArgumentException

style non è un NumberStyles valore.

oppure

style include il AllowHexSpecifier flag o HexNumber insieme a un altro valore.

ArgumentNullException

value è null.

FormatException

value non è conforme al modello di input specificato da style.

Esempio

Nell'esempio seguente vengono effettuate diverse chiamate al Parse(String, NumberStyles, IFormatProvider) metodo usando varie combinazioni di valori per i style parametri 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.

Un numero di singole chiamate al Parse(String, NumberStyles, IFormatProvider) metodo passa un'istanza della classe seguente BigIntegerFormatProvider , che definisce una tilde (~) come segno 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

Commenti

Il style parametro definisce gli elementi di stile(ad esempio spazi vuoti, simbolo di segno positivo o negativo, simbolo separatore di gruppo o simbolo di virgola decimale) consentiti nel value parametro per l'esito positivo dell'operazione di analisi. styles deve essere una combinazione di flag di bit dell'enumerazione NumberStyles . Il style parametro rende utile questo overload del metodo quando value contiene la rappresentazione di stringa di un valore esadecimale, quando il sistema numerico (decimale o esadecimale) rappresentato da value è noto solo in fase di esecuzione o quando si desidera impedire lo spazio vuoto o un simbolo di segno in value.

A seconda del valore di style, il value parametro può includere gli elementi seguenti:

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

Se style include NumberStyles.AllowHexSpecifier, il value parametro può includere gli elementi seguenti:

[ws]hexdigits[ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive i singoli elementi.

Elemento Descrzione
Ws Spazio vuoto facoltativo. Lo spazio vuoto può essere visualizzato all'inizio di value se include il NumberStyles.AllowLeadingWhite flag e può essere visualizzato alla fine di value se style include il NumberStyles.AllowTrailingWhite flag.style
$ Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalle NumberFormatInfo.CurrencyNegativePattern proprietà e NumberFormatInfo.CurrencyPositivePattern delle impostazioni cultura indicate dal provider parametro . Il simbolo di valuta delle impostazioni cultura corrente può essere visualizzato in value se style include il NumberStyles.AllowCurrencySymbol flag .
sign Segno facoltativo. Il segno può essere visualizzato all'inizio di value se include il NumberStyles.AllowLeadingSign flag e può essere visualizzato alla fine di value se style include il NumberStyles.AllowTrailingSignstyle flag. Le parentesi possono essere usate in value per indicare un valore negativo se style include il NumberStyles.AllowParentheses flag .
Cifre

Cifre_frazionarie

exponential_digits		 Sequenza di cifre da 0 a 9. Per fractional_digits, è valida solo la cifra 0.
, Simbolo separatore di gruppi specifico delle impostazioni cultura. Il simbolo separatore di gruppo delle impostazioni cultura specificate da provider può essere visualizzato in value se style include il NumberStyles.AllowThousands flag .
. Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo di virgola decimale delle impostazioni cultura designate da provider può essere visualizzato in value se style include il NumberStyles.AllowDecimalPoint flag . Solo la cifra 0 può essere visualizzata come cifra frazionaria per l'esito positivo dell'operazione di analisi; se fractional_digits include qualsiasi altra cifra, viene generata un'eccezione FormatException .
E Carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il value parametro può rappresentare un numero in notazione esponenziale se style include il NumberStyles.AllowExponent flag .
hexdigits Sequenza di cifre esadecimali da 0 a f o da 0 a F.

Annotazioni

Qualsiasi carattere di terminazione NUL (U+0000) in s viene ignorato dall'operazione di analisi, indipendentemente dal valore dell'argomento style .

Una stringa con solo cifre (che corrisponde allo NumberStyles.None stile) analizza sempre correttamente. La maggior parte degli elementi di controllo membri rimanenti NumberStyles che possono essere presenti, ma non devono essere presenti, nella stringa di input. La tabella seguente indica in che modo i singoli NumberStyles membri influiscono sugli elementi che possono essere presenti in value.

Valore NumberStyles Elementi consentiti in valore oltre alle cifre
None Solo l'elemento digits .
AllowDecimalPoint Elementi decimali (.) e frazionari .
AllowExponent Carattere "e" o "E", che indica la notazione esponenziale. insieme a exponential_digits.
AllowLeadingWhite Elemento ws all'inizio di value.
AllowTrailingWhite Elemento ws alla fine di value.
AllowLeadingSign Elemento del segno all'inizio di value.
AllowTrailingSign Elemento del segno alla fine di value.
AllowParentheses Elemento di segno sotto forma di parentesi che racchiudono il valore numerico.
AllowThousands Elemento separatore di gruppo (,).
AllowCurrencySymbol Elemento currency ($).
Currency Tutti gli elementi. Tuttavia, value non può rappresentare un numero esadecimale o un numero in notazione esponenziale.
Float L'elemento ws all'inizio o alla fine di value, firma all'inizio di valuee il simbolo decimale (.). Il value parametro può anche usare la notazione esponenziale.
Number Elementi ws, , signseparatore di gruppo (,) e separatore decimale (.).
Any Tutti gli elementi. Tuttavia, value non può rappresentare un numero esadecimale.

Importante

Se si usa il Parse metodo per eseguire il round trip della rappresentazione di stringa di un BigInteger valore restituito dal ToString metodo , è necessario utilizzare il BigInteger.ToString(String) metodo con l'identificatore di formato "R" per generare la rappresentazione di stringa del BigInteger valore. In caso contrario, la rappresentazione di stringa di BigInteger mantiene solo le 50 cifre più significative del valore originale e i dati possono andare persi quando si usa il Parse metodo per ripristinare il BigInteger valore.

A differenza degli altri NumberStyles valori, che consentono ma non richiedono la presenza di particolari elementi di stile in value, il NumberStyles.AllowHexSpecifier valore dello stile indica che i singoli caratteri numerici in value vengono sempre interpretati come caratteri esadecimali. I caratteri esadecimali validi sono 0-9, A-F e a-f. Gli unici flag che possono essere combinati con il style parametro sono NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. L'enumerazione NumberStyles include uno stile numerico composito, HexNumber, che include entrambi i flag di spazio vuoto.

Annotazioni

Se value è la rappresentazione di stringa di un numero esadecimale, non può essere preceduta da alcuna decorazione (ad esempio 0x o &h) che la differenzia come numero esadecimale. In questo modo la conversione non riesce.

Se value è una stringa esadecimale, il Parse(String, NumberStyles) metodo interpreta value come numero negativo archiviato usando la rappresentazione di complemento di due se le prime due cifre esadecimali sono maggiori o uguali a 0x80. In altre parole, il metodo interpreta il bit di ordine più alto del primo byte in value come bit del segno. Per assicurarsi che una stringa esadecimale venga interpretata correttamente come numero positivo, la prima cifra in value deve avere un valore pari a zero. Ad esempio, il metodo interpreta 0x80 come valore negativo, ma interpreta 0x080 o 0x0080 come valore positivo. Nell'esempio seguente viene illustrata la differenza tra stringhe esadecimali che rappresentano valori negativi e positivi.

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.

Il provider parametro è un'implementazione IFormatProvider . Il GetFormat metodo restituisce un NumberFormatInfo oggetto che fornisce informazioni specifiche delle impostazioni cultura sul formato di value. In genere, provider può essere uno dei seguenti:

  • Oggetto CultureInfo che rappresenta le impostazioni cultura che fornisce informazioni sulla formattazione numerica. Il GetFormat metodo restituisce l'oggetto NumberFormatInfo che fornisce informazioni sulla formattazione numerica.

  • Oggetto NumberFormatInfo che fornisce informazioni di formattazione. La sua implementazione di GetFormat restituisce solo se stessa.

  • Oggetto personalizzato che implementa IFormatProvider e utilizza il GetFormat metodo per creare un'istanza e restituire l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene utilizzato l'oggetto NumberFormatInfo per le impostazioni cultura correnti.

Vedi anche

Si applica a

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte la rappresentazione di un numero, contenuta nell'intervallo di caratteri di sola lettura specificato, in uno stile specificato nell'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

Parametri

value
ReadOnlySpan<Char>

Intervallo di sola lettura di caratteri che contiene il numero da convertire.

style
NumberStyles

Combinazione bit per bit dei valori di enumerazione che specificano il formato consentito di value.

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su value.

Restituisce

BigInteger

Valore equivalente al numero specificato nel value parametro .

Implementazioni

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Eccezioni

ArgumentException

style non è un NumberStyles valore.

oppure

style include il AllowHexSpecifier flag o HexNumber insieme a un altro valore.

ArgumentNullException

value è null.

FormatException

value non è conforme al modello di input specificato da style.

Commenti

Il style parametro definisce gli elementi di stile(ad esempio spazi vuoti, simbolo di segno positivo o negativo, simbolo separatore di gruppo o simbolo di virgola decimale) consentiti nel value parametro per l'esito positivo dell'operazione di analisi. styles deve essere una combinazione di flag di bit dell'enumerazione NumberStyles . Il style parametro rende utile questo overload del metodo quando value contiene la rappresentazione di un valore esadecimale, quando il sistema numerico (decimale o esadecimale) rappresentato da value è noto solo in fase di esecuzione o quando si desidera impedire spazi vuoti o un simbolo di segno in value.

A seconda del valore di style, il value parametro può includere gli elementi seguenti:

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

Se style include NumberStyles.AllowHexSpecifier, il value parametro può includere gli elementi seguenti:

[ws]hexdigits[ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive i singoli elementi.

Elemento Descrzione
Ws Spazio vuoto facoltativo. Lo spazio vuoto può essere visualizzato all'inizio di value se include il NumberStyles.AllowLeadingWhite flag e può essere visualizzato alla fine di value se style include il NumberStyles.AllowTrailingWhite flag.style
$ Simbolo di valuta specifico delle impostazioni cultura. La posizione in value è definita dalle NumberFormatInfo.CurrencyNegativePattern proprietà e NumberFormatInfo.CurrencyPositivePattern delle impostazioni cultura indicate dal provider parametro . Il simbolo di valuta delle impostazioni cultura corrente può essere visualizzato in value se style include il NumberStyles.AllowCurrencySymbol flag .
sign Segno facoltativo. Il segno può essere visualizzato all'inizio di value se include il NumberStyles.AllowLeadingSign flag e può essere visualizzato alla fine di value se style include il NumberStyles.AllowTrailingSignstyle flag. Le parentesi possono essere usate in value per indicare un valore negativo se style include il NumberStyles.AllowParentheses flag .
Cifre

Cifre_frazionarie

exponential_digits		 Sequenza di cifre da 0 a 9. Per fractional_digits, è valida solo la cifra 0.
, Simbolo separatore di gruppi specifico delle impostazioni cultura. Il simbolo separatore di gruppo delle impostazioni cultura specificate da provider può essere visualizzato in value se style include il NumberStyles.AllowThousands flag .
. Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo di virgola decimale delle impostazioni cultura designate da provider può essere visualizzato in value se style include il NumberStyles.AllowDecimalPoint flag . Solo la cifra 0 può essere visualizzata come cifra frazionaria per l'esito positivo dell'operazione di analisi; se fractional_digits include qualsiasi altra cifra, viene generata un'eccezione FormatException .
E Carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il value parametro può rappresentare un numero in notazione esponenziale se style include il NumberStyles.AllowExponent flag .
hexdigits Sequenza di cifre esadecimali da 0 a f o da 0 a F.

Annotazioni

Qualsiasi carattere di terminazione NUL (U+0000) in s viene ignorato dall'operazione di analisi, indipendentemente dal valore dell'argomento style .

Un value oggetto con solo cifre (che corrisponde allo NumberStyles.None stile) analizza sempre correttamente. La maggior parte degli elementi di controllo membri rimanenti NumberStyles che possono essere presenti, ma non devono essere presenti, in value. La tabella seguente indica in che modo i singoli NumberStyles membri influiscono sugli elementi che possono essere presenti in value.

Valore NumberStyles Elementi consentiti in valore oltre alle cifre
None Solo l'elemento digits .
AllowDecimalPoint Elementi decimali (.) e frazionari .
AllowExponent Carattere "e" o "E", che indica la notazione esponenziale. insieme a exponential_digits.
AllowLeadingWhite Elemento ws all'inizio di value.
AllowTrailingWhite Elemento ws alla fine di value.
AllowLeadingSign Elemento del segno all'inizio di value.
AllowTrailingSign Elemento del segno alla fine di value.
AllowParentheses Elemento di segno sotto forma di parentesi che racchiudono il valore numerico.
AllowThousands Elemento separatore di gruppo (,).
AllowCurrencySymbol Elemento currency ($).
Currency Tutti gli elementi. Tuttavia, value non può rappresentare un numero esadecimale o un numero in notazione esponenziale.
Float L'elemento ws all'inizio o alla fine di value, firma all'inizio di valuee il simbolo decimale (.). Il value parametro può anche usare la notazione esponenziale.
Number Elementi ws, , signseparatore di gruppo (,) e separatore decimale (.).
Any Tutti gli elementi. Tuttavia, value non può rappresentare un numero esadecimale.

A differenza degli altri NumberStyles valori, che consentono ma non richiedono la presenza di particolari elementi di stile in value, il NumberStyles.AllowHexSpecifier valore dello stile indica che i singoli caratteri numerici in value vengono sempre interpretati come caratteri esadecimali. I caratteri esadecimali validi sono 0-9, A-F e a-f. Gli unici flag che possono essere combinati con il style parametro sono NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. L'enumerazione NumberStyles include uno stile numerico composito, HexNumber, che include entrambi i flag di spazio vuoto.

Il provider parametro è un'implementazione IFormatProvider . Il GetFormat metodo restituisce un NumberFormatInfo oggetto che fornisce informazioni specifiche delle impostazioni cultura sul formato di value. In genere, provider può essere uno dei seguenti:

  • Oggetto CultureInfo che rappresenta le impostazioni cultura che fornisce informazioni sulla formattazione numerica. Il GetFormat metodo restituisce l'oggetto NumberFormatInfo che fornisce informazioni sulla formattazione numerica.

  • Oggetto NumberFormatInfo che fornisce informazioni di formattazione. La sua implementazione di GetFormat restituisce solo se stessa.

  • Oggetto personalizzato che implementa IFormatProvider e utilizza il GetFormat metodo per creare un'istanza e restituire l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene utilizzato l'oggetto NumberFormatInfo per le impostazioni cultura correnti.

Vedi anche

Si applica a

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) 

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

Parametri

utf8Text
ReadOnlySpan<Byte>
style
NumberStyles
provider
IFormatProvider

Restituisce

BigInteger

Implementazioni

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Si applica a

Parse(String, IFormatProvider)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura specificato nell'equivalente BigInteger .

public:
 static System::Numerics::BigInteger Parse(System::String ^ value, IFormatProvider ^ provider);
public:
 static System::Numerics::BigInteger Parse(System::String ^ value, IFormatProvider ^ provider) = IParsable<System::Numerics::BigInteger>::Parse;
public static System.Numerics.BigInteger Parse(string value, IFormatProvider provider);
public static System.Numerics.BigInteger Parse(string value, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> System.Numerics.BigInteger
Public Shared Function Parse (value As String, provider As IFormatProvider) As BigInteger

Parametri

value
String

Stringa contenente un numero da convertire.

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su value.

Restituisce

BigInteger

Valore equivalente al numero specificato nel value parametro .

Implementazioni

Parse(String, IFormatProvider)

Eccezioni

ArgumentNullException

value è null.

FormatException

value non è nel formato corretto.

Esempio

Negli esempi seguenti vengono illustrati due modi per definire la tilde (~) come segno negativo per la formattazione dei BigInteger valori. Si noti che per visualizzare i BigInteger valori nello stesso formato delle stringhe originali, il codice deve chiamare il BigInteger.ToString(IFormatProvider) metodo e passarlo all'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Il primo esempio definisce una classe che implementa IFormatProvider e usa il GetFormat metodo per restituire l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

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

È quindi possibile creare un'istanza di un BigInteger oggetto con il codice seguente:

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)

Il secondo esempio è più semplice. Passa l'oggetto NumberFormatInfo che fornisce informazioni di formattazione al provider parametro .

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)

Commenti

Il value parametro deve essere la rappresentazione di stringa di un numero nel formato seguente:

[ws][sign]digits[ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive i singoli elementi.

Elemento Descrzione
Ws Spazio vuoto facoltativo.
sign Segno facoltativo. I caratteri di segno validi sono determinati dalle NumberFormatInfo.NegativeSign proprietà e NumberFormatInfo.PositiveSign dell'oggetto NumberFormatInfo restituito dal provider metodo dell'oggetto GetFormat .
Cifre Sequenza di cifre compresa tra 0 e 9. Tutti gli zeri iniziali vengono ignorati.

Annotazioni

La stringa specificata dal value parametro viene interpretata usando lo NumberStyles.Integer stile . Non può contenere separatori di gruppo o separatori decimali e non può avere una parte decimale.

Importante

Se si usa il Parse metodo per eseguire il round trip della rappresentazione di stringa di un BigInteger valore restituito dal ToString metodo , è necessario utilizzare il BigInteger.ToString(String) metodo con l'identificatore di formato "R" per generare la rappresentazione di stringa del BigInteger valore. In caso contrario, la rappresentazione di stringa di BigInteger mantiene solo le 50 cifre più significative del valore originale e i dati possono andare persi quando si usa il Parse metodo per ripristinare il BigInteger valore.

Il parametro è un'implementazione IFormatProvider il provider cui GetFormat metodo restituisce un NumberFormatInfo oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura. Quando il Parse(String, IFormatProvider) metodo viene richiamato, chiama il provider metodo del GetFormat parametro e lo passa a un Type oggetto che rappresenta il NumberFormatInfo tipo. Il GetFormat metodo restituisce quindi l'oggetto NumberFormatInfo che fornisce informazioni sul formato del value parametro. Esistono tre modi per usare il provider parametro per fornire informazioni di formattazione personalizzate all'operazione di analisi:

  • È possibile passare un CultureInfo oggetto che rappresenta le impostazioni cultura che forniscono informazioni di formattazione. Il GetFormat metodo restituisce l'oggetto NumberFormatInfo che fornisce informazioni sulla formattazione numerica per tali impostazioni cultura.

  • È possibile passare l'oggetto effettivo NumberFormatInfo che fornisce informazioni sulla formattazione numerica. La sua implementazione di GetFormat restituisce solo se stessa.

  • È possibile passare un oggetto personalizzato che implementa IFormatProvider. Il GetFormat metodo crea un'istanza e restituisce l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null, la formattazione di value viene interpretata in base all'oggetto NumberFormatInfo delle impostazioni cultura correnti.

Vedi anche

Si applica a

Parse(ReadOnlySpan<Byte>, IFormatProvider) 

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

Parametri

utf8Text
ReadOnlySpan<Byte>
provider
IFormatProvider

Restituisce

BigInteger

Implementazioni

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Si applica a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Analizza un intervallo di caratteri in un valore.

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

Parametri

s
ReadOnlySpan<Char>

Intervallo di caratteri da analizzare.

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s.

Restituisce

BigInteger

Risultato dell'analisi sdi .

Implementazioni

Parse(ReadOnlySpan<Char>, IFormatProvider)

Si applica a

Parse(String, NumberStyles)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte la rappresentazione di stringa di un numero in uno stile specificato nell'equivalente BigInteger .

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

Parametri

value
String

Stringa contenente un numero da convertire.

style
NumberStyles

Combinazione bit per bit dei valori di enumerazione che specificano il formato consentito di value.

Restituisce

BigInteger

Valore equivalente al numero specificato nel value parametro .

Eccezioni

ArgumentException

style non è un NumberStyles valore.

oppure

style include il AllowHexSpecifier flag o HexNumber insieme a un altro valore.

ArgumentNullException

value è null.

FormatException

value non è conforme al modello di input specificato da NumberStyles.

Esempio

Nell'esempio seguente vengono illustrate le chiamate al Parse(String, NumberStyles) metodo con diversi valori possibili per il style parametro . Illustra come interpretare una stringa come valore esadecimale e come impedire spazi e simboli di firma.

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.

Commenti

Il style parametro definisce gli elementi di stile(ad esempio spazi vuoti, simbolo di segno positivo o negativo, simbolo separatore di gruppo o simbolo di virgola decimale) consentiti nel value parametro per l'esito positivo dell'operazione di analisi. styles deve essere una combinazione di flag di bit dell'enumerazione NumberStyles . Il style parametro rende utile questo overload del metodo quando value contiene la rappresentazione di stringa di un valore esadecimale, quando il sistema numerico (decimale o esadecimale) rappresentato da value è noto solo in fase di esecuzione o quando si desidera impedire lo spazio vuoto o un simbolo di segno in value.

A seconda del valore di style, il value parametro può includere gli elementi seguenti:

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

Se style include NumberStyles.AllowHexSpecifier, il value parametro può contenere gli elementi seguenti:

[ws]hexdigits[ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive i singoli elementi.

Elemento Descrzione
Ws Spazio vuoto facoltativo. Lo spazio vuoto può essere visualizzato all'inizio di value se include il NumberStyles.AllowLeadingWhite flag e può essere visualizzato alla fine di value se style include il NumberStyles.AllowTrailingWhite flag.style
$ Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalle NumberFormatInfo.CurrencyNegativePattern proprietà e NumberFormatInfo.CurrencyPositivePattern delle impostazioni cultura correnti. Il simbolo di valuta delle impostazioni cultura corrente può essere visualizzato in value se style include il NumberStyles.AllowCurrencySymbol flag .
sign Segno facoltativo. Il segno può essere visualizzato all'inizio di value se include il NumberStyles.AllowLeadingSign flag e può essere visualizzato alla fine di value se style include il NumberStyles.AllowTrailingSignstyle flag. Le parentesi possono essere usate in value per indicare un valore negativo se style include il NumberStyles.AllowParentheses flag .
Cifre

Cifre_frazionarie

exponential_digits		 Sequenza di cifre da 0 a 9. Per fractional_digits, è valida solo la cifra 0.
, Simbolo separatore di gruppi specifico delle impostazioni cultura. Il separatore di gruppo delle impostazioni cultura corrente può essere visualizzato in value se style include il NumberStyles.AllowThousands flag .
. Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo del separatore decimale delle impostazioni cultura corrente può essere visualizzato in value se style include il NumberStyles.AllowDecimalPoint flag . Solo la cifra 0 può essere visualizzata come cifra frazionaria per l'esito positivo dell'operazione di analisi; se fractional_digits include qualsiasi altra cifra, viene generata un'eccezione FormatException .
E Carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il value parametro può rappresentare un numero in notazione esponenziale se style include il NumberStyles.AllowExponent flag .
hexdigits Sequenza di cifre esadecimali da 0 a f o da 0 a F.

Annotazioni

Qualsiasi carattere di terminazione NUL (U+0000) in s viene ignorato dall'operazione di analisi, indipendentemente dal valore dell'argomento style .

Una stringa con solo cifre (che corrisponde allo NumberStyles.None stile) analizza sempre correttamente. La maggior parte degli elementi di controllo membri rimanenti NumberStyles che possono essere presenti, ma non devono essere presenti, nella stringa di input. La tabella seguente indica in che modo i singoli NumberStyles membri influiscono sugli elementi che possono essere presenti in value.

Valore della proprietà NumberStyles Elementi consentiti oltre value alle cifre
None Solo l'elemento digits .
AllowDecimalPoint Elementi decimali (.) e frazionari .
AllowExponent Carattere "e" o "E", che indica la notazione esponenziale, insieme a exponential_digits.
AllowLeadingWhite Elemento ws all'inizio di value.
AllowTrailingWhite Elemento ws alla fine di value.
AllowLeadingSign Elemento del segno all'inizio di value.
AllowTrailingSign Elemento del segno alla fine di value.
AllowParentheses Elemento di segno sotto forma di parentesi che racchiudono il valore numerico.
AllowThousands Elemento separatore di gruppo (,).
AllowCurrencySymbol Elemento currency ($).
Currency Tutti gli elementi. Tuttavia, value non può rappresentare un numero esadecimale o un numero in notazione esponenziale.
Float L'elemento ws all'inizio o alla fine di value, firma all'inizio di valuee il simbolo decimale (.). Il value parametro può anche usare la notazione esponenziale.
Number Elementi ws, , signseparatore di gruppo (,) e separatore decimale (.).
Any Tutti gli elementi. Tuttavia, value non può rappresentare un numero esadecimale.

Importante

Se si usa il Parse metodo per eseguire il round trip della rappresentazione di stringa di un BigInteger valore restituito dal ToString metodo , è necessario utilizzare il BigInteger.ToString(String) metodo con l'identificatore di formato "R" per generare la rappresentazione di stringa del BigInteger valore. In caso contrario, la rappresentazione di stringa di BigInteger mantiene solo le 50 cifre più significative del valore originale e i dati possono andare persi quando si usa il Parse metodo per ripristinare il BigInteger valore.

A differenza degli altri NumberStyles valori, che consentono, ma non richiedono, la presenza di particolari elementi di stile in value, il NumberStyles.AllowHexSpecifier valore dello stile significa che i singoli caratteri numerici in value vengono sempre interpretati come caratteri esadecimali. I caratteri esadecimali validi sono 0-9, A-F e a-f. Gli unici flag che possono essere combinati con il style parametro sono NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. L'enumerazione NumberStyles include uno stile numerico composito, HexNumber, che include entrambi i flag di spazio vuoto.

Annotazioni

Se value è la rappresentazione di stringa di un numero esadecimale, non può essere preceduta da alcuna decorazione (ad esempio 0x o &h) che la differenzia come numero esadecimale. In questo modo la conversione non riesce.

Se value è una stringa esadecimale, il Parse(String, NumberStyles) metodo interpreta value come numero negativo archiviato usando la rappresentazione di complemento di due se le prime due cifre esadecimali sono maggiori o uguali a 0x80. In altre parole, il metodo interpreta il bit di ordine più alto del primo byte in value come bit del segno. Per assicurarsi che una stringa esadecimale venga interpretata correttamente come numero positivo, la prima cifra in value deve avere un valore pari a zero. Ad esempio, il metodo interpreta 0x80 come valore negativo, ma interpreta 0x080 o 0x0080 come valore positivo. Nell'esempio seguente viene illustrata la differenza tra stringhe esadecimali che rappresentano valori negativi e positivi.

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.

Il value parametro viene analizzato usando le informazioni di formattazione in un NumberFormatInfo oggetto inizializzato per le impostazioni cultura di sistema correnti. Per specificare le impostazioni cultura le cui informazioni di formattazione vengono utilizzate per l'operazione di analisi, chiamare l'overload Parse(String, NumberStyles, IFormatProvider) .

Vedi anche

Si applica a

Parse(String)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte la rappresentazione di stringa di un numero nell'equivalente BigInteger .

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

Parametri

value
String

Stringa contenente il numero da convertire.

Restituisce

BigInteger

Valore equivalente al numero specificato nel value parametro .

Eccezioni

ArgumentNullException

value è null.

FormatException

value non è nel formato corretto.

Esempio

Nell'esempio seguente viene utilizzato il Parse(String) metodo per creare un'istanza di due BigInteger oggetti. Moltiplica ogni oggetto per un altro numero e quindi chiama il Compare metodo per determinare la relazione tra i due valori.

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.

Commenti

Il value parametro deve essere la rappresentazione di stringa di un numero nel formato seguente.

[ws][sign]digits[ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive i singoli elementi.

Elemento Descrzione
Ws Spazio vuoto facoltativo.
sign Segno facoltativo. I caratteri di segno validi sono determinati dalle NumberFormatInfo.NegativeSign proprietà e NumberFormatInfo.PositiveSign delle impostazioni cultura correnti.
Cifre Sequenza di cifre compresa tra 0 e 9. Tutti gli zeri iniziali vengono ignorati.

Annotazioni

La stringa specificata dal value parametro viene interpretata utilizzando lo NumberStyles.Integer stile . Non può contenere separatori di gruppo o separatori decimali e non può avere una parte decimale.

Il value parametro viene analizzato usando le informazioni di formattazione in un System.Globalization.NumberFormatInfo oggetto inizializzato per le impostazioni cultura di sistema correnti. Per altre informazioni, vedere NumberFormatInfo.CurrentInfo. Per analizzare una stringa usando le informazioni di formattazione di impostazioni cultura specifiche, usare il Parse(String, IFormatProvider) metodo .

Importante

Se si usa il Parse metodo per eseguire il round trip della rappresentazione di stringa di un BigInteger valore restituito dal ToString metodo , è necessario utilizzare il BigInteger.ToString(String) metodo con l'identificatore di formato "R" per generare la rappresentazione di stringa del BigInteger valore. In caso contrario, la rappresentazione di stringa di BigInteger mantiene solo le 50 cifre più significative del valore originale e i dati possono andare persi quando si usa il Parse metodo per ripristinare il BigInteger valore.

Vedi anche

Si applica a