UInt64.Parse Metodo

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Converte la rappresentazione di stringa di un numero nell'equivalente intero senza segno a 64 bit.

Overload

Parse(String, NumberStyles, IFormatProvider)	Converte la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nell'equivalente intero senza segno a 64 bit.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converte la rappresentazione di intervallo di un numero in uno stile e un formato specifico delle impostazioni cultura specificati nell'equivalente intero senza segno a 64 bit.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analizza un intervallo di caratteri UTF-8 in un valore.
Parse(String, IFormatProvider)	Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura specificato nell'equivalente intero senza segno a 64 bit.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizza un intervallo di caratteri in un valore.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analizza un intervallo di caratteri UTF-8 in un valore.
Parse(String)	Converte la rappresentazione di stringa di un numero nell'equivalente intero senza segno a 64 bit.
Parse(String, NumberStyles)	Converte la rappresentazione di stringa di un numero in uno stile specificato nell'equivalente intero senza segno a 64 bit.

Parse(String, NumberStyles, IFormatProvider)

Origine:

UInt64.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Decimal.Parse(String)

Converte la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nell'equivalente intero senza segno a 64 bit.

public:
 static System::UInt64 Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::UInt64>::Parse;

public static ulong Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> uint64

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As ULong

Parametri

s

String

Stringa che rappresenta il numero da convertire. La stringa viene interpretata usando lo stile specificato dal parametro style.

style

NumberStyles

Combinazione bit per bit di valori di enumerazione che indica gli elementi di stile che possono essere presenti in s. Un valore tipico da specificare è Integer.

provider

IFormatProvider

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

Restituisce

UInt64

Intero senza segno a 64 bit equivalente al numero specificato in s.

Implementazioni

Parse(String, NumberStyles, IFormatProvider)

Eccezioni

ArgumentNullException

Il parametro s è null.

ArgumentException

style non è un valore di NumberStyles.

-o-

style non è una combinazione di valori di AllowHexSpecifier e HexNumber.

FormatException

Il parametro s non è conforme a style.

OverflowException

Il parametro s rappresenta un numero minore di UInt64.MinValue o maggiore di UInt64.MaxValue.

-o-

s include cifre frazionarie diversi da zero.

Esempio

Nell'esempio seguente viene utilizzato il metodo Parse(String, NumberStyles, IFormatProvider) per convertire varie rappresentazioni di stringa di numeri in valori interi senza segno a 64 bit.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] cultureNames= { "en-US", "fr-FR" };
      NumberStyles[] styles= { NumberStyles.Integer,
                               NumberStyles.Integer | NumberStyles.AllowDecimalPoint };
      string[] values = { "170209", "+170209.0", "+170209,0", "-103214.00",
                                 "-103214,00", "104561.1", "104561,1" };
      
      // Parse strings using each culture
      foreach (string cultureName in cultureNames)
      {
         CultureInfo ci = new CultureInfo(cultureName);
         Console.WriteLine("Parsing strings using the {0} culture", 
                           ci.DisplayName);
         // Use each style.
         foreach (NumberStyles style in styles)
         {
            Console.WriteLine("   Style: {0}", style.ToString());
            // Parse each numeric string.
            foreach (string value in values)
            {
               try {
                  Console.WriteLine("      Converted '{0}' to {1}.", value,
                                    UInt64.Parse(value, style, ci));
               }
               catch (FormatException) {
                  Console.WriteLine("      Unable to parse '{0}'.", value);
               }      
               catch (OverflowException) {
                  Console.WriteLine("      '{0}' is out of range of the UInt64 type.",
                                    value);
               }
            }
         }
      }                                    
   }
}
// The example displays the following output:
//       Style: Integer
//          Converted '170209' to 170209.
//          Unable to parse '+170209.0'.
//          Unable to parse '+170209,0'.
//          Unable to parse '-103214.00'.
//          Unable to parse '-103214,00'.
//          Unable to parse '104561.1'.
//          Unable to parse '104561,1'.
//       Style: Integer, AllowDecimalPoint
//          Converted '170209' to 170209.
//          Converted '+170209.0' to 170209.
//          Unable to parse '+170209,0'.
//          '-103214.00' is out of range of the UInt64 type.
//          Unable to parse '-103214,00'.
//          '104561.1' is out of range of the UInt64 type.
//          Unable to parse '104561,1'.
//    Parsing strings using the French (France) culture
//       Style: Integer
//          Converted '170209' to 170209.
//          Unable to parse '+170209.0'.
//          Unable to parse '+170209,0'.
//          Unable to parse '-103214.00'.
//          Unable to parse '-103214,00'.
//          Unable to parse '104561.1'.
//          Unable to parse '104561,1'.
//       Style: Integer, AllowDecimalPoint
//          Converted '170209' to 170209.
//          Unable to parse '+170209.0'.
//          Converted '+170209,0' to 170209.
//          Unable to parse '-103214.00'.
//          '-103214,00' is out of range of the UInt64 type.
//          Unable to parse '104561.1'.
//          '104561,1' is out of range of the UInt64 type.

