Single.TryParse Metodo

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Converte la rappresentazione di stringa di un numero nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.

Overload

TryParse(String, IFormatProvider, Single)	Tenta di analizzare una stringa in un valore.
TryParse(ReadOnlySpan<Char>, Single)	Converte la rappresentazione di stringa di un numero in un intervallo di caratteri nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.
TryParse(String, Single)	Converte la rappresentazione di stringa di un numero nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)	Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)	Tenta di analizzare un intervallo di caratteri in un valore.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)	Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.
TryParse(ReadOnlySpan<Byte>, Single)	Prova a convertire un intervallo di caratteri UTF-8 contenente la rappresentazione di stringa di un numero nel numero a virgola mobile a precisione singola equivalente.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)	Converte la rappresentazione dell'intervallo di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.
TryParse(String, NumberStyles, IFormatProvider, Single)	Converte la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

TryParse(String, IFormatProvider, Single)

Origine:

Single.cs

Tenta di analizzare una stringa in un valore.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = IParsable<float>::TryParse;

public static bool TryParse (string? s, IFormatProvider? provider, out float result);

static member TryParse : string * IFormatProvider * single -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Single) As Boolean

Parametri

s

String

Stringa da analizzare.

provider

IFormatProvider

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

result

Single

Quando termina, questo metodo contiene il risultato dell'analisi corretta s o di un valore non definito in caso di errore.

Restituisce

Boolean

true se s è stato analizzato correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Char>, Single)

Origine:

Single.cs

Converte la rappresentazione di stringa di un numero in un intervallo di caratteri nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] float % result);

public static bool TryParse (ReadOnlySpan<char> s, out float result);

static member TryParse : ReadOnlySpan<char> * single -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Single) As Boolean

Parametri

s

ReadOnlySpan<Char>

>Intervallo di caratteri contenente la rappresentazione di stringa del numero da convertire.

result

Single

Quando termina, questo metodo contiene il numero a virgola mobile a precisione singola equivalente al parametro s, se la conversione ha avuto esito positivo o zero se la conversione non è riuscita. La conversione ha esito negativo se il parametro s è null o vuoto o non è un numero in un formato valido. Se s è un numero valido minore di Single.MinValue, result è NegativeInfinity. Se s è un numero valido maggiore di Single.MaxValue, result è PositiveInfinity. Questo parametro viene passato non inizializzato; qualsiasi valore originariamente fornito in result verrà sovrascritto.

Restituisce

Boolean

true se s è stata convertita correttamente; in caso contrario, false.

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

TryParse(String, Single)

Origine:

Single.cs

Converte la rappresentazione di stringa di un numero nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] float % result);

public static bool TryParse (string? s, out float result);

static member TryParse : string * single -> bool

Public Shared Function TryParse (s As String, ByRef result As Single) As Boolean

Parametri

s

String

Stringa che rappresenta un numero da convertire.

result

Single

Quando termina, questo metodo contiene un numero a virgola mobile e precisione singola equivalente al valore numerico o al simbolo contenuto in s, se la conversione ha avuto esito positivo oppure zero se la conversione non è riuscita. La conversione non riesce se il parametro s è null o Empty o non è un numero in un formato valido. Ha inoltre esito negativo in .NET Framework e .NET Core 2.2 e versioni precedenti se s rappresenta un numero minore di Single.MinValue o maggiore di Single.MaxValue. Questo parametro viene passato non inizializzato; qualsiasi valore originariamente fornito in result verrà sovrascritto.

Restituisce

Boolean

true se s è stata convertita correttamente; in caso contrario, false.

Esempio

Nell'esempio seguente viene utilizzato il metodo TryParse(String, Single) per convertire le rappresentazioni di stringa di valori numerici in valori Single. Si presuppone che en-US sia la lingua corrente.

string value;
float number;

// Parse a floating-point value with a thousands separator.
value = "1,643.57";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse a floating-point value with a currency symbol and a
// thousands separator.
value = "$1,643.57";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse value in exponential notation.
value = "-1.643e6";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse a negative integer value.
value = "-168934617882109132";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);
// The example displays the following output:
//       1643.57
//       Unable to parse '$1,643.57'.
//       -164300
//       -1.689346E+17

// Parse a floating-point value with a thousands separator.
let value = "1,643.57"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse a floating-point value with a currency symbol and a
// thousands separator.
let value = "$1,643.57"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse value in exponential notation.
let value = "-1.643e6"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse a negative integer value.
let value = "-168934617882109132"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."
// The example displays the following output:
//       1643.57
//       Unable to parse '$1,643.57'.
//       -164300
//       -1.689346E+17

Dim value As String
Dim number As Single

