Double.TryParse Metodo

Origine:

Double.cs

Origine:

Double.cs

Origine:

Double.cs

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

Restituisce

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

Origine:

Double.cs

Origine:

Double.cs

Origine:

Double.cs

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

Restituisce

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.

Origine:

Double.cs

Origine:

Double.cs

Origine:

Double.cs

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

Restituisce

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

Esempio

Nell'esempio seguente viene utilizzato il metodo TryParse(String, Double) per convertire le rappresentazioni di stringa di valori numerici in valori Double. Si presuppone che en-US sia la lingua 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 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 Double.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 le impostazioni cultura correnti NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbol, NumberFormatInfo.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.

Per altre informazioni sui formati numerici, vedere Tipi di formattazione.

Il parametro s viene interpretato usando una combinazione dei 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 Double.TryParse(String, NumberStyles, IFormatProvider, Double).

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 Double.TryParse(String, NumberStyles, IFormatProvider, Double).

In genere, se si passa il metodo Double.TryParse una stringa creata chiamando il metodo Double.ToString, viene restituito il valore Double originale. Tuttavia, a causa di una perdita di precisione, i valori potrebbero non essere uguali. Inoltre, il tentativo di analizzare la rappresentazione di stringa di Double.MinValue o Double.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.NegativeInfinity se si tenta di analizzare MinValue o Double.PositiveInfinity se si tenta di analizzare MaxValue. Nell'esempio seguente viene fornita un'illustrazione.

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 del tipo di dati Double, il metodo TryParse(String, Double) genera un OverflowException.

In .NET Core 3.0 e versioni successive non viene generata alcuna eccezione quando s non è compreso nell'intervallo del tipo di dati Double. Nella maggior parte dei casi, il metodo TryParse(String, Double) 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 parametro s durante un'operazione di analisi e i separatori decimali e di gruppo 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
• esempio : Utilità di formattazione WinForms .NET Core (C#)
• esempio : Utilità di formattazione WinForms .NET Core (Visual Basic)

Origine:

Double.cs

Origine:

Double.cs

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

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

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

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

Parametri

Restituisce

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

Origine:

Double.cs

Origine:

Double.cs

Origine:

Double.cs

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

Restituisce

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

Origine:

Double.cs

Origine:

Double.cs

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

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

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

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

Parametri

Restituisce

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

Origine:

Double.cs

Origine:

Double.cs

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

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

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

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

Parametri

Restituisce

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

Origine:

Double.cs

Origine:

Double.cs

Origine:

Double.cs

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

Restituisce

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.

Origine:

Double.cs

Origine:

Double.cs

Origine:

Double.cs

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

Restituisce

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

Eccezioni

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo Double.TryParse(String, NumberStyles, IFormatProvider, Double) 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 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.

Il metodo TryParse è simile al metodo Parse(String, NumberStyles, IFormatProvider), ad eccezione di questo metodo non genera un'eccezione se la conversione non riesce. Se la conversione ha esito positivo, il valore restituito viene true e il parametro result viene impostato sul risultato della conversione. Se la conversione non riesce, il valore restituito viene false e il parametro result è impostato su zero. In questo modo si 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 NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.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.

Una stringa con solo cifre (che corrisponde allo stile NumberStyles.None) analizza sempre correttamente se si trova nell'intervallo del tipo Double. 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.

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

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

In genere, se si passa il metodo Double.TryParse una stringa creata chiamando il metodo Double.ToString, viene restituito il valore Double originale. Tuttavia, a causa di una perdita di precisione, i valori potrebbero non essere uguali. Inoltre, il tentativo di analizzare la rappresentazione di stringa di Double.MinValue o Double.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.NegativeInfinity se si tenta di analizzare MinValue o Double.PositiveInfinity se si tenta di analizzare MaxValue. Nell'esempio seguente viene fornita un'illustrazione.

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 del tipo di dati Double, il metodo Double.TryParse(String, NumberStyles, IFormatProvider, Double) genera un OverflowException.

In .NET Core 3.0 e versioni successive non viene generata alcuna eccezione quando s non è compreso nell'intervallo del tipo di dati Double. Nella maggior parte dei casi, il metodo Double.TryParse(String, NumberStyles, IFormatProvider, Double) 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 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

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