open System
open System.Globalization

let cultureNames = [| "en-US"; "fr-FR" |]
let styles = [| NumberStyles.Integer; NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint |]
let values = 
    [| "170209"; "+170209.0"; "+170209,0"; "-103214.00"
       "-103214,00"; "104561.1"; "104561,1" |]

// Parse strings using each culture
for cultureName in cultureNames do
    let ci = CultureInfo cultureName
    printfn $"Parsing strings using the {ci.DisplayName} culture"
    // Use each style.
    for style in styles do
        printfn $"   Style: {style}"
        // Parse each numeric string.
        for value in values do
            try
                printfn $"      Converted '{value}' to {UInt64.Parse(value, style, ci)}."
            with
            | :? FormatException ->
                printfn $"      Unable to parse '{value}'."
            | :? OverflowException ->
                printfn $"      '{value}' is out of range of the UInt64 type."
// The example displays the following output:
//       Style: Integer
//          Converted '170209' to 170209.
//          Unable to parse '+170209.0'.
//          Unable to parse '+170209,0'.
//          Unable to parse '-103214.00'.
//          Unable to parse '-103214,00'.
//          Unable to parse '104561.1'.
//          Unable to parse '104561,1'.
//       Style: Integer, AllowDecimalPoint
//          Converted '170209' to 170209.
//          Converted '+170209.0' to 170209.
//          Unable to parse '+170209,0'.
//          '-103214.00' is out of range of the UInt64 type.
//          Unable to parse '-103214,00'.
//          '104561.1' is out of range of the UInt64 type.
//          Unable to parse '104561,1'.
//    Parsing strings using the French (France) culture
//       Style: Integer
//          Converted '170209' to 170209.
//          Unable to parse '+170209.0'.
//          Unable to parse '+170209,0'.
//          Unable to parse '-103214.00'.
//          Unable to parse '-103214,00'.
//          Unable to parse '104561.1'.
//          Unable to parse '104561,1'.
//       Style: Integer, AllowDecimalPoint
//          Converted '170209' to 170209.
//          Unable to parse '+170209.0'.
//          Converted '+170209,0' to 170209.
//          Unable to parse '-103214.00'.
//          '-103214,00' is out of range of the UInt64 type.
//          Unable to parse '104561.1'.
//          '104561,1' is out of range of the UInt64 type.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR" }
      Dim styles() As NumberStyles = { NumberStyles.Integer, _
                                       NumberStyles.Integer Or NumberStyles.AllowDecimalPoint }
      Dim values() As String = { "170209", "+170209.0", "+170209,0", "-103214.00", _
                                 "-103214,00", "104561.1", "104561,1" }
      
      ' Parse strings using each culture
      For Each cultureName As String In cultureNames
         Dim ci As New CultureInfo(cultureName)
         Console.WriteLine("Parsing strings using the {0} culture", ci.DisplayName)
         ' Use each style.
         For Each style As NumberStyles In styles
            Console.WriteLine("   Style: {0}", style.ToString())
            ' Parse each numeric string.
            For Each value As String In values
               Try
                  Console.WriteLine("      Converted '{0}' to {1}.", value, _
                                    UInt64.Parse(value, style, ci))
               Catch e As FormatException
                  Console.WriteLine("      Unable to parse '{0}'.", value)   
               Catch e As OverflowException
                  Console.WriteLine("      '{0}' is out of range of the UInt64 type.", _
                                    value)         
               End Try
            Next
         Next
      Next                                    
   End Sub