' Parse a floating-point value with a thousands separator.
value = "1,643.57"
If Single.TryParse(value, number) Then
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse a floating-point value with a currency symbol and a
' thousands separator.
value = "$1,643.57"
If Single.TryParse(value, number) Then
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse value in exponential notation.
value = "-1.643e6"
If Single.TryParse(value, number)
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse a negative integer number.
value = "-168934617882109132"
If Single.TryParse(value, number)
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If
' The example displays the following output:
'       1643.57
'       Unable to parse '$1,643.57'.
'       -1643000
'       -1.689346E+17

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

Questo overload è diverso dal metodo Single.Parse(String) restituendo un valore booleano che indica se l'operazione di analisi è riuscita anziché restituire il valore numerico analizzato. Elimina la necessità di usare la gestione delle eccezioni per testare un FormatException nel caso in cui s non sia valido e non possa essere analizzato correttamente.

Il parametro s può contenere PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol (il confronto tra stringhe fa distinzione tra maiuscole e minuscole) o una stringa del formato:

[ws] [sign] [integral-digits,]integral-digits[.[ fractional-digits]][e[sign]exponential-digits][ws]

Gli elementi tra parentesi quadre sono facoltativi. La tabella seguente descrive ogni elemento.

Elemento	Descrizione
ws	Serie di spazi vuoti.
firmare	Simbolo di segno negativo o segno positivo.
cifre integrali	Serie di caratteri numerici compresi tra 0 e 9 che specificano la parte integrante del numero. Le cifre integrali possono essere assenti se sono presenti cifre frazionarie.
,	Simbolo separatore di gruppi specifico delle impostazioni cultura.
.	Simbolo di virgola decimale specifica delle impostazioni cultura.
cifre frazionarie	Serie di caratteri numerici compresi tra 0 e 9 che specificano la parte frazionaria del numero.
E	Carattere maiuscolo o minuscolo 'e', che indica la notazione esponenziale (scientifica).
di cifre esponenziali	Serie di caratteri numerici compresi tra 0 e 9 che specificano un esponente.

Il parametro s viene interpretato usando una combinazione di flag NumberStyles.Float e NumberStyles.AllowThousands. Ciò significa che gli spazi vuoti e le migliaia di separatori sono consentiti, ma i simboli di valuta non sono. Per definire in modo esplicito gli elementi ,ad esempio simboli di valuta, migliaia di separatori e spazi vuoti, che possono essere presenti in s, usare l'overload del metodo TryParse(String, NumberStyles, IFormatProvider, Single).

Il parametro s viene analizzato usando le informazioni di formattazione in un oggetto 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 altre impostazioni cultura specificate, usare l'overload del metodo TryParse(String, NumberStyles, IFormatProvider, Single).

In genere, se si passa il metodo Single.TryParse una stringa creata chiamando il metodo Single.ToString, viene restituito il valore Single originale. Tuttavia, a causa di una perdita di precisione, i valori potrebbero non essere uguali.

Se s non è compreso nell'intervallo del tipo di dati Single, il metodo restituisce false in .NET Framework e .NET Core 2.2 e versioni precedenti. In .NET Core 3.0 e versioni successive restituisce Single.NegativeInfinity se s è minore di Single.MinValue e Single.PositiveInfinity se s è maggiore di Single.MaxValue.

Se viene rilevato un separatore nel parametro s durante un'operazione di analisi e i separatori decimali o numerici applicabili sono gli stessi, l'operazione di analisi presuppone che il separatore sia un separatore decimale anziché un separatore di gruppo. Per altre informazioni sui separatori, vedere CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Vedi anche

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

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)

Origine:

Single.cs

Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = IUtf8SpanParsable<float>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Single) As Boolean

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.

result

Single

In caso di restituzione, contiene il risultato dell'analisi corretta utf8Text o di un valore non definito in caso di errore.

Restituisce

Boolean

true se utf8Text è stato analizzato correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)

Origine:

Single.cs

Tenta di analizzare un intervallo di caratteri in un valore.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = ISpanParsable<float>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * single -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Single) As Boolean

Parametri

s

ReadOnlySpan<Char>

Intervallo di caratteri da analizzare.

provider

IFormatProvider

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

result

Single

Quando termina, questo metodo contiene il risultato dell'analisi corretta so di un valore non definito in caso di errore.

Restituisce

Boolean

true se s è stato analizzato correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)

Origine:

Single.cs

Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

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.

result

Single

In caso di restituzione, contiene il risultato dell'analisi corretta utf8Text o di un valore non definito in caso di errore.

Restituisce

Boolean

true se utf8Text è stato analizzato correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Byte>, Single)

Origine:

Single.cs

Prova a convertire un intervallo di caratteri UTF-8 contenente la rappresentazione di stringa di un numero nel numero a virgola mobile a precisione singola equivalente.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] float % result);

