Double.TryParse Metodo

Definizione

Converte la rappresentazione di stringa di un numero nel rispettivo numero a virgola mobile a precisione doppia equivalente. Un valore restituito indica se la conversione è riuscita o meno.

Overload

TryParse(String, IFormatProvider, Double)

Tenta di analizzare una stringa in un valore.

TryParse(String, Double)

Converte la rappresentazione di stringa di un numero nel rispettivo numero a virgola mobile a precisione doppia equivalente. Un valore restituito indica se la conversione è riuscita o meno.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)

Tenta di analizzare un intervallo di caratteri in un valore.

TryParse(ReadOnlySpan<Char>, Double)

Converte la rappresentazione in forma di intervallo di un numero in uno stile e in un formato specifico delle impostazioni cultura specificati nel numero a virgola mobile e precisione doppia equivalente. Un valore restituito indica se la conversione è riuscita o meno.

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

Converte un intervallo di caratteri contenente la rappresentazione 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.

TryParse(String, NumberStyles, IFormatProvider, Double)

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 e precisione doppia 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 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.

TryParse(String, IFormatProvider, Double)

Tenta di analizzare una stringa in un valore.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = IParsable<double>::TryParse;
public static bool TryParse (string? s, IFormatProvider? provider, out double result);
static member TryParse : string * IFormatProvider * double -> bool
Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Double) As Boolean

Parametri

s
String

Stringa da analizzare.

provider
IFormatProvider

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

result
Double

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

Restituisce

Boolean

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

Si applica a

TryParse(String, Double)

Converte la rappresentazione di stringa di un numero nel rispettivo numero a virgola mobile a precisione doppia equivalente. Un valore restituito indica se la conversione è riuscita o meno.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] double % result);
public static bool TryParse (string s, out double result);
public static bool TryParse (string? s, out double result);
static member TryParse : string * double -> bool
Public Shared Function TryParse (s As String, ByRef result As Double) As Boolean

Parametri

s
String

Stringa che contiene un numero da convertire.

result
Double

Al momento della restituzione, questo metodo contiene il numero a virgola mobile a precisione doppia 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 Empty o non è un numero in formato valido. Ha inoltre esito negativo in .NET Framework e .NET Core 2.2 e versioni precedenti se s rappresenta un numero minore di Double.MinValue o maggiore di Double.MaxValue. Questo parametro viene passato non inizializzato. Qualsiasi valore fornito in origine in result verrà sovrascritto.

Restituisce

Boolean

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

Esempio

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

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "1,643.57", "$1,643.57", "-1.643e6",
                          "-168934617882109132", "123AE6",
                          null, String.Empty, "ABCDEF" };
      double number;

      foreach (var value in values) {
         if (Double.TryParse(value, out number))
            Console.WriteLine("'{0}' --> {1}", value, number);
         else
            Console.WriteLine("Unable to parse '{0}'.", value);
      }
   }
}
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.
open System

let values =
    [| "1,643.57"; "$1,643.57"; "-1.643e6"
       "-168934617882109132"; "123AE6"
       null; String.Empty; "ABCDEF" |]

for value in values do
    match Double.TryParse value with
    | true, number ->
        printfn $"'{value}' --> {number}"
    | _ ->
        printfn $"Unable to parse '{value}'."
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.
Module Example
   Public Sub Main()
      Dim values() As String = { "1,643.57", "$1,643.57", "-1.643e6", 
                                "-168934617882109132", "123AE6", 
                                Nothing, String.Empty, "ABCDEF" }
      Dim number As Double
      
      For Each value In values
         If Double.TryParse(value, number) Then
            Console.WriteLine("'{0}' --> {1}", value, number)
         Else
            Console.WriteLine("Unable to parse '{0}'.", value)      
         End If   
      Next   
   End Sub
End Module
' The example displays the following output:
'       '1,643.57' --> 1643.57
'       Unable to parse '$1,643.57'.
'       '-1.643e6' --> -1643000
'       '-168934617882109132' --> -1.68934617882109E+17
'       Unable to parse '123AE6'.
'       Unable to parse ''.
'       Unable to parse ''.
'       Unable to parse 'ABCDEF'.

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 Double.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 nel caso in cui s non sia valido e non possa essere analizzato correttamente.

Il s parametro può contenere le impostazioni cultura NumberFormatInfo.PositiveInfinitySymbolcorrenti , , NumberFormatInfo.NegativeInfinitySymbolNumberFormatInfo.NaNSymbol (il confronto tra stringhe fa distinzione tra maiuscole e minuscole) o una stringa del formato:

[ws] [sign] [cifre integrali,]cifre integrali[.[ fractional-digits]][e[sign]exponential-digits][ws]

Gli elementi tra parentesi quadre sono facoltativi. La tabella seguente descrive i singoli elementi.

Elemento Descrizione
ws Serie di spazi vuoti.
sign 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).
cifre esponenziali Serie di caratteri numerici compresi tra 0 e 9 che specificano un esponente.

Per altre informazioni sui formati numerici, vedere Formattazione dei tipi.

