Single.TryParse Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Converte la rappresentazione di stringa di un numero nel numero a virgola mobile a precisione singola equivalente. Un valore restituito indica se la conversione è riuscita o meno.
Overload
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single) |
Prova a analizzare un intervallo di caratteri in un valore. |
TryParse(ReadOnlySpan<Char>, Single) |
Converte la rappresentazione 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 è riuscita o meno. |
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 è riuscita o meno. |
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single) |
Prova a analizzare un intervallo di caratteri UTF-8 in un valore. |
TryParse(String, IFormatProvider, Single) |
Prova a analizzare una stringa in un valore. |
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single) |
Prova a analizzare un intervallo di caratteri UTF-8 in un valore. |
TryParse(ReadOnlySpan<Byte>, Single) |
Tenta di convertire un intervallo di caratteri UTF-8 contenente la rappresentazione stringa di un numero nell'equivalente del numero a virgola mobile a precisione singola. |
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single) |
Converte la rappresentazione 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 è riuscita o meno. |
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 è riuscita o meno. |
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, tra cui .NET Framework, analizzare un valore troppo grande per rappresentare un errore.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
- Origine:
- Single.cs
Prova a 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 relative a s
.
- result
- Single
Quando questo metodo restituisce, contiene il risultato dell'analisi s
di o un valore non definito in caso di errore.
Restituisce
true
se è stato analizzato correttamente; in caso s
contrario, false
.
Si applica a
TryParse(ReadOnlySpan<Char>, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
- Origine:
- Single.cs
Converte la rappresentazione 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 è riuscita o meno.
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 che contiene la rappresentazione stringa del numero da convertire.
- result
- Single
Al termine, questo metodo contiene il numero a virgola mobile a precisione singola equivalente al parametro s
se la conversione ha esito positivo oppure zero se la conversione non riesce. La conversione non riesce se il parametro s
è null
o vuoto oppure 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 fornito in origine in result
verrà sovrascritto.
Restituisce
true
se s
è stato convertito 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, tra cui .NET Framework, analizzare un valore troppo grande per rappresentare un errore.
Si applica a
TryParse(String, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
- 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 è riuscita o meno.
public:
static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] float % result);
public static bool TryParse (string s, 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 questo metodo viene restituito, contiene il numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo contenuto in s
, se la conversione ha esito positivo oppure zero se la conversione non riesce. La conversione non riesce se il parametro s
è null
o Empty o non è un numero in un formato valido. Non riesce anche in .NET Framework e nelle versioni s
precedenti di .NET Core 2.2 se rappresenta un numero minore di Single.MinValue o maggiore di Single.MaxValue. Questo parametro viene passato non inizializzato. Qualsiasi valore fornito in origine in result
verrà sovrascritto.
Restituisce
true
se s
è stato convertito correttamente; in caso contrario, false
.
Esempio
Nell'esempio seguente viene usato il TryParse(String, Single) metodo per convertire le rappresentazioni stringa di valori numerici in Single valori. Si presuppone che en-US sia la cultura 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, tra cui .NET Framework, analizzare un valore troppo grande per rappresentare un errore.
Questo overload è diverso dal Single.Parse(String) metodo restituendo un valore booleano che indica se l'operazione di analisi ha avuto esito positivo anziché restituire il valore numerico analizzato. Elimina la necessità di usare la gestione delle eccezioni per testare un FormatException oggetto nell'evento non s
valido e non può essere analizzato correttamente.
Il parametro può contenere PositiveInfinitySymbol, , NaNSymbolNegativeInfinitySymbol(il s
confronto tra stringhe è distinzione tra maiuscole e minuscole) o una stringa del modulo:
[ws] [sign] [cifre integrali,]cifre integrali[.[ frazionarie-cifre]][e[sign]esponenziale-cifre][ws]
Gli elementi tra parentesi quadre sono facoltativi. La tabella seguente descrive i singoli elementi.
Elemento | Descrizione |
---|---|
ws | Serie di caratteri spazi vuoti. |
sign | Segno negativo o simbolo di 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 gruppo specifico delle impostazioni cultura. |
. | Simbolo decimale specifico delle impostazioni cultura. |
cifre frazionarie | Serie di caratteri numerici compresi tra 0 e 9 che specificano la parte frazionaria del numero. |
E | Un carattere maiuscolo o minuscolo 'e', che indica la notazione esponenziale (scientifica). |
cifre esponenziali | Serie di caratteri numerici compresi tra 0 e 9 che specificano un esponente. |
Il s
parametro viene interpretato usando una combinazione di NumberStyles.Float flag e NumberStyles.AllowThousands . Ciò significa che lo spazio vuoto 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 TryParse(String, NumberStyles, IFormatProvider, Single) metodo.
Il s
parametro viene analizzato usando le informazioni di formattazione in un 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 alcune altre impostazioni cultura specificate, usare l'overload del TryParse(String, NumberStyles, IFormatProvider, Single) metodo.
In genere, se si passa il metodo una stringa creata chiamando il Single.TryParse metodo, viene restituito il Single.ToString valore originale Single . Tuttavia, a causa di una perdita di precisione, i valori potrebbero non essere uguali.
Se s
non è compreso nell'intervallo Single del tipo di dati, il metodo restituisce false
in .NET Framework e in .NET Core 2.2 e versioni precedenti. In .NET Core 3.0 e versioni successive, restituisce se è minore di Single.MinValue e Single.PositiveInfinity se s
è maggiore di Single.MaxValue.s
Single.NegativeInfinity
Se viene rilevato un separatore nel s
parametro durante un'operazione di analisi e i separatori decimali o numerici applicabili sono uguali, 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
Si applica a
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
Prova a 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 relative a utf8Text
.
- result
- Single
In caso di restituzione, contiene il risultato dell'analisi utf8Text
corretta o di un valore non definito in caso di errore.
Restituisce
true
se è stato analizzato correttamente; in caso utf8Text
contrario, false
.
Si applica a
TryParse(String, IFormatProvider, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
- 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 relative a s
.
- result
- Single
Quando termina, questo metodo contiene il risultato dell'analisi s
corretta o di un valore non definito in caso di errore.
Restituisce
true
se s
è stato analizzato correttamente; in caso contrario, false
.
Si applica a
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
Tenta di 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 relative a utf8Text
.
- result
- Single
In caso di restituzione, contiene il risultato dell'analisi utf8Text
corretta o di un valore non definito in caso di errore.
Restituisce
true
se utf8Text
è stato analizzato correttamente; in caso contrario, false
.
Si applica a
TryParse(ReadOnlySpan<Byte>, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
Tenta di convertire un intervallo di caratteri UTF-8 contenente la rappresentazione di stringa di un numero nel numero a virgola mobile e 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 e 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 riesce. La conversione ha esito negativo se è utf8Text
Empty o non è in un formato valido. Questo parametro viene passato non inizializzato. Qualsiasi valore specificato in origine in result verrà sovrascritto.
Restituisce
true
se utf8Text
è stato convertito correttamente; in caso contrario, false
.
Si applica a
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
- Origine:
- Single.cs
Converte la rappresentazione 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 è riuscita o meno.
public:
static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result);
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);
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. Per interpretare l'intervallo, viene usato 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 relativamente a s
.
- result
- Single
Quando questo metodo viene restituito, contiene il numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo contenuto in s
, se la conversione ha esito positivo oppure zero se la conversione non riesce. La conversione ha esito negativo se il s
parametro è null
o Empty, non è conforme a style
, rappresenta un numero minore di Single.MinValue o maggiore di Single.MaxValue oppure se style
non è una combinazione valida di NumberStyles costanti enumerate. Questo parametro viene passato non inizializzato. Qualsiasi valore fornito in origine in result
verrà sovrascritto.
Restituisce
true
se s
è stato convertito correttamente; in caso contrario, false
.
Commenti
In .NET Core 3.0 e versioni successive i valori troppo grandi da rappresentare vengono arrotondati a o NegativeInfinity in base alle PositiveInfinity esigenze della specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare ha generato un errore.
Si applica a
TryParse(String, NumberStyles, IFormatProvider, Single)
- Origine:
- Single.cs
- Origine:
- Single.cs
- 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 è riuscita o meno.
public:
static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result);
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);
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 relativamente a s
.
- result
- Single
Quando questo metodo viene restituito, contiene il numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo contenuto in s
, se la conversione ha esito positivo oppure zero se la conversione non riesce. La conversione non riesce se il parametro s
è null
o Empty, se non è in un formato conforme a style
oppure 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 fornito in origine in result
verrà sovrascritto.
Restituisce
true
se s
è stato convertito correttamente; in caso contrario, false
.
Eccezioni
Esempio
Nell'esempio seguente viene illustrato l'uso del Single.TryParse(String, NumberStyles, IFormatProvider, Single) metodo 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 o NegativeInfinity in base alle PositiveInfinity esigenze della specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare ha generato un errore.
Questo overload è diverso dal Parse(String, NumberStyles, IFormatProvider) metodo restituendo un valore booleano che indica se l'operazione di analisi ha avuto esito positivo anziché restituire il valore numerico analizzato. Elimina la necessità di usare la gestione delle eccezioni per testare un FormatException oggetto nel caso in cui s
non sia valido e non possa essere analizzato correttamente.
Il style
parametro definisce il formato consentito del s
parametro per l'esito positivo dell'operazione di analisi. Deve essere una combinazione di flag di bit dell'enumerazione NumberStyles . I membri seguenti NumberStyles non sono supportati:
Il s
parametro può contenere PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol per le impostazioni cultura indicate da provider
. Inoltre, a seconda del valore di style
, il s
parametro può includere gli elementi seguenti:
[ws] [$] [sign] [cifre integrali,]cifre integrali[.fractional-digits][e[sign]exponential-digits][ws]
Gli elementi tra parentesi quadre ([e]) sono facoltativi. La tabella seguente descrive i singoli elementi.
Elemento | Descrizione |
---|---|
ws | Spazio vuoto facoltativo. Gli spazi vuoti possono essere visualizzati all'inizio di s se style include il NumberStyles.AllowLeadingWhite flag . Può essere visualizzato alla fine di s se style include il NumberStyles.AllowTrailingWhite flag . |
$ | Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalle NumberFormatInfo.CurrencyNegativePattern proprietà o NumberFormatInfo.CurrencyPositivePattern dell'oggetto NumberFormatInfo restituito dal IFormatProvider.GetFormat metodo del provider parametro . Il simbolo di valuta può essere visualizzato in s se style include il NumberStyles.AllowCurrencySymbol flag . |
sign | Segno facoltativo. Il segno può essere visualizzato all'inizio di s se include il NumberStyles.AllowLeadingSign flag e può essere visualizzato alla fine di s se style include il NumberStyles.AllowTrailingSignstyle flag . Le parentesi possono essere usate in s per indicare un valore negativo se style include il NumberStyles.AllowParentheses flag . |
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 NumberStyles.AllowThousands flag . |
. | Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo decimale delle impostazioni cultura corrente può essere visualizzato in s se style include il NumberStyles.AllowDecimalPoint flag . |
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 NumberStyles.AllowDecimalPoint flag . |
e | Carattere e o E, che indica che s può rappresentare un numero usando la notazione esponenziale. Il s parametro può rappresentare un numero in notazione esponenziale se lo stile include il NumberStyles.AllowExponent flag . |
cifre esponenziali | Serie di cifre comprese tra 0 e 9 che specificano un esponente. |
Nota
Qualsiasi carattere NUL di terminazione (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 se si trova nell'intervallo del Single tipo. Gli elementi di controllo membri rimanenti System.Globalization.NumberStyles che possono essere ma non devono essere presenti nella stringa di input. La tabella seguente indica in che modo i singoli NumberStyles flag influiscono sugli elementi che possono essere presenti in s
.
Valore NumberStyles | Elementi consentiti in s oltre alle cifre |
---|---|
None | Solo elemento a cifre integrali . |
AllowDecimalPoint | Elementi . e frazionari . |
AllowExponent | Il s parametro può anche usare la notazione esponenziale. Questo flag supporta da solo 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 di virgola decimale. |
AllowLeadingWhite | Elemento ws all'inizio di s . |
AllowTrailingWhite | Elemento ws alla fine di s . |
AllowLeadingSign | Elemento di segno all'inizio di s . |
AllowTrailingSign | Elemento di segno alla fine di s . |
AllowParentheses | Elemento di segno sotto forma di parentesi che racchiude il valore numerico. |
AllowThousands | Elemento , . |
AllowCurrencySymbol | Elemento $. |
Currency | Tutti. Il s parametro non può rappresentare un numero esadecimale o un numero in notazione esponenziale. |
Float | Elemento ws all'inizio o alla fine di , segno all'inizio di s s e il simbolo . Il s parametro può anche usare la notazione esponenziale. |
Number | Elementi ws separatore , sign migliaia di e decimali (.). |
Any | Tutti gli stili, tranne s non possono rappresentare un numero esadecimale. |
Il provider
parametro è un'implementazione il cui GetFormat metodo restituisce un IFormatProviderNumberFormatInfo oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura. Quando viene richiamato il metodo, chiama il TryParse(String, NumberStyles, IFormatProvider, Single)provider
metodo del GetFormat parametro e lo passa un Type oggetto che rappresenta il NumberFormatInfo tipo. Il GetFormat metodo restituisce quindi l'oggetto NumberFormatInfo che fornisce informazioni sul formato del s
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 di formattazione numerica per tali impostazioni cultura.
È possibile passare l'oggetto effettivo NumberFormatInfo che fornisce informazioni di formattazione numerica. (L'implementazione di GetFormat è stata appena restituita).
È 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 s
viene interpretata in base all'oggetto NumberFormatInfo delle impostazioni cultura correnti.
Se s
non è compreso nell'intervallo Single di dati, il metodo genera un OverflowException oggetto in .NET Framework e in .NET Core 2.2 e versioni precedenti. In .NET Core 3.0 e versioni successive, restituisce se è minore di Single.MinValue e Single.PositiveInfinity se s
è maggiore di Single.MaxValue.s
Single.NegativeInfinity
Se viene rilevato un separatore nel s
parametro durante un'operazione di analisi e i separatori decimali o numerici applicabili sono uguali, 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
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per