public static bool TryParse (ReadOnlySpan<byte> utf8Text, out float result);

static member TryParse : ReadOnlySpan<byte> * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Single) As Boolean

Parametri

utf8Text

ReadOnlySpan<Byte>

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

result

Single

Quando termina, questo metodo contiene un numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo contenuto in utf8Text se la conversione ha avuto esito positivo o zero se la conversione non è riuscita. La conversione non riesce se il utf8Text è Empty o non è in un formato valido. Questo parametro viene passato non inizializzato; qualsiasi valore specificato originariamente nel risultato verrà sovrascritto.

Restituisce

Boolean

true se utf8Text è stata convertita correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)

Origine:

Single.cs

Converte la rappresentazione dell'intervallo di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * single -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

Parametri

s

ReadOnlySpan<Char>

Intervallo di caratteri di sola lettura che contiene il numero da convertire. L'intervallo viene interpretato usando lo stile specificato da style.

style

NumberStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di s. Un valore tipico da specificare è Float combinato con AllowThousands.

provider

IFormatProvider

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

result

Single

Quando termina, questo metodo contiene il numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo contenuto in s, se la conversione ha avuto esito positivo oppure zero se la conversione non è riuscita. La conversione non riesce se il parametro s è null o Empty, non è conforme a style, rappresenta un numero minore di Single.MinValue o maggiore di Single.MaxValueo se style non è una combinazione valida di costanti enumerate NumberStyles. Questo parametro viene passato non inizializzato; qualsiasi valore originariamente fornito in result verrà sovrascritto.

Restituisce

Boolean

true se s è stata convertita correttamente; in caso contrario, false.

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

TryParse(String, NumberStyles, IFormatProvider, Single)

Origine:

Single.cs

Converte la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * single -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

Parametri

s

String

Stringa che rappresenta un numero da convertire.

style

NumberStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di s. Un valore tipico da specificare è Float combinato con AllowThousands.

provider

IFormatProvider

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

result

Single

Quando termina, questo metodo contiene il numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo contenuto in s, se la conversione ha avuto esito positivo oppure zero se la conversione non è riuscita. La conversione non riesce se il parametro s è null o Empty, non è conforme a styleo se style non è una combinazione valida di costanti di enumerazione NumberStyles. Ha inoltre esito negativo in .NET Framework o .NET Core 2.2 e versioni precedenti se s rappresenta un numero minore di Single.MinValue o maggiore di Single.MaxValue. Questo parametro viene passato non inizializzato; qualsiasi valore originariamente fornito in result verrà sovrascritto.

Restituisce

Boolean

true se s è stata convertita correttamente; in caso contrario, false.

Eccezioni

ArgumentException

style non è un valore di NumberStyles.

-o-

style è il valore di AllowHexSpecifier.

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo Single.TryParse(String, NumberStyles, IFormatProvider, Single) per analizzare la rappresentazione di stringa di numeri con uno stile specifico e formattati usando le convenzioni di una determinata cultura.

string value;
System.Globalization.NumberStyles style;
System.Globalization.CultureInfo culture;
float number;

// Parse currency value using en-GB culture.
value = "£1,097.63";
style = System.Globalization.NumberStyles.Number |
        System.Globalization.NumberStyles.AllowCurrencySymbol;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1345,978";
style = System.Globalization.NumberStyles.AllowDecimalPoint;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1.345,978";
style = System.Globalization.NumberStyles.AllowDecimalPoint |
        System.Globalization.NumberStyles.AllowThousands;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("es-ES");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1 345,978";
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// The example displays the following output:
//       Converted '£1,097.63' to 1097.63.
//       Converted '1345,978' to 1345.978.
//       Converted '1.345,978' to 1345.978.
//       Unable to convert '1 345,978'.

// Parse currency value using en-GB culture.
let value = "£1,097.63"
let style = System.Globalization.NumberStyles.Number ||| System.Globalization.NumberStyles.AllowCurrencySymbol
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1345,978"
let style = System.Globalization.NumberStyles.AllowDecimalPoint
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "fr-FR"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1.345,978"
let style = System.Globalization.NumberStyles.AllowDecimalPoint ||| System.Globalization.NumberStyles.AllowThousands
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "es-ES"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1 345,978"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// The example displays the following output:
//       Converted '£1,097.63' to 1097.63.
//       Converted '1345,978' to 1345.978.
//       Converted '1.345,978' to 1345.978.
//       Unable to convert '1 345,978'.

Dim value As String
Dim style As System.Globalization.NumberStyles
Dim culture As System.Globalization.CultureInfo
Dim number As Single

' Parse currency value using en-GB culture.
value = "£1,097.63"
style = System.Globalization.NumberStyles.Number Or _
        System.Globalization.NumberStyles.AllowCurrencySymbol