Il s parametro viene interpretato usando una combinazione di NumberStyles.Float flag e NumberStyles.AllowThousands . Ciò significa che sono consentiti spazi vuoti e migliaia di separatori, ma i simboli di valuta non sono consentiti. 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 Double.TryParse(String, NumberStyles, IFormatProvider, Double) 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 altre impostazioni cultura specificate, usare l'overload del Double.TryParse(String, NumberStyles, IFormatProvider, Double) metodo.

In genere, se si passa al Double.TryParse metodo una stringa creata chiamando il Double.ToString metodo , viene restituito il valore originale Double . Tuttavia, a causa di una perdita di precisione, i valori potrebbero non essere uguali. Inoltre, il tentativo di analizzare la rappresentazione di stringa di o Double.MinValueDouble.MaxValue non riesce a eseguire il round trip. In .NET Framework e .NET Core 2.2 e versioni precedenti genera un'eccezione OverflowException. In .NET Core 3.0 e versioni successive, restituisce Double.NegativeInfinityMinValue se si tenta di analizzare o Double.PositiveInfinity se si tenta di analizzare MaxValue. Nell'esempio seguente viene illustrato questo concetto.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      double number;

      value = Double.MinValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);

      value = Double.MaxValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.
open System

[<EntryPoint>]
let main _ = 
    let value = string Double.MinValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    let value = string Double.MaxValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    0
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.
Module Example
   Public Sub Main()
      Dim value As String
      Dim number As Double
      
      value = Double.MinValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
      
      value = Double.MaxValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
   End Sub
End Module
' The example displays the following output:
'    -1.79769313486232E+308 is outside the range of the Double type.
'    1.79769313486232E+308 is outside the range of the Double type.

In .NET Framework e .NET Core 2.2 e versioni precedenti, se s non è compreso nell'intervallo Double del tipo di dati, il TryParse(String, Double) metodo genera un'eccezione OverflowException.

In .NET Core 3.0 e versioni successive non viene generata alcuna eccezione quando s non è compreso nell'intervallo Double di dati. Nella maggior parte dei casi, il TryParse(String, Double) metodo calcola un risultato di Double.PositiveInfinity o Double.NegativeInfinity. Tuttavia, esiste un piccolo set di valori che vengono considerati più vicini ai valori massimi o minimi di Double rispetto all'infinito positivo o negativo. In questi casi, il metodo calcola un risultato di Double.MaxValue o Double.MinValue.

Se viene rilevato un separatore nel s parametro durante un'operazione di analisi e i separatori decimali e di gruppo 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<Char>, IFormatProvider, Double)

Tenta di analizzare un intervallo di caratteri in un valore.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = ISpanParsable<double>::TryParse;
public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out double result);
static member TryParse : ReadOnlySpan<char> * IFormatProvider * double -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Double) 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
Double

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

Restituisce

Boolean

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

Si applica a

TryParse(ReadOnlySpan<Char>, Double)

Converte la rappresentazione in forma di intervallo di un numero in uno stile e in un formato specifico delle impostazioni cultura specificati nel numero a virgola mobile e precisione doppia equivalente. Un valore restituito indica se la conversione è riuscita o meno.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] double % result);
public static bool TryParse (ReadOnlySpan<char> s, out double result);
static member TryParse : ReadOnlySpan<char> * double -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Double) As Boolean

Parametri

s
ReadOnlySpan<Char>

Intervallo di caratteri che contiene la rappresentazione stringa del numero da convertire.

result
Double

Al termine di questo metodo, contiene il numero a virgola mobile a precisione doppia equivalente al valore numerico o al simbolo contenuto nel parametro s, se la conversione ha esito positivo oppure zero se la conversione non riesce. La conversione non viene eseguita se il parametro s è null o vuoto oppure è in un formato non conforme a style. La conversione ha esito negativo anche se style non è una combinazione valida di costanti enumerate NumberStyles. Se s è un numero valido minore di Double.MinValue, result è NegativeInfinity. Se s è un numero valido maggiore di Double.MaxValue, result è PositiveInfinity. Questo parametro viene passato non inizializzato. Qualsiasi valore fornito in origine in result verrà sovrascritto.

Restituisce

Boolean

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(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)

Converte un intervallo di caratteri contenente la rappresentazione 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(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result);
public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;
public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out double result);
public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out double result);
static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * double -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Double) As Boolean

Parametri

s
ReadOnlySpan<Char>

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

style
NumberStyles

Combinazione bit per bit dei valori NumberStyles che indicano 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
Double

Al termine di questo metodo e se la conversione ha esito positivo, contiene il numero a virgola mobile a precisione doppia equivalente al valore numerico o al simbolo contenuto in s. In caso di conversione non riuscita, contiene zero. La conversione non riesce se il parametro s è null, un intervallo di caratteri vuoto oppure non è un numero in un formato conforme a style. Se s è un numero valido minore di Double.MinValue, result è NegativeInfinity. Se s è un numero valido maggiore di Double.MaxValue, result è PositiveInfinity. Questo parametro viene passato non inizializzato. Qualsiasi valore fornito in origine in result verrà sovrascritto.

Restituisce