End Module
' The example displays the following output:
'       Style: Integer
'          Converted '170209' to 170209.
'          Unable to parse '+170209.0'.
'          Unable to parse '+170209,0'.
'          Unable to parse '-103214.00'.
'          Unable to parse '-103214,00'.
'          Unable to parse '104561.1'.
'          Unable to parse '104561,1'.
'       Style: Integer, AllowDecimalPoint
'          Converted '170209' to 170209.
'          Converted '+170209.0' to 170209.
'          Unable to parse '+170209,0'.
'          '-103214.00' is out of range of the UInt64 type.
'          Unable to parse '-103214,00'.
'          '104561.1' is out of range of the UInt64 type.
'          Unable to parse '104561,1'.
'    Parsing strings using the French (France) culture
'       Style: Integer
'          Converted '170209' to 170209.
'          Unable to parse '+170209.0'.
'          Unable to parse '+170209,0'.
'          Unable to parse '-103214.00'.
'          Unable to parse '-103214,00'.
'          Unable to parse '104561.1'.
'          Unable to parse '104561,1'.
'       Style: Integer, AllowDecimalPoint
'          Converted '170209' to 170209.
'          Unable to parse '+170209.0'.
'          Converted '+170209,0' to 170209.
'          Unable to parse '-103214.00'.
'          '-103214,00' is out of range of the UInt64 type.
'          Unable to parse '104561.1'.
'          '104561,1' is out of range of the UInt64 type.

Commenti

Il parametro style definisce gli elementi di stile,ad esempio lo spazio vuoto o il simbolo di segno positivo o negativo, consentiti nel parametro s per l'esito positivo dell'operazione di analisi. Deve essere una combinazione di flag di bit dell'enumerazione NumberStyles.

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

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

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. Se style include NumberStyles.AllowHexSpecifier, il parametro s può includere gli elementi seguenti:

[ws]hexdigits[ws]

La tabella seguente descrive ogni elemento.

Elemento	Descrizione
ws	Spazio vuoto facoltativo. Gli spazi vuoti possono essere visualizzati all'inizio di s se style include il flag di NumberStyles.AllowLeadingWhite e possono essere visualizzati alla fine di s se style include il flag NumberStyles.AllowTrailingWhite.
$	Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalla proprietà CurrencyPositivePattern dell'oggetto NumberFormatInfo restituito dal metodo GetFormat del parametro provider. Il simbolo di valuta può essere visualizzato in s se style include il flag di NumberStyles.AllowCurrencySymbol.
firmare	Segno facoltativo. Il metodo genera un OverflowException se s include un segno negativo e rappresenta un numero diverso da zero. Il segno può essere visualizzato all'inizio di s se style include il flag di NumberStyles.AllowLeadingSign e può apparire la fine di s se style include il flag di NumberStyles.AllowTrailingSign. Le parentesi possono essere usate in s per indicare un valore negativo se style include il flag NumberStyles.AllowParentheses.
cifre	Sequenza di cifre da 0 a 9.
.	Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo decimale delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowDecimalPoint.
fractional_digits	Una o più occorrenze della cifra 0-9 se style include il flag di NumberStyles.AllowExponent o una o più occorrenze della cifra 0 in caso contrario. Le cifre frazionarie possono essere visualizzate in s solo se style include il flag di NumberStyles.AllowDecimalPoint.
E	Carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il parametro s può rappresentare un numero in notazione esponenziale se style include il flag NumberStyles.AllowExponent.
exponential_digits	Sequenza di cifre da 0 a 9. Il parametro s può rappresentare un numero in notazione esponenziale se style include il flag NumberStyles.AllowExponent.
hexdigits	Sequenza di cifre esadecimali da 0 a f o da 0 a F.

Nota

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 decimali (che corrisponde allo stile di NumberStyles.None) viene sempre analizzata correttamente. La maggior parte dei membri rimanenti NumberStyles elementi di controllo che possono essere presenti, ma non devono essere presenti, in questa stringa di input. La tabella seguente indica in che modo i singoli membri NumberStyles influiscono sugli elementi che possono essere presenti in s.