culture = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1345,978"
style = System.Globalization.NumberStyles.AllowDecimalPoint
culture = System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1.345,978"
style = System.Globalization.NumberStyles.AllowDecimalPoint Or _
        System.Globalization.NumberStyles.AllowThousands
culture = System.Globalization.CultureInfo.CreateSpecificCulture("es-ES")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1 345,978"
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If
' The example displays the following output:
'       Converted '£1,097.63' to 1097.63.
'       Converted '1345,978' to 1345.978.
'       Converted '1.345,978' to 1345.978.
'       Unable to convert '1 345,978'.

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

Questo overload è diverso dal metodo Parse(String, NumberStyles, IFormatProvider) restituendo un valore booleano che indica se l'operazione di analisi è riuscita anziché restituire il valore numerico analizzato. Elimina la necessità di usare la gestione delle eccezioni per testare un FormatException nel caso in cui s non sia valido e non possa essere analizzato correttamente.

Il parametro style definisce il formato consentito del parametro s affinché l'operazione di analisi abbia esito positivo. Deve essere una combinazione di flag di bit dell'enumerazione NumberStyles. I membri NumberStyles seguenti non sono supportati:

• NumberStyles.AllowHexSpecifier

• NumberStyles.HexNumber

Il parametro s può contenere PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol per le impostazioni cultura indicate da provider. Inoltre, a seconda del valore di style, il parametro s può includere gli elementi seguenti:

[ws] [$] [sign] [integral-digits,]integral-digits[.fractional-digits][e[sign]exponential-digits][ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. 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. Può essere visualizzato alla fine di s se style include il flag di NumberStyles.AllowTrailingWhite.
$	Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalle proprietà NumberFormatInfo.CurrencyNegativePattern o NumberFormatInfo.CurrencyPositivePattern dell'oggetto NumberFormatInfo restituito dal metodo IFormatProvider.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 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.
cifre integrali	Serie di cifre comprese tra 0 e 9 che specificano la parte integrante del numero. Le cifre integrali possono essere assenti se sono presenti cifre frazionarie.
,	Simbolo separatore delle migliaia specifico delle impostazioni cultura. Il simbolo separatore delle migliaia di impostazioni cultura correnti 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.
cifre frazionarie	Serie di cifre comprese tra 0 e 9 che specificano la parte frazionaria del numero. Le cifre frazionarie possono essere visualizzate in s se style include il flag di NumberStyles.AllowDecimalPoint.
e	Carattere e o E, che indica che s può rappresentare un numero utilizzando la notazione esponenziale. Il parametro s può rappresentare un numero in notazione esponenziale se lo stile include il flag NumberStyles.AllowExponent.
di cifre esponenziali	Serie di cifre comprese tra 0 e 9 che specificano un esponente.

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 Single. Gli altri System.Globalization.NumberStyles membri controllano gli elementi che possono essere ma non devono essere presenti nella stringa di input. La tabella seguente indica in che modo i singoli flag di NumberStyles influiscono sugli elementi che possono essere presenti in s.

Valore NumberStyles	Elementi consentiti in s oltre alle cifre
None	Solo cifre integrali elemento.
AllowDecimalPoint	Oggetto . e cifre frazionarie elementi.
AllowExponent	Il parametro s può anche usare la notazione esponenziale. Questo flag supporta i valori nel formato cifre integraliEcifre esponenziali; sono necessari flag aggiuntivi per analizzare correttamente le stringhe in notazione esponenziale con elementi quali segni positivi o negativi e simboli decimali.
AllowLeadingWhite	Elemento ws all'inizio di .
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 ,.
AllowCurrencySymbol	Elemento $.
Currency	Tutto. Il parametro s non può rappresentare un numero esadecimale o un numero in notazione esponenziale.
Float	Elemento all'inizio o alla fine di , segno all'inizio di e . simbolo. Il parametro s può anche usare la notazione esponenziale.
Number	Elementi separatore ws, sign, migliaia (, ), e separatore decimale (.).
Any	Tutti gli stili, ad eccezione di s non possono rappresentare un numero esadecimale.

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

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

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

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

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

Se s non è compreso nell'intervallo del tipo di dati Single, il metodo genera un OverflowException in .NET Framework e .NET Core 2.2 e versioni precedenti. In .NET Core 3.0 e versioni successive restituisce Single.NegativeInfinity se s è minore di Single.MinValue e Single.PositiveInfinity se s è maggiore di Single.MaxValue.

Se viene rilevato un separatore nel parametro s durante un'operazione di analisi e i separatori decimali o numerici applicabili sono gli stessi, l'operazione di analisi presuppone che il separatore sia un separatore decimale anziché un separatore di gruppo. Per altre informazioni sui separatori, vedere CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Vedi anche

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