Boolean

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, Double)

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 e precisione doppia 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] double % result);
public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;
public static bool TryParse (string s, System.Globalization.NumberStyles style, IFormatProvider provider, out double result);
public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out double result);
static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * double -> bool
Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Double) As Boolean

Parametri

s
String

Stringa che contiene un numero da convertire.

style
NumberStyles

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

provider
IFormatProvider

Oggetto IFormatProvider che fornisce informazioni di formattazione specifiche delle impostazioni cultura relative a s.

result
Double

Quando questo metodo viene restituito, contiene il numero a virgola mobile a precisione doppia 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 oppure se non è in un formato conforme a style oppure se style non è una combinazione valida di costanti di enumerazione NumberStyles. Non riesce anche in .NET Framework o .NET Core 2.2 e versioni precedenti se s rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue. Questo parametro viene passato non inizializzato. Qualsiasi valore fornito in origine in result verrà sovrascritto.

Restituisce

Boolean

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

Eccezioni

style non è un valore di NumberStyles.

-oppure-

style include il valore di AllowHexSpecifier.

Esempio

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

string value;
NumberStyles style;
CultureInfo culture;
double number;

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

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

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

value = "1 345,978";
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Unable to convert '1 345,978'.
// Parse currency value using en-GB culture.
let value = "£1,097.63"
let style = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
let culture = CultureInfo.CreateSpecificCulture "en-GB"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Converted '£1,097.63' to 1097.63.

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

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

let value = "1 345,978"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Unable to convert '1 345,978'.
Dim value As String
Dim style As NumberStyles
Dim culture As CultureInfo
Dim number As Double

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

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

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

value = "1 345,978"
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays:
'       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.

Il TryParse metodo è simile al metodo , ad eccezione di Parse(String, NumberStyles, IFormatProvider) questo metodo non genera un'eccezione se la conversione non riesce. Se la conversione ha esito positivo, il valore restituito è true e il result parametro viene impostato sul risultato della conversione. Se la conversione non riesce, il valore restituito è false e il result parametro è impostato su zero. In questo modo si 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 NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.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 Double 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 s, segno all'inizio di se il simbolo . Il s parametro può anche usare la notazione esponenziale.
Number Elementi wsseparatore , sign, migliaia (,) e separatore decimale (.).
Any Tutti gli stili, tranne s che non possono rappresentare un numero esadecimale.

Il provider parametro è un'implementazione IFormatProvider , ad esempio un NumberFormatInfo oggetto o CultureInfo . Il provider parametro fornisce informazioni specifiche delle impostazioni cultura usate per l'analisi. Se provider è o non è null possibile ottenere un NumberFormatInfo oggetto, vengono utilizzate le informazioni sul formato per le impostazioni cultura correnti.

La conversione non riesce se il s parametro è o non è null un valore numerico, il provider parametro non restituisce un NumberFormatInfo oggetto o il style parametro non è una combinazione di flag di bit dall'enumerazione NumberStyles .

In genere, se si passa al Double.TryParse metodo una stringa creata chiamando il Double.ToString metodo , viene restituito il valore originale Double . Tuttavia, a causa di una perdita di precisione, i valori potrebbero non essere uguali. Inoltre, il tentativo di analizzare la rappresentazione di stringa di o Double.MinValueDouble.MaxValue non riesce a eseguire il round trip. In .NET Framework e .NET Core 2.2 e versioni precedenti genera un'eccezione OverflowException. In .NET Core 3.0 e versioni successive, restituisce Double.NegativeInfinityMinValue se si tenta di analizzare o Double.PositiveInfinity se si tenta di analizzare MaxValue. Nell'esempio seguente viene illustrato questo concetto.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      double number;

      value = Double.MinValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);

      value = Double.MaxValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.
open System

[<EntryPoint>]
let main _ = 
    let value = string Double.MinValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    let value = string Double.MaxValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    0
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.
Module Example
   Public Sub Main()
      Dim value As String
      Dim number As Double
      
      value = Double.MinValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
      
      value = Double.MaxValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
   End Sub
End Module
' The example displays the following output:
'    -1.79769313486232E+308 is outside the range of the Double type.
'    1.79769313486232E+308 is outside the range of the Double type.

In .NET Framework e .NET Core 2.2 e versioni precedenti, se s non è compreso nell'intervallo Double del tipo di dati, il Double.TryParse(String, NumberStyles, IFormatProvider, Double) metodo genera un'eccezione OverflowException.

In .NET Core 3.0 e versioni successive non viene generata alcuna eccezione quando s non è compreso nell'intervallo Double di dati. Nella maggior parte dei casi, il Double.TryParse(String, NumberStyles, IFormatProvider, Double) metodo calcola un risultato di Double.PositiveInfinity o Double.NegativeInfinity. Tuttavia, esiste un piccolo set di valori che vengono considerati più vicini ai valori massimi o minimi di Double rispetto all'infinito positivo o negativo. In questi casi, il metodo calcola un risultato di Double.MaxValue o Double.MinValue.

Se viene rilevato un separatore nel s parametro durante un'operazione di analisi e i separatori decimali o numerici e di gruppo 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

Si applica a