Valori di NumberStyles non compositi	Elementi consentiti in s oltre alle cifre
NumberStyles.None	Solo cifre decimali.
NumberStyles.AllowDecimalPoint	Il separatore decimale (.) e gli elementi fractional_digits. Tuttavia, se lo stile non include il flag NumberStyles.AllowExponent, fractional_digits deve essere costituito da una o più cifre 0; in caso contrario, viene generata una OverflowException.
NumberStyles.AllowExponent	Carattere "e" o "E", che indica la notazione esponenziale, insieme a exponential_digits.
NumberStyles.AllowLeadingWhite	Elemento ws all'inizio di .
NumberStyles.AllowTrailingWhite	Elemento ws alla fine di .
NumberStyles.AllowLeadingSign	Segno prima di cifre.
NumberStyles.AllowTrailingSign	Segno dopo cifre.
NumberStyles.AllowParentheses	Parentesi prima e dopo cifre per indicare un valore negativo.
NumberStyles.AllowThousands	Elemento separatore di gruppo (,).
NumberStyles.AllowCurrencySymbol	Elemento currency ($).

Se viene usato il flag NumberStyles.AllowHexSpecifier, s deve essere un valore esadecimale. I caratteri esadecimali validi sono 0-9, A-F e a-f. Un prefisso come "0x" non è supportato e causa l'esito negativo dell'operazione di analisi. Gli unici flag che possono essere combinati con esso sono NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. L'enumerazione NumberStyles include uno stile numerico composito, NumberStyles.HexNumber, che include entrambi i flag di spazio vuoto.

Nota

Se il parametro s è la rappresentazione di stringa di un numero esadecimale, non può essere preceduto da alcuna decorazione (ad esempio 0x o &h) che la differenzia come numero esadecimale. In questo modo, l'operazione di analisi genera un'eccezione.

Il parametro provider è un'implementazione IFormatProvider il cui metodo GetFormat restituisce un oggetto NumberFormatInfo che fornisce informazioni specifiche delle impostazioni cultura sul formato di s. Esistono tre modi per usare il parametro provider per fornire informazioni di formattazione personalizzate all'operazione di analisi:

• È possibile passare l'oggetto NumberFormatInfo effettivo che fornisce informazioni di formattazione. L'implementazione di GetFormat restituisce semplicemente se stessa.

• È possibile passare un oggetto CultureInfo che specifica le impostazioni cultura di cui utilizzare la formattazione. La proprietà NumberFormat fornisce informazioni di formattazione.

• È possibile passare un'implementazione di IFormatProvider personalizzata. Il metodo GetFormat deve 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

• ToString
• l'analisi di stringhe numeriche in .NET

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Origine:

UInt64.cs

Importante

Questa API non è conforme a CLS.

Converte la rappresentazione di intervallo di un numero in uno stile e un formato specifico delle impostazioni cultura specificati nell'equivalente intero senza segno a 64 bit.

public static ulong Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> uint64

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As ULong

Parametri

s

ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano il numero da convertire. L'intervallo viene interpretato usando lo stile specificato dal parametro style.

style

NumberStyles

Combinazione bit per bit di valori di enumerazione che indica gli elementi di stile che possono essere presenti in s. Un valore tipico da specificare è Integer.

provider

IFormatProvider

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

Restituisce

UInt64

Intero senza segno a 64 bit equivalente al numero specificato in s.

Implementazioni

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Origine:

UInt64.cs

Analizza un intervallo di caratteri UTF-8 in un valore.

public static ulong Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> uint64

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As ULong

Parametri

utf8Text

ReadOnlySpan<Byte>

Intervallo di caratteri UTF-8 da analizzare.

style

NumberStyles

Combinazione bit per bit di stili numerici che possono essere presenti in utf8Text.

provider

IFormatProvider

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

Restituisce

UInt64

Risultato dell'analisi utf8Text.

Implementazioni

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Origine:

UInt64.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Decimal.Parse(String)

Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura specificato nell'equivalente intero senza segno a 64 bit.

public:
 static System::UInt64 Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::UInt64>::Parse;

public static ulong Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> uint64

Public Shared Function Parse (s As String, provider As IFormatProvider) As ULong

Parametri

s

String

Stringa che rappresenta il numero da convertire.

provider

IFormatProvider

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

Restituisce

UInt64

Intero senza segno a 64 bit equivalente al numero specificato in s.

Implementazioni

Parse(String, IFormatProvider)

Eccezioni

ArgumentNullException

Il parametro s è null.

FormatException

Il parametro s non è nello stile corretto.

OverflowException

Il parametro s rappresenta un numero minore di UInt64.MinValue o maggiore di UInt64.MaxValue.

Esempio

