Double.TryParse Método

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

Parâmetros

Devoluções

true se s foi convertido com sucesso; caso contrário, false.

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::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

Parâmetros

Devoluções

true se s foi convertido com sucesso; caso contrário, false.

Exemplos

O exemplo seguinte utiliza o TryParse(String, Double) método para converter as representações de cadeias de valores numéricos em Double valores. Pressupõe que en-US é a cultura atual.

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'.

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

Esta sobrecarga difere do Double.Parse(String) método por devolver um valor booleano que indica se a operação de análise analisada teve sucesso, em vez de devolver o valor numérico analisado. Elimina a necessidade de usar o tratamento de exceções para testar a FormatException caso este s seja inválido e não possa ser analisado com sucesso.

O s parâmetro pode conter o símbolo da NumberFormatInfo.PositiveInfinitySymbolcultura atual, NumberFormatInfo.NegativeInfinitySymbol, NumberFormatInfo.NaNSymbol ou símbolo. Esta comparação de strings é insensível a maiúsculas minúsculas no .NET Core 3.0 e versões posteriores, mas é sensível a maiúsculas minúsculas em versões anteriores, incluindo o .NET Framework. O s parâmetro pode também ser uma cadeia da forma:

[ws][sinal][dígitos integrais,] dígitos integrais[.[ dígitos fracionários]][dígitos exponenciais e[signo][ws]

Os elementos entre parênteses retos são opcionais. A tabela a seguir descreve cada elemento.

Elemento	Description
ws	Uma série de caracteres em espaços em branco.
assinar	Um sinal negativo ou símbolo positivo.
dígitos integrais	Uma série de caracteres numéricos de 0 a 9 que especificam a parte integral do número. Os dígitos integrais podem estar ausentes se existirem dígitos fracionários.
,	Um símbolo separador de grupo específico de cada cultura.
.	Um símbolo de ponto decimal específico para cada cultura.
Dígitos fracionários	Uma série de caracteres numéricos de 0 a 9 que especificam a parte fracionária do número.
E	Um caractere maiúsculo ou minúsculo 'e', que indica notação exponencial (científica).
Dígitos exponenciais	Uma série de caracteres numéricos de 0 a 9 que especificam um expoente.

Para mais informações sobre formatos numéricos, consulte Tipos de Formatação.

O s parâmetro é interpretado usando uma combinação das NumberStyles.Float flags e NumberStyles.AllowThousands . Isto significa que o espaço em branco e os separadores de milhares são permitidos, mas os símbolos de moeda não. Para definir explicitamente os elementos (como símbolos de moeda, separadores de milhares e espaços em branco) que podem estar presentes em s, use o Double.TryParse(String, NumberStyles, IFormatProvider, Double) método overload.

O s parâmetro é analisado usando a informação de formatação num NumberFormatInfo objeto que é inicializado para a cultura do sistema atual. Para obter mais informações, veja NumberFormatInfo.CurrentInfo. Para analisar uma string usando a informação de formatação de outra cultura especificada, use o Double.TryParse(String, NumberStyles, IFormatProvider, Double) método overload.

Normalmente, se passar ao Double.TryParse método uma cadeia criada ao chamar o Double.ToString método, o valor original Double é devolvido. No entanto, devido à perda de precisão, os valores podem não ser iguais. Além disso, tentar analisar a representação da cadeia de qualquer um Double.MinValue ou Double.MaxValue falha em fazer round-trip. No .NET Framework, lança um OverflowException. No .NET Core 3.0 e versões posteriores, devolve Double.NegativeInfinity se tentares analisar MinValue, ou Double.PositiveInfinity se tentares analisar MaxValue. O exemplo a seguir fornece uma ilustração.

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.

No .NET Framework, se s estiver fora do alcance do tipo de dado Double, o método TryParse(String, Double) lança um OverflowException.

Em versões .NET Core 3.0 e posteriores, não é feita exceção quando s está fora do alcance do tipo de dados Double. Na maioria dos casos, o TryParse(String, Double) método calcula um resultado de Double.PositiveInfinity ou Double.NegativeInfinity. No entanto, existe um pequeno conjunto de valores que são considerados mais próximos dos valores máximos ou mínimos de Double do que do infinito positivo ou negativo. Nesses casos, o método calcula um resultado de Double.MaxValue ou Double.MinValue.

Se um separador for encontrado no s parâmetro durante uma operação de análise sintática, e os separadores decimais e de grupo forem os mesmos, a operação de análise analisar assume que o separador é um separador decimal e não um separador de grupo. Para mais informações sobre separadores, veja CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator, e NumberGroupSeparator.

Ver também

• Parse(String)
• ToString()
• Análise de Cadeias Numéricas em .NET
• Exemplo: Utilitário de formatação WinForms .NET Core (C#)
• Exemplo: Utilitário de formatação do .NET Core WinForms (Visual Basic)

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

Parâmetros

Devoluções

true se s foi convertido com sucesso; caso contrário, false.

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::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

Parâmetros

Devoluções

true se s foi convertido com sucesso; caso contrário, false.

Exceções

Exemplos

O exemplo seguinte demonstra o uso do Double.TryParse(String, NumberStyles, IFormatProvider, Double) método para analisar a representação de cadeias de números que têm um estilo particular e são formatados segundo as convenções de uma cultura particular.

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'.

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

O TryParse método é semelhante ao Parse(String, NumberStyles, IFormatProvider) método, exceto que este método não lança exceção se a conversão falhar. Se a conversão for bem-sucedida, o valor de retorno é true e o result parâmetro é definido para o resultado da conversão. Se a conversão falhar, o valor de retorno é false e o result parâmetro é definido para zero. Isto elimina a necessidade de usar o tratamento de exceções para testar a FormatException caso este s seja inválido e não possa ser analisado com sucesso.

O style parâmetro define o formato permitido do s parâmetro para que a operação de análise sintática tenha sucesso. Deve ser uma combinação de indicadores de bits da NumberStyles enumeração. Os seguintes NumberStyles membros não são apoiados:

• NumberStyles.AllowHexSpecifier

• NumberStyles.HexNumber

O s parâmetro pode conter NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbol, ou NumberFormatInfo.NaNSymbol símbolo para a cultura indicado por provider. Esta comparação de strings é insensível a maiúsculas minúsculas no .NET Core 3.0 e versões posteriores, mas é sensível a maiúsculas minúsculas em versões anteriores, incluindo o .NET Framework. Além disso, dependendo do valor de style, o s parâmetro pode incluir os seguintes elementos:

[ws] [$] [sinal][dígitos integrais,]dígitos integrais[.dígitos fracionários][dígitos exponenciais e[signo]ws]

Os elementos entre parênteses retos ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento	Description
ws	Espaço em branco opcional. O espaço em branco pode aparecer no início de s if style inclui a NumberStyles.AllowLeadingWhite bandeira. Pode aparecer no final de s se style incluir a NumberStyles.AllowTrailingWhite bandeira.
$	Um símbolo monetário específico de cada cultura. A sua posição na cadeia é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades ou NumberFormatInfo.CurrencyPositivePattern do NumberFormatInfo objeto devolvidas pelo IFormatProvider.GetFormat método do provider parâmetro. O símbolo da moeda pode aparecer se sstyle incluir a NumberStyles.AllowCurrencySymbol bandeira.
assinar	Um sinal opcional. O sinal pode aparecer no início de s se inclui a NumberStyles.AllowLeadingSign bandeira, e pode aparecer no final de s se style inclui a NumberStyles.AllowTrailingSignstyle bandeira. Parênteses podem ser usados s para indicar um valor negativo se style incluir a NumberStyles.AllowParentheses bandeira.
dígitos integrais	Uma série de dígitos de 0 a 9 que especificam a parte integral do número. Os dígitos integrais podem estar ausentes se existirem dígitos fracionários.
,	Um símbolo separador de milhares específico de cultura. O símbolo separador dos milhares da cultura atual pode aparecer se sstyle incluir a NumberStyles.AllowThousands bandeira.
.	Um símbolo de ponto decimal específico para cada cultura. O símbolo de ponto decimal da cultura atual pode aparecer em s se style incluir a NumberStyles.AllowDecimalPoint bandeira.
Dígitos fracionários	Uma série de dígitos de 0 a 9 que especificam a parte fracionária do número. Dígitos fracionários podem aparecer em s se style incluir a NumberStyles.AllowDecimalPoint bandeira.
e	O carácter e ou E, que indica que s pode representar um número usando notação exponencial. O s parâmetro pode representar um número em notação exponencial se o estilo incluir a NumberStyles.AllowExponent bandeira.
Dígitos exponenciais	Uma série de dígitos que variam de 0 a 9 que especificam um expoente.

Uma cadeia apenas com dígitos (que corresponde ao NumberStyles.None estilo) analisa sempre com sucesso se estiver no intervalo do Double tipo. Os restantes System.Globalization.NumberStyles elementos controlam elementos que podem estar, mas não são obrigados a estar, presentes na cadeia de entrada. A tabela seguinte indica como as bandeiras individuais NumberStyles afetam os elementos que podem estar presentes em s.

Valor de NumberStyles	Elementos permitidos em s além dos dígitos
None	Apenas o elemento de dígitos integrais .
AllowDecimalPoint	Os elementos de . e de dígitos fracionários.
AllowExponent	O s parâmetro também pode usar notação exponencial. Este flag, por si só, suporta valores na forma de dígitos integraisE dígitos exponenciais; São necessárias bandeiras adicionais para analisar com sucesso cadeias em notação exponencial com elementos como sinais positivos ou negativos e símbolos de ponto decimal.
AllowLeadingWhite	O elemento ws no início de s.
AllowTrailingWhite	O elemento ws no final de s.
AllowLeadingSign	O elemento signo no início de s.
AllowTrailingSign	O elemento signo no final de s.
AllowParentheses	O elemento do signo na forma de parênteses que envolvem o valor numérico.
AllowThousands	O elemento ,
AllowCurrencySymbol	O $ elemento.
Currency	Todos. O s parâmetro não pode representar um número hexadecimal ou um número em notação exponencial.
Float	O elemento ws no início ou fim de s, sinal no início de s, e o símbolo . O s parâmetro também pode usar notação exponencial.
Number	Os wselementos, sign, milhares, separadores (,), e ponto decimal (.).
Any	Todos os estilos, exceto s , não podem representar um número hexadecimal.

O provider parâmetro é uma IFormatProvider implementação, como um NumberFormatInfo objeto ou CultureInfo . O provider parâmetro fornece informação específica da cultura utilizada na análise sintática. Se provider é null ou um NumberFormatInfo objeto não puder ser obtido, utiliza-se a informação de formato para a cultura atual.

A conversão falha se o s parâmetro for null ou não um valor numérico, se o provider parâmetro não produzir um NumberFormatInfo objeto, ou se o style parâmetro não for uma combinação de indicadores de bits da NumberStyles enumeração.

Normalmente, se passar ao Double.TryParse método uma cadeia criada ao chamar o Double.ToString método, o valor original Double é devolvido. No entanto, devido à perda de precisão, os valores podem não ser iguais. Além disso, tentar analisar a representação da cadeia de qualquer um Double.MinValue ou Double.MaxValue falha em fazer round-trip. No .NET Framework, lança um OverflowException. No .NET Core 3.0 e versões posteriores, devolve Double.NegativeInfinity se tentares analisar MinValue, ou Double.PositiveInfinity se tentares analisar MaxValue. O exemplo a seguir fornece uma ilustração.

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.

No .NET Framework, se s estiver fora do alcance do tipo de dado Double, o método Double.TryParse(String, NumberStyles, IFormatProvider, Double) lança um OverflowException.

Em versões .NET Core 3.0 e posteriores, não é feita exceção quando s está fora do alcance do tipo de dados Double. Na maioria dos casos, o Double.TryParse(String, NumberStyles, IFormatProvider, Double) método calcula um resultado de Double.PositiveInfinity ou Double.NegativeInfinity. No entanto, existe um pequeno conjunto de valores que são considerados mais próximos dos valores máximos ou mínimos de Double do que do infinito positivo ou negativo. Nesses casos, o método calcula um resultado de Double.MaxValue ou Double.MinValue.

Se um separador for encontrado no s parâmetro durante uma operação de análise sintática, e os separadores decimais e de grupo de moeda ou número aplicáveis forem os mesmos, a operação de análise analisar assume que o separador é um separador decimal e não um separador de grupo. Para mais informações sobre separadores, veja CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator, e NumberGroupSeparator.

Ver também

• ToString()
• Análise de Cadeias Numéricas em .NET