L'esempio seguente è il gestore eventi click del pulsante di un modulo Web. Usa la matrice restituita dalla proprietà HttpRequest.UserLanguages per determinare le impostazioni locali dell'utente. Crea quindi un'istanza di un oggetto CultureInfo che corrisponde a tale impostazione locale. L'oggetto NumberFormatInfo appartenente a tale oggetto CultureInfo viene quindi passato al metodo Parse(String, IFormatProvider) per convertire l'input dell'utente in un valore UInt64.

protected void OkToSingle_Click(object sender, EventArgs e)
{
    string locale;
    float number;
    CultureInfo culture;

    // Return if string is empty
    if (String.IsNullOrEmpty(this.inputNumber.Text))
        return;

    // Get locale of web request to determine possible format of number
    if (Request.UserLanguages.Length == 0)
        return;
    locale = Request.UserLanguages[0];
    if (String.IsNullOrEmpty(locale))
        return;

    // Instantiate CultureInfo object for the user's locale
    culture = new CultureInfo(locale);

    // Convert user input from a string to a number
    try
    {
        number = Single.Parse(this.inputNumber.Text, culture.NumberFormat);
    }
    catch (FormatException)
    {
        return;
    }
    catch (Exception)
    {
        return;
    }
    // Output number to label on web form
    this.outputNumber.Text = "Number is " + number.ToString();
}

Protected Sub OkToSingle_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToSingle.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Single

   ' Return if string is empty
   If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub

   ' Get locale of web request to determine possible format of number
   If Request.UserLanguages.Length = 0 Then Exit Sub
   locale = Request.UserLanguages(0)
   If String.IsNullOrEmpty(locale) Then Exit Sub

   ' Instantiate CultureInfo object for the user's locale
   culture = New CultureInfo(locale)

   ' Convert user input from a string to a number
   Try
      number = Single.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As OverflowException
      Exit Sub
   End Try

   ' Output number to label on web form
   Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

Commenti

Questo overload del metodo Parse(String, IFormatProvider) viene in genere usato per convertire il testo che può essere formattato in diversi modi in un valore UInt64. Ad esempio, può essere usato per convertire il testo immesso da un utente in una casella di testo HTML in un valore numerico.

Il parametro s contiene un numero di form:

[ws] [sign]digits[ws]

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

Elemento	Descrizione
ws	Spazio vuoto facoltativo.
firmare	Segno positivo facoltativo o segno negativo se s rappresenta il valore zero.
cifre	Sequenza di cifre compresa tra 0 e 9.

Il parametro s viene interpretato usando lo stile NumberStyles.Integer. Oltre alle cifre decimali del valore intero senza segno, sono consentiti solo spazi iniziali e finali insieme a un segno iniziale. Se il segno negativo è presente, s deve rappresentare un valore pari a zero oppure il metodo genera un OverflowException. Per definire in modo esplicito gli elementi di stile insieme alle informazioni di formattazione specifiche delle impostazioni cultura che possono essere presenti in s, usare il metodo Parse(String, NumberStyles, IFormatProvider).

Il parametro provider è un'implementazione IFormatProvider il cui metodo GetFormat restituisce un oggetto NumberFormatInfo che fornisce informazioni specifiche delle impostazioni cultura sul formato di s. Esistono tre modi per usare il parametro provider per fornire informazioni di formattazione personalizzate all'operazione di analisi:

• È possibile passare l'oggetto NumberFormatInfo effettivo che fornisce informazioni di formattazione. L'implementazione di GetFormat restituisce semplicemente se stessa.

• È possibile passare un oggetto CultureInfo che specifica le impostazioni cultura di cui utilizzare la formattazione. La proprietà NumberFormat fornisce informazioni di formattazione.

• È possibile passare un'implementazione di IFormatProvider personalizzata. Il metodo GetFormat deve creare un'istanza e restituire l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene utilizzata la NumberFormatInfo per le impostazioni cultura correnti.

Vedi anche

• ToString()
• TryParse
• l'analisi di stringhe numeriche in .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Origine:

UInt64.cs

Analizza un intervallo di caratteri in un valore.

public:
 static System::UInt64 Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<System::UInt64>::Parse;

public static ulong Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> uint64

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As ULong

Parametri

s

ReadOnlySpan<Char>

Intervallo di caratteri da analizzare.

provider

IFormatProvider

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

Restituisce

UInt64

Risultato dell'analisi s.

Implementazioni

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Origine:

UInt64.cs

Analizza un intervallo di caratteri UTF-8 in un valore.

public:
 static System::UInt64 Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<System::UInt64>::Parse;

public static ulong Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> uint64

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As ULong

Parametri

utf8Text

ReadOnlySpan<Byte>

Intervallo di caratteri UTF-8 da analizzare.

provider

IFormatProvider

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

Restituisce

UInt64

Risultato dell'analisi utf8Text.

Implementazioni

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String)

Origine:

UInt64.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Decimal.Parse(String)

Converte la rappresentazione di stringa di un numero nell'equivalente intero senza segno a 64 bit.

public:
 static System::UInt64 Parse(System::String ^ s);

public static ulong Parse (string s);

static member Parse : string -> uint64

Public Shared Function Parse (s As String) As ULong

Parametri

s

String

Stringa che rappresenta il numero da convertire.

Restituisce

UInt64

Intero senza segno a 64 bit equivalente al numero contenuto in s.

Eccezioni

ArgumentNullException

Il parametro s è null.

FormatException

Il parametro s non è nel formato corretto.

OverflowException

Il parametro s rappresenta un numero minore di UInt64.MinValue o maggiore di UInt64.MaxValue.

Esempio

Nell'esempio seguente viene usato il metodo Parse per analizzare una matrice di valori stringa.

string[] values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                    "0xFA1B", "163042", "-10", "14065839182",
                    "16e07", "134985.0", "-12034" };
foreach (string value in values)
{
   try {
      ulong number = UInt64.Parse(value); 
      Console.WriteLine("{0} --> {1}", value, number);
   }
   catch (FormatException) {
      Console.WriteLine("{0}: Bad Format", value);
   }   
   catch (OverflowException) {
      Console.WriteLine("{0}: Overflow", value);   
   }  
}
// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10: Overflow
//       14065839182 --> 14065839182
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034: Overflow

let values = 
    [| "+13230"; "-0"; "1,390,146"; "$190,235,421,127"
       "0xFA1B"; "163042"; "-10"; "14065839182"
       "16e07"; "134985.0"; "-12034" |]
for value in values do
    try 
        let number = UInt64.Parse value 
        printfn $"{value} --> {number}"
    with
    | :? FormatException ->
        printfn $"{value}: Bad Format"
    | :? OverflowException ->
        printfn $"{value}: Overflow"
// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10: Overflow
//       14065839182 --> 14065839182
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034: Overflow

Dim values() As String = { "+13230", "-0", "1,390,146", "$190,235,421,127", _
                           "0xFA1B", "163042", "-10", "14065839182", _
                           "16e07", "134985.0", "-12034" }
For Each value As String In values
   Try
      Dim number As ULong = UInt64.Parse(value) 
      Console.WriteLine("{0} --> {1}", value, number)
   Catch e As FormatException
      Console.WriteLine("{0}: Bad Format", value)
   Catch e As OverflowException
      Console.WriteLine("{0}: Overflow", value)   
   End Try  
Next
' The example displays the following output:
'       +13230 --> 13230
'       -0 --> 0
'       1,390,146: Bad Format
'       $190,235,421,127: Bad Format
'       0xFA1B: Bad Format
'       163042 --> 163042
'       -10: Overflow
'       14065839182 --> 14065839182
'       16e07: Bad Format
'       134985.0: Bad Format
'       -12034: Overflow

Commenti

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

[ws] [firma]cifre[ws]

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

Elemento	Descrizione
ws	Spazio vuoto facoltativo.
firmare	Segno facoltativo. I caratteri di segno validi sono determinati dalle proprietà NumberFormatInfo.NegativeSign e NumberFormatInfo.PositiveSign delle impostazioni cultura correnti. Tuttavia, il simbolo di segno negativo può essere usato solo con zero; in caso contrario, il metodo genera un OverflowException.
cifre	Sequenza di cifre compresa tra 0 e 9. Tutti gli zeri iniziali vengono ignorati.

Nota

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

Il parametro s viene analizzato usando le informazioni di formattazione in un oggetto System.Globalization.NumberFormatInfo 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 metodo Parse(String, IFormatProvider).

Vedi anche

• ToString
• l'analisi di stringhe numeriche in .NET

Parse(String, NumberStyles)

Origine:

UInt64.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Decimal.Parse(String)

Converte la rappresentazione di stringa di un numero in uno stile specificato nell'equivalente intero senza segno a 64 bit.

public:
 static System::UInt64 Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static ulong Parse (string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> uint64

Public Shared Function Parse (s As String, style As NumberStyles) As ULong

Parametri

s

String

Stringa che rappresenta il numero da convertire. La stringa viene interpretata usando lo stile specificato dal parametro style.

style

NumberStyles

Combinazione bit per bit dei valori di enumerazione che specifica il formato consentito di s. Un valore tipico da specificare è Integer.

Restituisce

UInt64

Intero senza segno a 64 bit equivalente al numero specificato in s.

Eccezioni

ArgumentNullException

Il parametro s è null.

ArgumentException

style non è un valore di NumberStyles.

-o-

style non è una combinazione di valori di AllowHexSpecifier e HexNumber.

FormatException

Il parametro s non è conforme a style.

OverflowException

Il parametro s rappresenta un numero minore di UInt64.MinValue o maggiore di UInt64.MaxValue.

-o-

s include cifre frazionarie diversi da zero.

Esempio

L'esempio seguente tenta di analizzare ogni elemento in una matrice di stringhe usando un numero di valori NumberStyles.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values= { " 214309 ", "1,064,181", "(0)", "10241+", " + 21499 ", 
                         " +21499 ", "122153.00", "1e03ff", "91300.0e-2" };
      NumberStyles whitespace =  NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite;
      NumberStyles[] styles= { NumberStyles.None, whitespace, 
                               NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingSign | whitespace, 
                               NumberStyles.AllowThousands | NumberStyles.AllowCurrencySymbol, 
                               NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint };

      // Attempt to convert each number using each style combination.
      foreach (string value in values)
      {
         Console.WriteLine("Attempting to convert '{0}':", value);
         foreach (NumberStyles style in styles)
         {
            try {
               ulong number = UInt64.Parse(value, style);
               Console.WriteLine("   {0}: {1}", style, number);
            }   
            catch (FormatException) {
               Console.WriteLine("   {0}: Bad Format", style);
            }   
            catch (OverflowException)
            {
               Console.WriteLine("   {0}: Overflow", value);         
            }         
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Attempting to convert ' 214309 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: 214309
//       Integer, AllowTrailingSign: 214309
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1,064,181':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: 1064181
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '(0)':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '10241+':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 10241
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' + 21499 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' +21499 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 21499
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '122153.00':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 122153
//    
//    Attempting to convert '1e03ff':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '91300.0e-2':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 913

open System
open System.Globalization

let values =
    [| " 214309 "; "1,064,181"; "(0)"; "10241+"; " + 21499 " 
       " +21499 "; "122153.00"; "1e03ff"; "91300.0e-2" |]
let whitespace =  NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite
let styles =
    [| NumberStyles.None; whitespace 
       NumberStyles.AllowLeadingSign ||| NumberStyles.AllowTrailingSign ||| whitespace 
       NumberStyles.AllowThousands ||| NumberStyles.AllowCurrencySymbol 
       NumberStyles.AllowExponent ||| NumberStyles.AllowDecimalPoint |]

// Attempt to convert each number using each style combination.
for value in values do
    printfn $"Attempting to convert '{value}':"
    for style in styles do
        try
            let number = UInt64.Parse(value, style)
            printfn $"   {style}: {number}"
        with
        | :? FormatException ->
            printfn $"   {style}: Bad Format"
        | :? OverflowException ->
            printfn $"   {value}: Overflow"
    printfn ""
// The example displays the following output:
//    Attempting to convert ' 214309 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: 214309
//       Integer, AllowTrailingSign: 214309
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1,064,181':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: 1064181
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '(0)':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '10241+':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 10241
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' + 21499 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' +21499 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 21499
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '122153.00':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 122153
//    
//    Attempting to convert '1e03ff':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '91300.0e-2':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 913

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { " 214309 ", "1,064,181", "(0)", "10241+", _
                                 " + 21499 ", " +21499 ", "122153.00", _
                                 "1e03ff", "91300.0e-2" }
      Dim whitespace As NumberStyles =  NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite
      Dim styles() As NumberStyles = { NumberStyles.None, _
                                       whitespace, _
                                       NumberStyles.AllowLeadingSign Or NumberStyles.AllowTrailingSign Or whitespace, _
                                       NumberStyles.AllowThousands Or NumberStyles.AllowCurrencySymbol, _
                                       NumberStyles.AllowExponent Or NumberStyles.AllowDecimalPoint }

      ' Attempt to convert each number using each style combination.
      For Each value As String In values
         Console.WriteLine("Attempting to convert '{0}':", value)
         For Each style As NumberStyles In styles
            Try
               Dim number As ULong = UInt64.Parse(value, style)
               Console.WriteLine("   {0}: {1}", style, number)
            Catch e As FormatException
               Console.WriteLine("   {0}: Bad Format", style)
            Catch e As OverflowException
               Console.WriteLine("   {0}: Overflow", value)         
            End Try         
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    Attempting to convert ' 214309 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: 214309
'       Integer, AllowTrailingSign: 214309
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '1,064,181':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: 1064181
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '(0)':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '10241+':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: 10241
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert ' + 21499 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert ' +21499 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: 21499
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '122153.00':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 122153
'    
'    Attempting to convert '1e03ff':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '91300.0e-2':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 913

Commenti

Il parametro style 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 parametro s affinché l'operazione di analisi abbia esito positivo. style deve essere una combinazione di flag di bit dell'enumerazione NumberStyles. Il parametro style rende utile questo overload del metodo quando s contiene la rappresentazione di stringa di un valore esadecimale, quando il sistema numerico (decimale o esadecimale) rappresentato da s è noto solo in fase di esecuzione o quando si desidera impedire lo spazio vuoto o un simbolo di segno in s.

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

[ws] [] [firma] [cifre,]cifre[.fractional_digits][E[ segno]exponential_digits][ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. Se style include NumberStyles.AllowHexSpecifier, il parametro s può contenere gli elementi seguenti:

[ws]hexdigits[ws]

La tabella seguente descrive ogni elemento.

Elemento	Descrizione
ws	Spazio vuoto facoltativo. Lo spazio vuoto può essere visualizzato all'inizio di s se style include il flag di NumberStyles.AllowLeadingWhite e può essere visualizzato alla fine di s se style include il flag NumberStyles.AllowTrailingWhite.
$	Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalla NumberFormatInfo.CurrencyNegativePattern e dalle proprietà NumberFormatInfo.CurrencyPositivePattern delle impostazioni cultura correnti. Il simbolo di valuta delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowCurrencySymbol.
firmare	Segno facoltativo. Il segno può essere visualizzato all'inizio di s se style include il flag di NumberStyles.AllowLeadingSign e può essere visualizzato alla fine di s se style include il flag NumberStyles.AllowTrailingSign. Le parentesi possono essere usate in s per indicare un valore negativo se style include il flag NumberStyles.AllowParentheses. Tuttavia, il simbolo di segno negativo può essere usato solo con zero; in caso contrario, il metodo genera un OverflowException.
cifre fractional_digits 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 s se style include il flag NumberStyles.AllowThousands.
.	Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo decimale delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowDecimalPoint. 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 una FormatException.
E	Carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il parametro s può rappresentare un numero in notazione esponenziale se style include il flag NumberStyles.AllowExponent.
hexdigits	Sequenza di cifre esadecimali da 0 a f o da 0 a F.

Nota

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 stile NumberStyles.None) analizza sempre correttamente se si trova nell'intervallo del tipo UInt64. La maggior parte dei rimanenti NumberStyles membri controlli elementi che possono essere presenti, ma non devono essere presenti, nella stringa di input. La tabella seguente indica in che modo i singoli membri NumberStyles influiscono sugli elementi che possono essere presenti in s.

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

A differenza degli altri valori NumberStyles, che consentono, ma non richiedono, la presenza di elementi di stile specifici in s, il valore dello stile NumberStyles.AllowHexSpecifier significa che i singoli caratteri numerici in s vengono sempre interpretati come caratteri esadecimali. I caratteri esadecimali validi sono 0-9, A-F e a-f. Un prefisso come "0x" non è supportato e causa l'esito negativo dell'operazione di analisi. Gli unici flag che possono essere combinati con il parametro style sono NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. L'enumerazione NumberStyles include uno stile numerico composito, NumberStyles.HexNumber, che include entrambi i flag di spazio vuoto.

Nota

Se s è 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.

Il parametro s viene analizzato usando le informazioni di formattazione in un oggetto NumberFormatInfo 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

• ToString
• TryParse
• l'analisi di stringhe numeriche in .NET